算法学习——回溯算法

理论基础

什么是回溯法？
回溯法也可以叫做回溯搜索法，它是一种搜索的方式。

在二叉树系列中，我们已经不止一次，提到了回溯，例如二叉树：以为使用了递归，其实还隐藏着回溯。
回溯是递归的副产品，只要有递归就会有回溯。

所以以下讲解中，回溯函数也就是递归函数，指的都是一个函数。

回溯法的效率

回溯法的性能如何呢，这里要和大家说清楚了，虽然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法。
因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。

那么既然回溯法并不高效为什么还要用它呢？
因为没得选，一些问题能暴力搜出来就不错了，撑死了再剪枝一下，还没有更高效的解法。

那么都什么问题，这么牛逼，只能暴力搜索。

回溯法解决的问题

回溯法，一般可以解决如下几种问题：

组合问题：N个数里面按一定规则找出k个数的集合
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
排列问题：N个数按一定规则全排列，有几种排列方式
棋盘问题：N皇后，解数独等等

回溯法模板

卡哥总结的回溯算法模板。

回溯三部曲：

1.回溯函数模板返回值以及参数：回溯算法中函数返回值一般为void。再来看一下参数，因为回溯算法需要的参数可不像二叉树递归的时候那么容易一次性确定下来，所以一般是先写逻辑，然后需要什么参数，就填什么参数。

回溯函数伪代码如下：

void backtracking(参数)

2.回溯函数终止条件：
什么时候达到了终止条件，树中就可以看出，一般来说搜到叶子节点了，也就找到了满足条件的一条答案，把这个答案存放起来，并结束本层递归。

所以回溯函数终止条件伪代码如下：

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

3.回溯搜索的遍历过程：
在上面我们提到了，回溯法一般是在集合中递归搜索，集合的大小构成了树的宽度，递归的深度构成的树的深度。

回溯函数遍历过程伪代码如下：

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

for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。

组合

力扣题目链接

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

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

思路

可以看出这棵树，一开始集合是 1，2，3，4， 从左向右取数，取过的数，不再重复取。

第一次取1，集合变为2，3，4 ，因为k为2，我们只需要再取一个数就可以了，分别取2，3，4，得到集合[1,2] [1,3] [1,4]，以此类推。

每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围。

图中可以发现n相当于树的宽度，k相当于树的深度。

那么如何在这个树上遍历，然后收集到我们要的结果集呢？

图中每次搜索到了叶子节点，我们就找到了一个结果。

相当于只需要把达到叶子节点的结果收集起来，就可以求得 n个数中k个数的组合集合。

回溯法三部曲

递归函数的返回值以及参数
在这里要定义两个全局变量，一个用来存放符合条件单一结果，一个用来存放符合条件结果的集合。

vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件结果

函数里一定有两个参数，既然是集合n里面取k个数，那么n和k是两个int型的参数。

然后还需要一个参数，为int型变量startIndex，这个参数用来记录本层递归中，集合从哪里开始遍历（集合就是[1,…,n] ）。

为什么要有这个startIndex呢？
startIndex 就是防止出现重复的组合。
从下图中红线部分可以看出，在集合[1,2,3,4]取1之后，下一层递归，就要在[2,3,4]中取数了，那么下一层递归如何知道从[2,3,4]中取数呢，靠的就是startIndex。

所以需要startIndex来记录下一层递归，搜索的起始位置。

那么整体代码如下：

vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件单一结果
void backtracking(int n, int k, int startIndex)

回溯函数终止条件
什么时候到达所谓的叶子节点了呢？

path这个数组的大小如果达到k，说明我们找到了一个子集大小为k的组合了，在图中path存的就是根节点到叶子节点的路径。
此时用result二维数组，把path保存起来，并终止本层递归。

所以终止条件代码如下：

if (path.size() == k) {
    result.push_back(path);
    return;
}

单层搜索的过程
回溯法的搜索过程就是一个树型结构的遍历过程，在如下图中，可以看出for循环用来横向遍历，递归的过程是纵向遍历。

如此我们才遍历完图中的这棵树。
for循环每次从startIndex开始遍历，然后用path保存取到的节点i。
可以看出backtracking（递归函数）通过不断调用自己一直往深处遍历，总会遇到叶子节点，遇到了叶子节点就要返回。
backtracking的下面部分就是回溯的操作了，撤销本次处理的结果。

代码如下：

for (int i = startIndex; i <= n; i++) { // 控制树的横向遍历
    path.push_back(i); // 处理节点
    backtracking(n, k, i + 1); // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
    path.pop_back(); // 回溯，撤销处理的节点
}

代码

