LeetCode 回溯法 阶段性小结 个人向专题通关计划

回溯法应用场景

回溯法又叫回溯搜索法，是一种搜索的方式，类似于深度搜索。回溯搜索的本质是穷举搜索，所以并不是一种高效的算法，可以考虑一些剪枝优化策略。
回溯法可以解决的问题种类一般包括以下几种：

• 组合问题：N个数里面按照某种要求找出满足条件的k个数的集合
• 切割问题：一个字符串按照某种要求可以有多少种切割方式
• 子集问题：一个N个数的集合里有多少符合条件的子集
• 排列问题：N个数按某种规则全排列，可以有多少种排列方式
• 棋盘问题：N皇后、解数独等

回溯法代码模板

按照树结构和深度搜索的思想可以较好地理解回溯的过程：

void backtracking(params):{
	if(达到终止条件){
		记录当前可行的结果; //总的结果池中的一种
		return;
	}
	for(本层集合中元素(也可理解为树节点的孩子个数)){
		处理节点;
		backtracking(更新参数); //深搜递归
		回溯：撤销上面的处理结果; //精髓部分
	}
}

注意：节点处理的过程与回溯撤销的过程要一一对应。

回溯：组合问题

LeetCode77 组合

题目链接

解题思路：可以认为随着for循环的不断进行，搜索空间也在不断变化，最终遍历完整个求解空间。
(遍历包含1的求解空间–>遍历包含2但不含1的求解空间–>遍历包含3但不包含1和2的求解空间–>遍历包含4但不包含1、2、3的求解空间)，所遍历的求解空间越来越小，但并不交叉，且最终能合并为完整的求解空间。

AC代码：

class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(int n, int k, int idx){
        if(path.size() == k){
            res.push_back(path);
            return;
        }
        for(int j=idx; j<=n; j++){
            path.push_back(j);
            backtracking(n, k, j+1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combine(int n, int k) {
        backtracking(n, k, 1);
        return res;
    }
};

LeetCode40 组合总和 II

题目链接

解题思路：排序+去重
AC代码：

class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums, int target, int idx, int sum, int depth){
        if(sum == target){
            res.push_back(path);
            return;
        }
        for(int i=idx; i<nums.size();i++){
        	//去重剪枝 例如[2,2,2,5] 第一次考虑时就已经把最多存在3个2的解空间搜索完了
        	//那么最多只存在2个2的解空间自然已经被覆盖了，就无须额外再进行搜索了
            if(i>idx && nums[i] == nums[i-1]){ 
                continue;
            }
            sum+=nums[i];
            if(sum > target){ // 剪枝
                break;
            }
            path.push_back(nums[i]);
            //注意这里i+1避免了元素的重复使用
            backtracking(nums, target, i+1, sum, depth+1); 
            sum -= nums[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());//先排序 方便去重与剪枝
        backtracking(candidates, target, 0, 0, 0);
        return res;
    }
};

回溯：切割问题

LeetCode131 分割回文串

题目链接

解题思路：注意当确定目前处里中的子串是回文串后，才能开启下一个回文子串的寻找。

AC代码：

class Solution {
private:
    vector<vector<string>> res;
    vector<string> path;
    bool ishuiwen(string &s, int start, int end){
        while(start<end){
            if(s[start]!=s[end]) return false;
            start++; end--;
        }
        return true;
    }
    void backtracking(string &s, int idx){
        if(idx == s.size()){//结束
            res.push_back(path);
            return;
        }
        for(int i=idx;i<s.size();++i){
            if(ishuiwen(s, idx, i)){
                path.push_back(s.substr(idx, i-idx+1));
            }
            else continue;

            backtracking(s, i+1); //注意起始位置的更新
            path.pop_back();
        }
    }
public:
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return res;
    }
};

LeetCode93 复原IP地址

题目链接

解题思路：这道题目很有意思，应该是当年保研时候的一道机试题目。跟上一道题目一样，也是需要注意当前处理的子串是否满足ip的条件。
AC代码：

