【算法篇】回溯算法类（1）（笔记）

CXDNW2024-10-03 20:28

目录

一、理论基础

[1. 相关题目](#1. 相关题目)

[2. 遍历过程](#2. 遍历过程)

[3. 代码框架](#3. 代码框架)

[二、LeetCode 题目](#二、LeetCode 题目)

[1. 组合](#1. 组合)

[2. 组合总和III](#2. 组合总和III)

[3. 电话号码的字母组合](#3. 电话号码的字母组合)

[4. 组合总和](#4. 组合总和)

[5. 组合总和II](#5. 组合总和II)

[6. 分割回文串](#6. 分割回文串)

[7. 复原IP地址](#7. 复原IP地址)

[8. 子集](#8. 子集)

一、理论基础

1. 相关题目

2. 遍历过程

3. 代码框架

cpp 复制代码 
void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

二、LeetCode 题目

1. 组合

https://leetcode.cn/problems/combinations/description/https://leetcode.cn/problems/combinations/description/

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。你可以按 任何顺序 返回答案。

bash 复制代码 
示例 1：
输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2：
输入：n = 1, k = 1
输出：[[1]]
cpp 复制代码 
class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(int n, int k, int startIndex) {
        // 满足条件插入
        if (path.size() == k) {
            result.push_back(path);
            return;
        }

        // 如果后面的数组满足不了能取出 k - path.size() 个数组，则不用遍历了
        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) {
            path.push_back(i);
            backtracking(n, k, i + 1);
            path.pop_back();
        }

        return;
    }

    vector<vector<int>> combine(int n, int k) {
        backtracking(n, k, 1);
        return result;
    }
};

2. 组合总和III

https://leetcode.cn/problems/combination-sum-iii/description/https://leetcode.cn/problems/combination-sum-iii/description/

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

  • 只使用数字 1 到 9
  • 每个数字 最多使用一次

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

bash 复制代码 
示例 1:
输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

示例 2:
输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。

示例 3:
输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。
cpp 复制代码 
class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(int targetSum, int k, int sum, int startIndex) {
        if (path.size() == k) {
            if (targetSum == sum) result.push_back(path);
            return;
        }

        // 剪枝
        for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
            sum += i;
            path.push_back(i);
            backtracking(targetSum, k, sum, i + 1);
            sum -= i;
            path.pop_back();
        }

        return;
    }

    vector<vector<int>> combinationSum3(int k, int n) {
        backtracking(n, k, 0, 1);
        return result;
    }
};

3. 电话号码的字母组合

https://leetcode.cn/problems/letter-combinations-of-a-phone-number/description/https://leetcode.cn/problems/letter-combinations-of-a-phone-number/description/

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

bash 复制代码 
示例 1：
输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

示例 2：
输入：digits = ""
输出：[]

示例 3：
输入：digits = "2"
输出：["a","b","c"]
cpp 复制代码 
class Solution {
private:
    const string letterMap[10] = {
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz", // 9
    };
public:
    vector<string> result;
    string s;
    void backtracking(const string& digits, int index) {
        if (index == digits.size()) {
            result.push_back(s);
            return;
        }
        int digit = digits[index] - '0';        // 将index指向的数字转为int
        string letters = letterMap[digit];      // 取数字对应的字符集
        for (int i = 0; i < letters.size(); i++) {
            s.push_back(letters[i]);            // 处理
            backtracking(digits, index + 1);    // 递归，注意index+1，一下层要处理下一个数字了
            s.pop_back();                       // 回溯
        }
    }
    vector<string> letterCombinations(string digits) {
        s.clear();
        result.clear();
        if (digits.size() == 0) {
            return result;
        }
        backtracking(digits, 0);
        return result;
    }
};

4. 组合总和

https://leetcode.cn/problems/combination-sum/description/https://leetcode.cn/problems/combination-sum/description/

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

bash 复制代码 
示例 1：
输入：candidates = [2,3,6,7], 
target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：
输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：
输入: candidates = [2], target = 1
输出: []
cpp 复制代码 
class Solution {
public:
    vector<vector<int>> result;
    vector<int> record;
    void backtracking(vector<int>& candidates, int targetnum, int sum, int startIndex) {
        if (sum == targetnum) {
            result.push_back(record);
            return;
        }

        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= targetnum; i++) {
            record.push_back(candidates[i]);
            backtracking(candidates, targetnum, sum + candidates[i], i);
            record.pop_back();
        }

        return;
    }

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end()); // 需要排序
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

5. 组合总和II

https://leetcode.cn/problems/combination-sum-ii/description/https://leetcode.cn/problems/combination-sum-ii/description/

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。

bash 复制代码 
示例 1:
输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:
输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]
cpp 复制代码 
// 方法一：
class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int startIndex, int target) {
        if (target == 0) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i < candidates.size() && target - candidates[i] >= 0; i++) {
            if (i > startIndex && candidates[i] == candidates[i - 1]) {
                continue;
            }
            path.push_back(candidates[i]);
            backtracking(candidates, i + 1, target - candidates[i]);
            path.pop_back();
        }
        return;
    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, 0, target);
        return result;
    }
};


// 方法二：
class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int startIndex, int target) {
        if (target == 0) {
            result.push_back(path);
            return;
        }

        unordered_set<int> uset;
        for (int i = startIndex; i < candidates.size() && target - candidates[i] >= 0; i++) {
            if (uset.find(candidates[i]) != uset.end()) {
                continue;
            }
            uset.insert(candidates[i]);
            path.push_back(candidates[i]);
            backtracking(candidates, i + 1, target - candidates[i]);
            path.pop_back();
        }
        return;
    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, 0, target);
        return result;
    }
};

