回溯算法

回溯

回溯是一种深度优先的搜索方法，有回溯就有递归。回溯常常用来遍历树状的解空间，进而得到最优解/全部解,回溯的本质是暴力穷举，穷举所有可能，然后选出我们想要的答案。 回溯的经典写法：

void dfs(int 起点,int n,int k){
    if (path == k) {//是否为解
        存放结果;
        return;
    }
    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {//遍历本层解空间
        处理节点;
        dfs(起点+1，int n, int k); // 加深一层递归
        回溯，撤销处理结果
    }
}

组合问题

组合

力扣题目链接(opens new window)

给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。

示例: 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]

思路

第一层：第一个节点可以选择从1开始到n-k+1的数 第二层：从第一层选择的下一个节点开始，规定节点的顺序是为了去重，[1.3.4]和[3,1,4]在组合上是一样的。 ... 第k层：路径长度已经到k,加入结果集。

class Solution {

private:
        vector<vector<int>> ans;
        vector<int> path;
        void dfs(int n, int k, int startIndex) {
            int d = k - path.size(); // 还要选 d 个数
            if (d == 0) { // 选好了
                ans.push_back(path);
                return;
            }
            for (int i = startIndex ; i <= n-d+1;i++) {//当i=n-1的时候，后面的路径长度为2，当i等于n-2的时候，后面的路径长度为3，类推当i等于n-k+1的时候，路径长度为k.也因此要等于n-k+1，也可等价于i<n-k+2
                path.push_back(i);
                dfs(n,k,i+1);
                path.pop_back(); // 恢复现场
            }
        };
public:
    vector<vector<int>> combine(int n, int k) {
        dfs(n,k,1);
        return ans;
    }
};

组合之和

组合题目的进阶，选择符合某个条件的组合。

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。又分为元素可以重复选和不可以重复选，只能选k个数三种。

可以重复选取

示例：

