算法之回溯

回溯的本质就是DFS，如果从节点1开始有n条路径，那就一条一条来来试，是否满足条件，如果不满足则返回到开始状态，试其它的路径。回溯的问题解空间可能会比较大，需要遍历比较多，所以就需要剪枝，删除那些不可能的路径，降低遍历的路径。
回溯的题目一般都是要求问题的所有解空间：
典型的题目有：
1. 排列组合问题
2. Sum，求所有等于sum的组合
2. N-Queen问题

排列组合问题

排列和组合是两种类型的问题，一开始挺怵这种题，觉得很难，其实都是有模板的，解题的思路都是递归。
然后会说下这种题的一种followup

组合问题

求一个字符串的所有组合？先假设没有重复元素比如123，它的所有组合有
{},{1},{2},{3},{1,2},{1,3},{1,2,3}
从结果来进行分析，可以转化为
{1}
{1,2}
{1,2,3}
{1,3}
可以理解为先选择1，然后再选择2，再选择3，每一步都是一种结果，这次以1开始的所有组合就已经做完了，就选择不选择1，选择2的组合，重复做一遍。分析来看，就是一个递归行为。

class Solution {
public:
    /**
     * @param S: A set of numbers.
     * @return: A list of lists. All valid subsets.
     */
    vector<vector<int> > subsets(vector<int> &nums) {
        vector<vector<int>> resList;
        if(nums.empty()){
            resList.push_back(nums);
            return resList;
        }
        sort(nums.begin(), nums.end());此处可以不排序，如果题目没有要求必须所有组合必须是升序的话
        vector<int> res;
        subsets(nums, 0, res, resList);
        return resList;
    }

    void subsets(vector<int>& nums, int i, vector<int>& res, vector<vector<int>>& resList){
        resList.push_back(res);
        for(int j = i; j < nums.size(); j++){
            res.push_back(nums[j]);
            subsets(nums, j+1, res, resList);
            res.pop_back();
        }
    }
};

然后一般都会有另外一个followup，就是如果字符串中有重复元素，如何去掉重复组合？比如1,2,2。
按照原来的思路需要
{1}
{1,2}
{1,2,2}
{1,2}这就有重复了，此处需要过滤掉
因为在第2个位置，2这个元素已经放过一次，下次就第2个位置就不能再放2了，当要将第3个元素放在第2个位置的时候发现前面那个元素已经放过了，就不需要再放了，将这种情况过滤掉就好了。
从分析来看，只需要解决重复使用问题就可以了，那怎么解决重复的问题，一般来说要找重复元素有两种策略，第一就是排序，这样重复元素就会在一起，第二就是hashmap去重复元素。
hashmap肯定不合适，因为原始数据就会少，破坏原有代码结构，明显用排序会更加好

class Solution {
public:
    /**
     * @param S: A set of numbers.
     * @return: A list of lists. All valid subsets.
     */
    vector<vector<int> > subsets(vector<int> &nums) {
        vector<vector<int>> resList;
        if(nums.empty()){
            resList.push_back(nums);
            return resList;
        }
        sort(nums.begin(), nums.end());
        vector<int> res;
        subsets(nums, 0, res, resList);
        return resList;
    }

    void subsets(vector<int>& nums, int i, vector<int>& res, vector<vector<int>>& resList){
        resList.push_back(res);
        for(int j = i; j < nums.size(); j++){
            if(j > i && nums[j] == nums[j-1]){因为排序好了，所以相同的元素肯定会相邻，因为j-1元素已经放过了，当j元素和j-1元素相等，则可以直接过滤掉
                continue;
            }
            res.push_back(nums[j]);
            subsets(nums, j+1, res, resList);
            res.pop_back();
        }
    }
};

排列问题

求一个字符串的全排列，比如123，它的全排列有123，132，213，231，321，312
回溯解决，先将1放在第一个位置，然后可以放2，最后放3，当放置完3之后就没有数据，它就回溯到2，回溯到2的时候恢复状态，将3pop出来，当回溯到2的时候也没有数据了，就需要回溯到1。
123
132

class Solution {
public:
    /**
     * @param nums: A list of integers.
     * @return: A list of permutations.
     */
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> ResultList;
        if (nums.empty())
        {
            return ResultList;
        }
        GetAllPermute(nums, 0, ResultList);
        return ResultList;
    }
    void GetAllPermute(vector<int>& nums, int Index, vector<vector<int>>& ResultList){
        if ( Index == nums.size() )
        {
            ResultList.push_back(nums);
            return;
        }

        for (int i = Index; i < nums.size(); ++i)
        {
            swap(nums[Index], nums[i]);
            GetAllPermute(nums, Index+1, ResultList);
            swap(nums[Index], nums[i]);
        }
    }
};

followup就是当string中有重复元素如何避免重复组合，比如122，当第一个位置放了1的时候，第二个位置可以放置2，第三个位置可以放置2，回溯到第2个位置的时候此时放置下一个元素，但是两个元素相同，所以是重复排列。也就是判断这个位置放过的所有元素不能有重复，有重复就是一个走过的分支就不需要继续遍历了，这就是所谓的剪枝。

class Solution {
public:
    /**
     * @param nums: A list of integers.
     * @return: A list of unique permutations.
     */
    vector<vector<int> > permuteUnique(vector<int> &nums) {
        vector<vector<int>> Result;
        if(nums.empty()){
            return Result;
        }

        GetAllPermuteUnique(nums, 0, Result);

        return Result;
    }

    void GetAllPermuteUnique(vector<int>& nums, int i, vector<vector<int>>& Result){
        if(i == nums.size()){
            Result.push_back(nums);
            return;
        }

        for(int j = i; j < nums.size(); j++){
            if( IsSwapped(nums, i, j) ){
                continue;
            }
            swap(nums[i], nums[j]);
            GetAllPermuteUnique(nums, i+1, Result);
            swap(nums[i], nums[j]);
        }
    }