6. 分割回文串

https://leetcode.cn/problems/palindrome-partitioning/description/https://leetcode.cn/problems/palindrome-partitioning/description/

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

bash 复制代码 
示例 1：
输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：
输入：s = "a"
输出：[["a"]]
cpp 复制代码 
class Solution {
public:
    vector<vector<string>> result;
    vector<string> st;
    void backtracking(const string s, int beginIndex) {
        // 找到一种切割方法
        if (beginIndex == s.size()) {
            result.push_back(st);
            return;
        }

        for (int i = beginIndex; i < s.size(); i++) {
            if (isPalindrome(s, beginIndex, i)) {
                // 是回文子串，保存
                st.push_back(s.substr(beginIndex, i - beginIndex + 1));
            }
            else {
                continue;
            }
            backtracking(s, i + 1);
            st.pop_back();
        }

        return;
    }

    bool isPalindrome(const string s, int begin, int end) {
        for (int i = begin, j = end; i < j; i++, j--) {
            if (s[i] != s[j]) return false;
        }
        return true;
    }

    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;
    }
};

7. 复原IP地址

https://leetcode.cn/problems/restore-ip-addresses/description/https://leetcode.cn/problems/restore-ip-addresses/description/

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

  • 例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

bash 复制代码 
示例 1：
输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]

示例 2：
输入：s = "0000"
输出：["0.0.0.0"]

示例 3：
输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]
cpp 复制代码 
// 版本一：
class Solution {
public:
    vector<string> result;
    vector<string> st;
    void backtracking(const string s, int beginIndex) {
        if (beginIndex == s.size()) {
            if (st.size() == 4) {
                string buff = st.front();
                for (int j = 1; j < 4; j++)  buff = buff + "." + st[j];
                result.push_back(buff);
                return;
            }
            else {
                return;
            }
        }

        for (int i = beginIndex; i < s.size(); i++) {
            if (judgeNum(s, beginIndex, i)) {
                // 在范围内
                st.push_back(s.substr(beginIndex, i - beginIndex + 1));
                backtracking(s, i + 1);
                st.pop_back();
            }
            else {
                break;
            }
        }

        return;
    }

    bool judgeNum(const string& s, int start, int end) {
    if (start > end) {
        return false;
    }
    if (s[start] == '0' && start != end) { // 0开头的数字不合法
            return false;
    }
    int num = 0;
    for (int i = start; i <= end; i++) {
        if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
            return false;
        }
        num = num * 10 + (s[i] - '0');
        if (num > 255) { // 如果大于255了不合法
            return false;
        }
    }
    return true;
}

    vector<string> restoreIpAddresses(string s) {
        backtracking(s, 0);
        return result;
    }
};