class Solution {
public:
        vector<int> paths;
        vector<vector<int>>result;
    void backtracking(int n , int k ,int startidx)
        {
            if(paths.size()==k)
            {
                result.push_back(paths);
                return;
            }   
            for(int i = startidx;i <= n ;i++)
            {
                paths.push_back(i);
                backtracking(n,k,i+1);
                paths.pop_back();
            }
        }
    vector<vector<int>> combine(int n, int k) 
    {
        backtracking(n,k,1);
        return result;
    }
};

组合（优化）

组合总和III

力扣题目链接

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

说明：
所有数字都是正整数。
解集不能包含重复的组合。

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

思路

代码

class Solution {
public:
    vector<vector<int>>result;
    vector<int>paths;
    int sum = 0;
    void backtracking(int n , int k,int startidx)
    {
        if(paths.size()>k) return;
        if(sum > n) return;
        if(paths.size()==k && sum==n )
        {
            result.push_back(paths);
            return ;
        }
        for(int i = startidx; i<=9;++i)
        {
            paths.push_back(i);
            sum+=i;
            backtracking(n,k,i+1);
            paths.pop_back();
            sum-=i;
        }
    }
    vector<vector<int>> combinationSum3(int k, int n) 
    {
        backtracking(n,k,1);
        return result;
    }
};

电话号码的字母组合

力扣题目链接

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 ：
输入：digits = “23”
输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]

思路

数字和字母如何映射
可以使用map或者定义一个二维数组，例如：string letterMap[10]，来做映射，我这里定义一个二维数组，代码如下：

const string letterMap[10] = {
    "", // 0
    "", // 1
    "abc", // 2
    "def", // 3
    "ghi", // 4
    "jkl", // 5
    "mno", // 6
    "pqrs", // 7
    "tuv", // 8
    "wxyz", // 9
};

回溯法来解决n个for循环的问题

例如：输入：“23”，抽象为树形结构，如图所示：

图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]。

回溯三部曲

确定回溯函数参数

首先需要一个字符串s来收集叶子节点的结果，然后用一个字符串数组result保存起来，这两个变量我依然定义为全局。
再来看参数，参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index。
这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。

代码如下：

vector<string> result;
string s;
void backtracking(const string& digits, int index)

确定终止条件
例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。

那么终止条件就是如果index 等于 输入的数字个数（digits.size）了（本来index就是用来遍历digits的）。

然后收集结果，结束本层递归。

代码如下：

if (index == digits.size()) {
    result.push_back(s);
    return;
}

这里index跳出循环后的大小就是数组的大小

确定单层遍历逻辑

首先要取index指向的数字，并找到对应的字符集（手机键盘的字符集）。

然后for循环来处理这个字符集，代码如下：

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();                       // 回溯
}

注意这里for循环，可不像是在回溯算法：求组合问题和回溯算法：求组合总和中从startIndex开始遍历的。

因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合，而上述两道题都是求同一个集合中的组合！

代码

class Solution {
public:
    const vector<string>phones = 
    {
        "",
        "",
        "abc",
        "def",
        "ghi",
        "jkl",
        "mno",
        "pqrs",
        "tuv",
        "wxyz"
    };
    vector<string>result;
    string path;
    void backtracking(string digits , int index)
    {
        if( index == digits.size())
        {
            result.push_back(path);
            return;
        }
        int num = digits[index] - '0';
        string words = phones[num];
        for(int i = 0 ; i < words.size();++i)
        {
            path.push_back(words[i]);
            backtracking(digits,index+1);
            path.pop_back();
        }
    }
    vector<string> letterCombinations(string digits) 
    {
        if(digits.size()==0)return result;
        backtracking(digits,0);
        return result;
    }
};

组合总和

力扣题目链接

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。

说明：
所有数字（包括 target）都是正整数。
解集不能包含重复的组合。
示例 1：

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

思路

代码

class Solution {
public:
    vector<vector<int>>result;
    vector<int>paths;
    void backtracking(vector<int>& candidates , int target ,int sum , int startidx)
    {
        if(sum > target)
        {
            return;
        }
        if(sum == target)
        {
            result.push_back(paths);
            return ;
        }
        for(int i = startidx ; i < candidates.size();++i)
        {
            paths.push_back(candidates[i]);
            sum += candidates[i];
            backtracking(candidates,target,sum,i);
            sum -= candidates[i];
            paths.pop_back();
        }
    }

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) 
    {
        backtracking(candidates,target,0,0);
        return result;
    }
};

组合总和II

力扣题目链接

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

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

说明： 所有数字（包括目标数）都是正整数。解集不能包含重复的组合。

示例 1:
输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:

