代码随想录算法训练营第二十七天|39. 组合总和 40.组合总和II 131.分割回文串

LeetCode 39.组合总和

题目链接：39.组合总和

踩坑：把元素可以重复利用理解成每次向下递归时集合都是原始集合。但是其实这样会造成重复。

思路：在向下递归时，开始的位置不再是当前元素的后一个，而是当前元素，即下一层递归也可以用当前元素。

代码：

class Solution {
public:
    void backtracking(vector<int>& candidates, int start, int target, vector<int> path, vector<vector<int>>& result)
    {
        if(target == 0)
        {
            result.push_back(path);
            return;
        }
        if(target < 0) return;

        for(int i = start; i < candidates.size(); i++)
        {
            path.push_back(candidates[i]);
            backtracking(candidates, i, target-candidates[i], path, result);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<int> path;
        vector<vector<int>> result;
        backtracking(candidates, 0, target, path, result);
        return result;
    }
};

LeetCode 40.组合总和II

题目链接：40.组合总和II

踩坑：一开始没感觉出来会重复（有点蠢）。。。

思路：重复的原理是如果有数组[1,5,2,3,9,4,1,3,5,6]，在从第一个1进行回溯的过程中一定会遍历到第二个1后面的3，即path中为[1,3]，此后的回溯过程会与从第二个1开始的回溯重复。所以可以对原始数组去重吗？？答案是不行，因为重复的数字只是数值相同，其还是两个元素，可以出现在结果集里。
我们可以先对数组进行排序，让相同的元素待在一起。同时明确两个概念，树枝遍历与数层遍历。如果为每一个元素做一个标记以表示该元素现在在不在path中，我们可以发现，如果当前元素的前一个元素在path中，那么我们正在向下递归，如果当前元素的前一个元素不在path中，那么我们正在横向回溯。而在向下递归的过程中，我们可以选择任意元素，不会造成结果重复，在横向回溯的过程中，我们不能选择相同元素，否则会造成结果重复。所以如果现在是横向回溯且当前元素与上一元素相等，我们直接跳过。

代码：

class Solution {
public:
    void backtracking(vector<int>& candidates, int start, vector<int>& used, int target, vector<int>& path, vector<vector<int>>& result)
    {
        if(target == 0)
        {
            result.push_back(path);
            return;
        }
        if(target < 0) return;

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

LeetCode 131.分割回文串

题目链接：131.分割回文串

踩坑：第一次接触使用回溯解决切割问题。

思路：切割和组合是一体两面的事情。将组合选取的元素之前直到上一个被选取元素的部分就可以看作一个字串。

代码：

class Solution {
public:
    void backtracking(string& s, int start, vector<string>& path, vector<vector<string>>& result)
    {
        if(start == s.length())
        {
            result.push_back(path);
            return;
        }

        for(int i = start; i < s.length(); i++)
        {
            if(huiwen(s, start, i))
            {
                string t = s.substr(start, i-start+1);
                path.push_back(t);
            }else continue;
            backtracking(s, i + 1, path, result);
            path.pop_back();
        }
    }

    bool huiwen(string& s, int left, int right)
    {
        while(left < right)
        {
            if(s[left++] != s[right--]) return false;
        }
        return true;
    }
    vector<vector<string>> partition(string s) {
        vector<string> path;
        vector<vector<string>> result;
        backtracking(s, 0, path, result);
        return result;
    }
};