// 版本二：
class Solution {
private:
    vector<string> result;  // 记录结果

    // startIndex: 搜索的起始位置，pointNum:添加逗点的数量
    void backtracking(string& s, int startIndex, int pointNum) {
        if (pointNum == 3) { // 逗点数量为3时，分隔结束
            // 判断第四段子字符串是否合法，如果合法就放进result中
            if (isValid(s, startIndex, s.size() - 1)) {
                result.push_back(s);
            }
            return;
        }

        for (int i = startIndex; i < s.size(); i++) {
            if (isValid(s, startIndex, i)) { // 判断 [startIndex, i] 这个区间的子串是否合法
                s.insert(s.begin() + i + 1 , '.');  // 在i的后面插入一个逗点
                pointNum++;
                backtracking(s, i + 2, pointNum);   // 插入逗点之后下一个子串的起始位置为i+2
                pointNum--;                         // 回溯
                s.erase(s.begin() + i + 1);         // 回溯删掉逗点
            } else {
                break; // 不合法，直接结束本层循环
            }
        }
    }

    // [start, end]
    bool isValid(const string& s, int start, int end) {
        if (start > end) {
            return false;
        }
        if (s[start] == '0' && start != end) { // 0开头的数字不合法
                return false;
        }
        int num = 0;
        for (int i = start; i <= end; i++) {
            if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
                return false;
            }
            num = num * 10 + (s[i] - '0');
            if (num > 255) { // 如果大于255了不合法
                return false;
            }
        }
        return true;
    }

public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        if (s.size() < 4 || s.size() > 12) return result; // 算是剪枝了
        backtracking(s, 0, 0);
        return result;
    }
};

8. 子集

https://leetcode.cn/problems/subsets/description/https://leetcode.cn/problems/subsets/description/

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

bash 复制代码 
示例 1：
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：
输入：nums = [0]
输出：[[],[0]]
cpp 复制代码 
class Solution {
public:
    vector<vector<int>> result;
    vector<int> vec;
    void backtracking(vector<int>& nums, int beginIndex) {
        result.push_back(vec);
        if (beginIndex >= nums.size()) {
            return;
        }

        for (int i = beginIndex; i < nums.size(); i++) {
            vec.push_back(nums[i]);
            backtracking(nums, i + 1);
            vec.pop_back();
        }
        return;
    }

    vector<vector<int>> subsets(vector<int>& nums) {
        if (nums.size() == 0) return result;
        backtracking(nums, 0);
        return result;
    }
};
相关推荐
王俊山IT1 分钟前
C++学习笔记----10、模块、头文件及各种主题（一）---- 模块（1）
开发语言·c++·笔记·学习
weixin_537590455 分钟前
《C++ Primer Plus》中文版第二章习题
开发语言·c++·visual studio
RationalDysaniaer12 分钟前
Gin入门笔记
笔记·gin
阑梦清川14 分钟前
数学建模启发式算法篇（一）---遗传算法
算法·数学建模·启发式算法
xing251621 分钟前
张氏宗谱序言白话文翻译
笔记
ErvinHowell28 分钟前
文件MD5生成性能大提升！如何实现分片与Worker优化
前端·vue.js·算法
用户405478783748229 分钟前
深度学习笔记 - Pytorch自搭建VGG-16模型实现人脸识别
算法
很透彻34 分钟前
【网络】传输层协议TCP（下）
网络·c++·网络协议·tcp/ip
益达爱喝芬达42 分钟前
力扣11.3
算法·leetcode
y_m_h42 分钟前
leetcode912.排序数组的题解
数据结构·算法
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）05红米手机使用google play06【经验分享】Ubuntu22.04安装微信(linux官方版)07【AIGC】重塑未来的科技巨轮08【Java】Ruoyi-Vue-Plus 整合 文件分片上传至 minio、阿里云、七牛云等OSS-【后端篇】09RAG 实践- Ollama+RagFlow 部署本地知识库10Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO