算法刷题Day 27 组合总和+组合总和II+分割回文子串

Day 26 回溯算法

39. 组合总和

本题的特点是元素为可重复选取的

其实只要在原来的基础上添加一点小小的变化就是实现重复选取（与排列区别开），一时没想出来

class Solution {
    vector<vector<int>> rst;
    vector<int> path;
    int sum;

    void backtracking(vector<int> &candidates, int target, int idx)
    {
        if (sum == target)
        {
            rst.push_back(path);
            return;
        }
        else if (sum > target) return;

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

public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        rst.clear();
        path.clear();
        sum = 0;
        backtracking(candidates, target, 0);
        return rst;
    }
};

40. 组合总和II

这里与39.组合总和 (opens new window)最大的不同就是要去重了。

前面我们提到：要去重的是“同一树层上的使用过”，如何判断同一树层上元素（相同的元素）是否使用过了呢。

如果candidates[i] == candidates[i - 1] 并且 used[i - 1] == false，就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。

class Solution {
    int sum = 0;
    vector<int> path;
    vector<vector<int>> table;

    void backtracking(const vector<int> &candidates, int target, int idx)
    {
        if (sum == target)
        {
            table.push_back(path);
            return;
        }
        else if (sum > target)
        {
            return;
        }

        for (int i = idx; i < candidates.size(); ++i)
        {
            if (i > idx && candidates[i] == candidates[i - 1])
            {
                continue;
            }
            path.push_back(candidates[i]);
            sum += candidates[i];
            backtracking(candidates, target, i + 1);
            sum -= candidates[i];
            path.pop_back();
        }
    }

public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        path.clear();
        table.clear();
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0);
        return table;
    }
};

131. 分割回文子串

class Solution {
    vector<vector<string>> rst;
    vector<string> path;


    bool isValid(const string &s)
    {
        int left = 0, right = s.size() - 1;
        while (left < right)
        {
            if (s[left] != s[right])
            {
                return false;
            }
            left++;
            right--;
        }

        return true;
    }

    void backtracking(const string &s, int idx)
    {
        if (idx >= s.size())
        {
            rst.push_back(path);
            return;
        }

        for (int i = idx; i < s.size(); ++i)
        {
            auto tmp = s.substr(idx, i - idx + 1);
            if (isValid(tmp))
            {
                path.push_back(tmp);
                backtracking(s, i + 1);
                path.pop_back();
            }            
        }
    }

public:
    vector<vector<string>> partition(string s) {
        path.clear();
        rst.clear();
        backtracking(s, 0);
        return rst;
    }
};