[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

思路

如果 candidates 中有重复元素，可能会生成重复的组合。为了避免这种情况，首先需要对 candidates 进行排序。排序后，相同的数字会排列在一起，从而可以更容易地跳过重复的组合。

不排序去重：

代码

class Solution {
public:
    vector<vector<int>>result;
    vector<int>path;
    void backtracking(vector<int>& candidates, int target, int sum,int startidx )
    {
        if(sum > target)return;
        if(sum==target)
        {
            result.push_back(path);
            return;
        }
        for(int i = startidx;i<candidates.size();++i)
        {
            if(i>startidx && candidates[i]==candidates[i-1])continue;
            path.push_back(candidates[i]);
            sum += candidates[i];
            backtracking(candidates,target,sum,i+1);
            sum -= candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) 
    {
        sort(candidates.begin(),candidates.end());
        backtracking(candidates,target,0,0);
        return result;
    }
};

分割回文串

力扣题目链接

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

思路

代码

class Solution {
public:
    bool isPstring(string s ,int begin , int end)
    {
        if(s.size()==1)return true;
        int i = begin;
        int k = end;
        while(i < k)
        {
            if(s[i]==s[k])
            {
                i++;
                k--; 
            }
            else
            {
                return false;
            }
        }
        return true;
    }
    vector<string> path;
    vector<vector<string>> result;
    void backtracking(string s , int startidx)
    {
        if(startidx >= s.size())
        {
            result.push_back(path);
            return ;
        }
        for(int i = startidx ; i < s.size() ;i++)
        {
            if(isPstring(s,startidx,i))
            {
                string substr = s.substr(startidx,i-startidx+1);
                path.push_back(substr);
            }
            else
            {
                continue;
            }
            backtracking(s,i+1);
            path.pop_back();
        }
    }


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

复原ip地址

力扣题目链接

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
有效的 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 地址。

思路

代码

class Solution {
public:
    bool islegaldig(string s , int begin , int end)
    {
        if((end-begin +1)>=4)return false;
        if((end-begin +1) == 0)return false;
        string substr = s.substr(begin,end-begin+1);
        if(substr.size()>1 && substr[0] == '0') return false;

        int sum = 0;
        for(int i = 0 ; i < substr.size() ; i++)
        {
            if(substr[i]<'0'||substr[i]>'9')
            {
                return false;
            }
            sum *= 10;
            sum += substr[i] - '0';
        }
        if(sum<0 || sum>255)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    vector<string>result;
    void backtracking(string &s , int startidx , int pointnum)
    {
        if(pointnum == 3)
        {
            if(islegaldig(s,startidx,s.size()-1))
            {
                result.push_back(s);
            }
            return ;
        }
        for(int i = startidx ; i < s.size() ; i++ )
        {
            if(islegaldig(s,startidx,i))
            {
                s.insert(s.begin()+i+1,'.');
                pointnum++;
                backtracking(s,i+2,pointnum);
                pointnum--;
                s.erase(s.begin()+i+1);
                
            }
            else
            {
                continue;
            }
        }
    }
    vector<string> restoreIpAddresses(string s) 
    {
        backtracking(s,0,0);
        return result;
    }
};

子集

力扣题目链接

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

说明：解集不能包含重复的子集。
示例: 输入: nums = [1,2,3] 输出: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ]

思路

代码

class Solution {
public:
    vector<int>path;
    vector<vector<int>>result;
    void backtracking(vector<int>&nums,int startidx)
    {
        result.push_back(path);
        if(startidx>=nums.size())
        {
            return;
        }
        for(int i = startidx ; i < nums.size();i++)
        {
            path.push_back(nums[i]);
            backtracking(nums,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) 
    {
        backtracking(nums,0);
        return result;
    }
};

子集II

力扣题目链接

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

代码

class Solution {
public:
    vector<int>path;
    vector<vector<int>>result;
    void backtracking(vector<int>&nums,int startidx)
    {
        result.push_back(path);
        if(startidx >= nums.size())
        {
            return ;
        }
        unordered_set<int> set;
        for(int i = startidx ; i < nums.size() ;i++)
        {
            if(set.find(nums[i])==set.end())
            {
                set.insert(nums[i]);
                path.push_back(nums[i]);
                backtracking(nums,i+1);
                path.pop_back();
            }
            else
            {
                continue;
            }
            
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) 
    {
        sort(nums.begin(),nums.end());
        backtracking(nums,0);
        return result;
    }
};

全排列

力扣题目链接
给定一个 没有重复 数字的序列，返回其所有可能的全排列。

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

思路

代码

class Solution {
public:
    vector<int>path;
    vector<vector<int>>result;

    void backtracking(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]==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 result;
    }
};

全排列II

力扣题目链接

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

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

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

思路

代码

class Solution {
public:
    vector<int>path;
    vector<vector<int>>result;

    void backtracking(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 > 0 && nums[i]==nums[i-1])&& used[i-1]==false)
            {
                continue;
            }
            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>> permuteUnique(vector<int>& nums) 
    {
        sort(nums.begin(),nums.end());
        vector<bool>used(nums.size(),false);
        backtracking(nums,used);
        return result;
    }
};

重新安排行程