• 输入：candidates = [2,3,6,7], target = 7,
• 所求解集为： [ [7], [2,2,3] ]

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    void dfs(vector<int>& candidates,int target,int start){
        if(target<0){return;}//如果小于0了证明这条路走不通
        if(target ==0){
            ans.push_back(path);
            return;
        }
        for(int i = start;i<candidates.size();i++){
            path.push_back(candidates[i]);
            //这儿的边界条件是i因为可以重复选择一个数但是不能往回选，例如选择2就一次性选完，不能选了2再选3再重新选2，这样可以避免重复，原理是223与232排序后是一样的
            
            dfs(candidates,target-candidates[i],i);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {

        dfs(candidates,target,0);
        return ans;
    }
};

不可重复选

• 示例:
• 输入: candidates = [2,5,2,1,2], target = 5,
• 所求解集为:[[1,2,2],[5]]

不可重复选的需要去重，这个去重需要同一层去重，比如(2,2,1)在示例中有三个2，第一层只能用一次2。所以会用一个used数组。 先排序候选集，设置used为类变量，当元素a第一次出现的时候used设置为1,压栈，下一层可以继续使用该元素a。退栈之后置为0.此时需要在本层增加一个去掉重复a的逻辑，i&&candidates[i]==candidates[i-1]&&used[i-1]==false，直接去掉最后几个

#include<algorithm>
class Solution {
public:
    //本题的难点在于同一层中不能有相同的元素，否则会造成重复
    vector<vector<int>> ans;
    vector<int> path;
    vector<bool> used;
    void dfs(vector<int>& candidates,int target,int start){
        if(target<0){return;}//如果小于0了证明这条路走不通
        if(target ==0){
            ans.push_back(path);
            return;
        }
        for(int i = start;i<candidates.size();i++){
            //以1,1,1，为例，前一个1在栈中的时候，这个1才可以使用，否则的话，跳过前面的1不应当使用后面的1，会造成重复现象
            if(i&&candidates[i]==candidates[i-1]&&used[i-1]==false){//退栈之后前面两个1都是false 这时候就直接略过第三个1了
            continue;
            }
            path.push_back(candidates[i]);
            used[i]=true;//压栈，把used设置为true
            dfs(candidates,target-candidates[i],i+1);//这儿的边界条件是i+1因为不可以重复选择同一个数
            used[i]=false;
            path.pop_back();
        }

    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        used = vector<bool>(candidates.size(), false);//used赋值
        sort(candidates.begin(),candidates.end());//把相同元素排序到一起
        dfs(candidates,target,0);
        return ans;
    }

};

只能选择k个数

找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。 例如:相加为7的三个数只有1,2,4

思路：直接深度为k遍历即可

class Solution {
private:
    vector<vector<int>> result; // 存放结果集
    vector<int> path; // 符合条件的结果
    // targetSum：目标和，也就是题目中的n。
    // k：题目中要求k个数的集合。
    // sum：已经收集的元素的总和，也就是path里元素的总和。
    // startIndex：下一层for循环搜索的起始位置。
    void dfs(int targetSum, int k, int sum, int startIndex) {
        if (path.size() == k) {
            if (sum == targetSum) result.push_back(path);
            return; // 如果path.size() == k 但sum != targetSum 直接返回
        }
        for (int i = startIndex; i <= 9; i++) {
            sum += i; // 处理
            path.push_back(i); // 处理
            dfs(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
            sum -= i; // 回溯
            path.pop_back(); // 回溯
        }
    }

public:
    vector<vector<int>> combinationSum3(int k, int n) {
        result.clear(); // 可以不加
        path.clear();   // 可以不加
        dfs(n, k, 0, 1);
        return result;
    }
};

排列问题

全排列

力扣题目链接(opens new window)

给定一个没有重复数字的序列，返回其所有可能的全排列。

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

全排列2

力扣题目链接(opens new window)

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

• 输入：nums = [1,1,2]
• 输出： [[1,1,2], [1,2,1], [2,1,1]]

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void dfs(vector<int> &nums,vector<bool>& used){
        if(path.size()==nums.size()){
            result.push_back(path);
            return ;
        }
        for(int i =0;i<nums.size();i++){
            //需要跳过多个重复数字，以及不允许在不同的层使用同一个数字
            if((i&&nums[i-1]==nums[i]&&used[i-1]==false)||(used[i]))continue;
            used[i]=true;
            path.push_back(nums[i]);
            dfs(nums,used);
            path.pop_back();
            used[i]=false;
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<bool> used(nums.size(),false);
        dfs(nums,used);
        return result;
    }
};

分割问题

分割回文

力扣题目链接(opens new window)

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

思路

一个函数判断是否为回文。一个一步步遍历，如果是回文就入栈。

class Solution {
public:
    vector<vector<int>> f;
    vector<vector<string>> result;
    vector<string> path;
    void dfs(string s, int start) {
        if (start == s.size()) {
            result.push_back(path);
            return;
        }
        int i = start;
        for (int j = start + 1; j <= s.size(); j++) {
            if (f[i][j-1] == 1){
                path.push_back(s.substr(i, j - i));
                dfs(s, j);
                path.pop_back();
            }
        }
    }
    void isCircle(string s) {
        f.resize(s.size(), vector<int>(s.size(), 0));
        for (int i = s.size() - 1; i >= 0; i--) {
            for (int j = i; j < s.size(); j++) {
                if (s[i] == s[j]) {
                    if (i == j || i == j - 1)
                        f[i][j] = 1;
                    else {
                        f[i][j] = f[i + 1][j - 1];
                    }
                }
            }
        }
    }
    vector<vector<string>> partition(string s) {
        isCircle(s);
        dfs(s, 0);

        return result;
    }
};

分割IP地址

力扣题目链接(opens new window)

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。

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

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; // 不合法，直接结束本层循环
        }
    }
    // 判断字符串s在左闭又闭区间[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;
    }
};

子集问题

子集

力扣题目链接(opens new window)

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例: 输入: nums = [1,2,3] 输出: [ [3],[1],[2],[1,2,3], [1,3], [2,3], [1,2], [] ]

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        result.push_back(path); // 收集子集，要放在终止添加的上面，否则会漏掉自己
        if (startIndex >= nums.size()) { // 终止条件可以不加
            return;
        }
        for (int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

棋盘问题

N皇后

class Solution {
private:
vector<vector<string>> result;
// n 为输入的棋盘大小
// row 是当前递归到棋盘的第几行了
void backtracking(int n, int row, vector<string>& chessboard) {
    if (row == n) {
        result.push_back(chessboard);
        return;
    }
    for (int col = 0; col < n; col++) {
        if (isValid(row, col, chessboard, n)) { // 验证合法就可以放
            chessboard[row][col] = 'Q'; // 放置皇后
            backtracking(n, row + 1, chessboard);
            chessboard[row][col] = '.'; // 回溯，撤销皇后
        }
    }
}
bool isValid(int row, int col, vector<string>& chessboard, int n) {
    // 检查列
    for (int i = 0; i < row; i++) { // 这是一个剪枝
        if (chessboard[i][col] == 'Q') {
            return false;
        }
    }
    // 检查 45度角是否有皇后
    for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    // 检查 135度角是否有皇后
    for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
        if (chessboard[i][j] == 'Q') {
            return false;
        }
    }
    return true;
}
public:
    vector<vector<string>> solveNQueens(int n) {
        result.clear();
        std::vector<std::string> chessboard(n, std::string(n, '.'));
        backtracking(n, 0, chessboard);
        return result;
    }
};

数独问题