回溯算法知识总结

1. 什么是回溯 怎么用（回溯本质及模版）

底层逻辑：解决树形结构问题、用到递归逻辑、穷举本质优化靠剪枝。

回溯模版：

1. 建立回溯函数（一般以void返回）难点：如何选取参数 （index，sum，used，... ）

void backtracking(参数)

2. 回溯终止条件 难点：如何对应终止条件 

if (终止条件) {
    存放结果;
    return;
}

3. 单层遍历规则 （广搜（横向遍历）靠for循环，深搜（纵向遍历）靠递归）（例外：电话问题）

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

4. 模版总结

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

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

2. 什么时候用 （解决问题/适用场景）

组合问题（不强调顺序）：输入一个数组/字符串 和 目标值，输出题目要求的集合解

• 例如：39. 组合总和 - 力扣（LeetCode）或 216. 组合总和 III - 力扣（LeetCode）

切割问题：输入一个数组/字符串，输出题目要求的切割形式

• 例如：131. 分割回文串 - 力扣（LeetCode）或 93. 复原 IP 地址 - 力扣（LeetCode）

子集问题（（需全取元素）特殊组合问题）：输入一个数组/字符串，输出题目要求的所有子集

• 例如：90. 子集 II - 力扣（LeetCode）或 491. 递增子序列 - 力扣（LeetCode）

排列问题（强调顺序）：输入一个数组/字符串，输出题目要求的所有全排列

•  例如：90. 子集 II - 力扣（LeetCode）或 46. 全排列 - 力扣（LeetCode）

棋盘问题：N皇后、解数独等

• 例如：51. N 皇后 - 力扣（LeetCode）或 37. 解数独 - 力扣（LeetCode）

3.  如何解决问题（问题难点 + 解决方案）

3.1 组合问题难点：

1. 剪枝如何剪

77. 组合 - 力扣（LeetCode）

输入：n 为最大整数、k为要求组合个数 ； 输出：所有k个元素的组合集合。

分析：

1. 以顺序排列的组合方式。

2. 广搜路线只考虑后面的元素个数是否满足 {k - path.size ()} 个。

3. for循环的判断条件变为 {i <= n - (k - path.size ()) + 1} （例 n = 4，k = 3，此时path.size() = 2, i只需考虑 3 或 4）

2. 回溯函数参数怎么选 

216. 组合总和 III - 力扣（LeetCode）

输入：n 为目标数、k为要求组合个数（不能有重复） ； 输出：sum = n的 k 个元素的组合集合。

分析：

1. 回溯函数设定：

BT(int k, int n)

a. 广搜 是否 不取重复 （是）----> StartIndex

b. 考虑限定终止条件（sum == n），sum是否需要在回溯中重复使用（需要）----> Sum

回溯函数参数变为 

void BT(int targetSum, int k, int sum, int startIndex)

2. 广搜循环判断：Sum出现在回溯传入参数中，需要随回溯一起变化

for (int i = startIndex; i <= 9; i++) {
    sum += i;
    path.push_back(i);
    backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
    sum -= i; // 回溯
    path.pop_back(); // 回溯
}

3. 含映射的回溯问题

17. 电话号码的字母组合 - 力扣（LeetCode）

输入：含 ‘ 2 ’ ~ ‘ 9 ’ 的一字符串，每个字符映射一组小集合 ； 输出：所有映射子集组合的集合。

分析：

1. 回溯函数设定

void backtracking(const string& digits)

a. 广搜 是否 不取重复 （否）

b. 考虑终止条件（number == nums.size()），number 是否需要在回溯中重复使用（需要）----> number

回溯函数参数变为 

void backtracking(const string& digits, int number)

2. 广搜循环判断：

a. 组合子集是否为映射因子 （是）------> for循环映射元素

b. 映射集合选取 根据 {digits[number]} 确定，映射集合表示为

int digit = digits[number] - '0';
string letters = letterMap[digits];

c. 广搜循环变为

for (int i = 0; i < letters.size(); i++) {
            s.push_back(letters[i]);            // 处理
            backtracking(digits, index + 1);    // 递归，注意index+1，一下层要处理下一个数字了
            s.pop_back();                       // 回溯
        }

4. 去重问题（同一树层使用过）