    这个函数就是判断当前位置是否有重复元素放入过，SwapIndex位置就是已经放入过这个位置的所有元素
    bool IsSwapped(vector<int>& nums, int CurIndex, int SwapIndex){
        for(int i = CurIndex; i < SwapIndex; i++){
            if(nums[i] == nums[SwapIndex]){
                return true;
            }
        }
        return false;
    }
};
class Solution {
public:
    /**
     * @param nums: A list of integers.
     * @return: A list of unique permutations.
     */
    vector<vector<int> > permuteUnique(vector<int> &nums) {
        vector<vector<int>> Result;
        if(nums.empty()){
            Result.push_back(nums);
            return Result;
        }

        GetAllPermuteUnique(nums, 0, Result);

        return Result;
    }

    void GetAllPermuteUnique(vector<int>& nums, int i, vector<vector<int>>& Result){
        if(i == nums.size()){
            Result.push_back(nums);
            return;
        }

        判断重复元素可以采用hashset，这是一种比较快的方式，这个地方不能采用
        =====
        if(j>i && nums[j] == nums[j-1]){
          continue;
        }
        因为在求整个排列过程中，nums已经变形了，不再是排好序的数组，重复元素不再相邻了，所以不能使用
        =====
        unordered_set<int> iPosElements;
        for(int j = i; j < nums.size(); j++){
            if( iPosElements.end() != iPosElements.find(nums[j]) ){
                continue;
            }
            iPosElements.insert(nums[j]);
            swap(nums[i], nums[j]);
            GetAllPermuteUnique(nums, i+1, Result);
            swap(nums[i], nums[j]);
        }
    }
};

Sum组合问题

对于求2sum的问题，比较简单，就不需要采用回溯的方法，直接先对数组排序，然后采用two point的方法，前后夹击，找出所有组合。
3sum则就是将3sum问题转化为2sum就可以了。
对于k-sum，假设没有重复元素

class Solution {
public:
    /**
     * @param A: an integer array.
     * @param k: a positive integer (k <= length(A))
     * @param target: a integer
     * @return a list of lists of integer 
     */
    vector<vector<int> > kSumII(vector<int> A, int k, int target) {
        vector<vector<int> > resList;
        if( k < 1 || k > A.size() || A.empty() ) {
            return resList;
        }
        if( 1 == k ) {
            auto findPos = find(A.begin(), A.end(), target);
            if( findPos != A.end() ) {
                resList.push_back( vector<int>(1, *findPos) );
            }
            return resList;
        }

        sort(A.begin(), A.end());
        vector<int> res;
        Helper(A, 0, k, target, res, resList);

        return resList;
    }

    void Helper(vector<int>& A, int begin, int k, int target, vector<int>& res, vector<vector<int>>& resList) {
        if( begin+k > A.size() ) {
            return;
        }

        if( 2 == k ) {
            TwoSum(A, begin, target, res, resList);
            return;
        }

        for(int i = begin; i < A.size(); i++) {
            res.push_back(A[i]);
            Helper(A, i+1, k-1, target-A[i], res, resList);
            res.pop_back();
        }

    }

    void TwoSum(vector<int>& A, int begin, int target, vector<int>& res, vector<vector<int>>& resList) {
        int end = A.size() - 1;
        while( begin  < end ) {
            if( A[begin] + A[end] == target ) {
                res.push_back(A[begin]);
                res.push_back(A[end]);
                resList.push_back(res);
                res.pop_back();
                res.pop_back();
                begin++;
                end--;
            }else if( A[begin] + A[end] > target) {
                end--;
            }else{
                begin++;
            }
        }
    }

};

如果是求所有组合呢？没有k的限制，也是一样的

class Solution {
public:
    /**
     * @param num: Given the candidate numbers
     * @param target: Given the target number
     * @return: All the combinations that sum to target
     */
    vector<vector<int> > combinationSum2(vector<int> &num, int target) {
        vector<vector<int>> resList;
        if(num.empty()){
            return resList;
        }

        sort(num.begin(), num.end());
        vector<int> res;
        GetAllCombinationSum(num, 0, target, res, resList);
        return resList;
    }

    void GetAllCombinationSum(vector<int>&num, int cur, int target, vector<int>& res, vector<vector<int>>& resList){
        if(0 == target){
            resList.push_back(res);
            return;
        }else if(target < 0){
            return;
        }
        因为num是排好序的数组，重复元素肯定相邻，所以就可以采用这种办法来去除重复组合
        for(int i = cur; i < num.size(); i++){
            if(i != cur && num[i] == num[i-1]){
                continue;
            }
            res.push_back(num[i]);
            GetAllCombinationSum(num, i+1, target-num[i], res, resList);
            res.pop_back();
        }
    }
};

N-Queue问题也是一样的，在这里就不具体讲了。

小结

回溯是用来求所有解空间问题的，如果仅仅是求解的个数更像是DP问题，下面会有专门的一小节来将DP，这也是面试过程中常见的题目。当然如果每次从一个状态到下一个状态都不一样，DP也没有办法，还是需要回溯，因为DP解决的是重复计算问题，而从一个状态到到达的下一个状态没有重复则就没有重复计算，此时和回溯也就一样了。
回溯本质上是DFS，所以它是需要回到上次状态来试验下一条路径，就需要pop_back等类似操作将状态回归。另外一方面就是需要剪枝，因为回溯本身的复杂度会比较大，一般剪枝的策略就是采用排序和hash来去重，以及对于一些不可能答案直接返回。