class Solution {
private:
    vector<string> res;
    bool legal(string &s, int left, int right){
        int cnt = 0;
        if(right - left > 0 && s[left] == '0' ) return false;
        while(right >= left){
            if(s[left] > '9' || s[left] < '0') return false;
            cnt = cnt*10 + (s[left++] - '0');
            if(cnt > 255) return false;
        }
        
 
        return true;
    }
    void backtracking(string &s, int idx, int time){
        if(time == 3){//直接判断第四段
            if(idx <= s.size() -1 && legal(s, idx, s.size()-1)){
                res.push_back(s); 
            }
            return;
        }
        for(int i=idx;i<s.size();++i){
            if(legal(s, idx, i)){
                s.insert(s.begin() + i + 1 , '.'); //再i的后面插入一个分隔符
                backtracking(s, i+2, time+1); //注意多了一个分隔符 直接是i+2
                s.erase(s.begin() + i + 1);
            }
            else break;
        }
    }
public:
    vector<string> restoreIpAddresses(string s) {
        backtracking(s, 0, 0);
        return res;
    }
};

回溯：子集问题

LeetCode491 递增子序列

解题思路：
这一题的难点在于去重的逻辑：同一层下，使用过的元素就不能再次使用了。
例如[1,2,1,1] 最多三个1的情况已经考虑过了，那么后续的最多两个1的情况便要去重。
AC代码：

class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;
    
    void backtracking(vector<int>& nums, int idx, int pre){
        if(path.size() > 1){
            res.push_back(path);
            //return; 不返回是因为非叶子节点也是所求解的答案
        }
        int used[201] = {0}; //每一层的记录数组都会重新定义
        for(int i=idx;i<nums.size();++i){
            if(used[nums[i]+100]){ //去重 例如[1,2,1,1] 最多三个1的情况已经考虑过了，那么后续的最多两个1的情况便要去重
                continue;
            }
            used[nums[i]+100] = 1;
            if(nums[i] >= pre){
                path.push_back(nums[i]);
                backtracking(nums, i+1, nums[i]);
                path.pop_back();
            }
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        int tmp = INT_MIN;
        backtracking(nums, 0, tmp);
        return res;
    }
};

回溯：排列问题

LeetCode46 全排列

解题思路：数组不含重复元素，只需要记录该元素是否已经被选取过即可
AC代码：

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums, vector<bool>& used){
        if(path.size() == nums.size()){
            res.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();++i){
            if(used[i] == true) continue;
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return res;
    }
};

LeetCode47 全排列 II

解题思路：
数组课包含重复数字，那么在上一题记录已选取元素的索引的同时，还要记录该数字是否已经在这一层中被使用过。
AC代码：

class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums, vector<bool>& used_idx){
        if(path.size() == nums.size()){
            res.push_back(path);
            return;
        }
        int used[21] = {0}; //用于判断某一数字在该层是否已经被使用过
        for(int i=0;i<nums.size();++i){
            if(used[nums[i]+10] || used_idx[i]) continue;
            used[nums[i]+10] = 1;
            used_idx[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used_idx);
            used_idx[i] = false;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used_idx(nums.size(), false);
        backtracking(nums, used_idx);
        return res;
    }
};

回溯：棋盘问题

LeetCode51 N皇后

解题思路：
这一题的关键在于判断当前棋局是否成立
AC代码：

class Solution {
private:
    vector<vector<string>> res;
    bool islegal(vector<string>& qipan, int i, int j){
        //检查列
        for(int row=0;row<i;row++){
            if(qipan[row][j] == 'Q') return false;
        }
        //检查左上部分
        for(int row=i-1, col=j-1; row>=0 && col>=0; row--, col--){
            if(qipan[row][col] == 'Q') return false;
        }
        //检查右上部分
        for(int row = i-1, col = j+1; row>=0 && col < qipan.size(); row--, col++){
            if(qipan[row][col] == 'Q') return false;
        }
        return true;
    }
    void backtracking(vector<string>& qipan, int cnt){
        if(cnt == qipan.size()){
            res.push_back(qipan);
            return;
        }
        for(int i=0;i<qipan.size();++i){
            if(islegal(qipan, cnt, i)){
                qipan[cnt][i] = 'Q';
                backtracking(qipan, cnt+1);
                qipan[cnt][i] = '.';
            }
        }
    }
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<string> qipan(n, string(n, '.'));
        backtracking(qipan, 0);
        return res;
    }
};