算法训练 day27 | 39. 组合总和 40.组合总和II 131.分割回文串

39. 组合总和

题目链接:组合总和

视频讲解:Leetcode:39. 组合总和讲解

        本题集合里的元素可以用无数次，那么相较于组合总和III，只是搜索的起点idx不一样，下一层递归还可以从上一层递归的起点开始遍历。对于剪枝操作，是在for循环里，循环条件可以加上遍历时算的和小于等于目标值。剪枝需要排序。

class Solution {
public:
    vector<int> v;
    vector<vector<int>> ret;
    void back(vector<int>& candidates, int target, int sum, int idx)
    {
        if (sum > target) return;
        if (sum == target)
        {
            ret.push_back(v);
            return;
        }

        for (int i = idx; i < candidates.size() && sum + candidates[i] <= target; ++i)
        {
            sum += candidates[i];
            v.push_back(candidates[i]);
            back(candidates, target, sum, i);
            sum -= candidates[i];
            v.pop_back();
        }
    }

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        back(candidates, target, 0, 0);
        return ret;
    }
};

40.组合总和II

题目链接:组合总和II
 

视频讲解:回溯算法中的去重

       本题集合中有重复数字，但找出的组合不允许有重复，先对集合排序，相同值的元素肯定是相邻的，它们中任意一个元素与其他元素的组合种类都是一样的，所以当遍历到重复元素时，只留下第一个元素，后面重复的跳过去，这样就做到去重了。但是在纵向便利的时候，虽然元素的值相等，但元素不同，也是要遍历到的。纵向遍历时，用一个bool型的used数组记录使用过的元素为true，回溯时就变回了false，当进行横向遍历时，为false的元素就是重复的元素，应跳过。

// 时间复杂度: O(n * 2^n)
// 空间复杂度: O(n)
class Solution {
public:
    vector<int> v;
    vector<vector<int>> ret;
    void back(vector<int>& candidates, int target, int sum, int idx, vector<bool>& used)
    {
        if (sum > target) return;

        if (sum == target)
        {
            ret.push_back(v);
            return;
        }

        for (int i = idx; i < candidates.size(); ++i)
        {
            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false)
            {
                continue;
            }
            v.push_back(candidates[i]);
            sum += candidates[i];
            used[i] = true;
            back(candidates, target, sum, i + 1, used);
            used[i] = false;
            v.pop_back();
            sum -= candidates[i];
        }
    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        vector<bool> used(candidates.size(), false);
        back(candidates, target, 0, 0, used);
        return ret;
    }
};

131.分割回文串 

题目链接:分割回文串

视频讲解:131.分割回文串

        分割其实与组合类似，也可以抽象成一棵树形结构，用递归纵向遍历，for循环横向遍历。

递归

1、确定递归函数的返回值和参数

用两个全局变量分别放切割后的字符串和结果集。递归需传入字符串和切割的起始位置idx，不用返回值。

2、确定终止条件

遍历到字符串最后面，说明找到一种切割方法，结束本层递归。

3、确定单层递归逻辑

我们在for循环中截取的子串为[idx,i]，就要判断这一节是不是回文串，如果是，就放入字符串数组中。

// 时间复杂度: O(n * 2^n)
// 空间复杂度: O(n^2)
class Solution {
public:
    vector<string> v;
    vector<vector<string>> ret;

    bool Palindrome(const string& s, int begin, int end)
    {
        for (int i = begin, j = end; i < j; i++, j--)
        {
            if (s[i] != s[j])
                return false;
        }
        return true;
    }

    void back(string s, int idx)
    {
        if (idx >= s.size())
        {
            ret.push_back(v);
            return;
        }
        for (int i = idx; i < s.size(); ++i)
        {
            if (Palindrome(s, idx, i))
            {
                string str = s.substr(idx, i - idx + 1);
                v.push_back(str);
            }
            else {
                continue;
            }
            back(s, i + 1);
            v.pop_back();
        }
    }

    vector<vector<string>> partition(string s) {
        v.clear();
        ret.clear();
        back(s, 0);
        return ret;
    }
};