40. 组合总和 II - 力扣（LeetCode）

输入：一字符串、 k为目标数； 输出：和为k的组合的集合（无数字重复）。

分析：

1. 回溯函数设定

void backtracking(vector<int>& candidates, int target)

a. 广搜 是否 不取重复 （是）----> StartIndex

b. 考虑终止条件，Sum是否需要在回溯中重复使用（需要）----> Sum 

    去重操作           Used是否需要在回溯中重复使用（需要）----> Used

void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used)

2. 广搜循环判断：

for (int i = startIndex; i < candidates.size(); i++) 

a. 剪枝优化

for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) 

b. 去重操作

 if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
        continue;
    }

1）used[i - 1] = true : 同一树枝有用过candidates[i - 1]；

2）used[i - 1] = false : 同一树层有用过candidates[i - 1]；需跳过 

3.2 切割问题难点：

1. 如何切割

131. 分割回文串 - 力扣（LeetCode）

输入：一字符串； 输出：所有分隔为回文的字符串组合的集合。

分析：

1. 回溯函数设定

void backtracking (const string& s)

a. 广搜 是否 不取重复 （是）----> StartIndex

b. 考虑终止条件，判断是否为回文 TAG，是否需在回溯中重复使用（不需要）

                             path.size（） == s.size（）

void backtracking (const string& s, int startIndex) 

2. 广搜循环判断：

for (int i = startIndex; i < s.size(); i++) 

a. 切割条件判断 （回文串逻辑判断）

1）是 切割字符串 附入 走递归 push_back ( )

2）不是 不切割 继续寻找符合条件的字符串 continue

if (isPalindrome(s, startIndex, i)) { // 是回文子串
        // 获取[startIndex,i]在s中的子串
        string str = s.substr(startIndex, i - startIndex + 1);
        path.push_back(str);
    } else {                // 如果不是则直接跳过
        continue;
    }

最终代码

for (int i = startIndex; i < s.size(); i++) {
    if (isPalindrome(s, startIndex, i)) { // 是回文子串
        // 获取[startIndex,i]在s中的子串
        string str = s.substr(startIndex, i - startIndex + 1);
        path.push_back(str);
    } else {                // 如果不是则直接跳过
        continue;
    }
    backtracking(s, i + 1); // 寻找i+1为起始位置的子串
    path.pop_back();        // 回溯过程，弹出本次已经填在的子串
}

3.3 子集问题难点：

1. 终止条件与放入逻辑

放入逻辑放在终止条件外（无需return），因为需要考虑所有元素的子集！

3.4 去重问题难点：

1. 用used数组写法

 result.push_back(path);
        for (int i = startIndex; i < nums.size(); i++) {
            // used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
            // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
            // 而我们要对同一树层使用过的元素进行跳过
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
        }

2. 用set写法 (适用于无法先排序的数组进行增子序列统计)

491. 递增子序列 - 力扣（LeetCode）

result.push_back(path);
unordered_set<int> uset; // 定义set对同一节点下的本层去重
        for (int i = startIndex; i < nums.size(); i++) {
            if (uset.find(nums[i]) != uset.end()) { // 如果发现出现过就pass
                continue;
            }
            uset.insert(nums[i]); // set跟新元素
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }

用set误区：

1. 放在类成员里，一次 insert ，回溯对应 一次 erase；错误原因：控制整棵树，而非同层树。

3. set与used比较

答：使用set去重的版本相对于used数组的版本效率都要低很多。原因：调用insert函数做哈希映射需要费时。结论：使用set去重，不仅时间复杂度高了，空间复杂度也高了

3.5 棋盘问题难点：

51. N 皇后 - 力扣（LeetCode）

输入：n为棋盘大小； 输出：所有行存在皇后的棋盘可行解的集合。

分析：

1. 回溯函数设定

void backtracking(int n)

a. 广搜 是否 不取重复 （否）

b. 考虑终止条件，行数Row == n？，是否需要在回溯中重复使用 （是）-------> row

                             记录棋局初始化根据n的取值以设立好，故需要在函数传入中写入 -----> chess

void backtracking(int n, int row, vector<string>& chessboard)

2. 广搜循环判断：

类似切割问题，但是不要continue

一刷总结致此 0712-0713