代码随想录DAY30：回溯

回溯

题目描述

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

思路

组合：元素不重复，可重复选择
终止条件：trackSum == target 更新 res 并返回； trackSum > target 时直接返回
路径：candidates
选择列表：当前元素及其右侧元素，start 控制 “ 不同组合”，到下一层的回溯参数 i + 1 表示元素不可重复选择， i 表示参数可以重复选择。

代码

class Solution {
private:
    vector<vector<int>> res;
    vector<int> track;
    int trackSum;
public:
    void backtrack(vector<int>& candidates, int target, int start)
    {
        if (trackSum == target)
        {
            res.push_back(track);
            return;
        }
        if (trackSum > target)
        {
            return;
        }

        for (int i = start; i < candidates.size(); i++)
        {
            track.push_back(candidates[i]);
            trackSum += candidates[i];
			
			//重点：元素可重复选择，参数为 i
            backtrack(candidates, target, i);
            
            track.pop_back();
            trackSum -= candidates[i];
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        trackSum = 0;
        backtrack(candidates, target, 0);
        return res;
    }
};

题目描述

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

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

注意：解集不能包含重复的组合。

思路

组合：
① 包含重复元素：排序
② 单个元素不可重复选择：i + 1
③ 相同元素最多选择一次：used
④ 解集不包含重复组合：start 右侧

结束条件：trackSum == target
路径：走过的元素
选择列表：与当前元素不同的元素

代码

class Solution {
private:
    vector<vector<int>> res;
    vector<int> track;
    int trackSum;
public:
    void backtrack(vector<int>& candidates, int target, int start,vector<bool>& used)
    {
        if (trackSum == target)
        {
            res.push_back(track);
            return;
        }
        if (trackSum > target)
        {
            return;
        }

        for (int i = start; i < candidates.size(); i++)
        {
            if (i > 0 && candidates[i] == candidates[i - 1] && !used[i - 1])
            {
                continue;
            }
            track.push_back(candidates[i]);
            trackSum += candidates[i];
            used[i] = true;
            backtrack(candidates, target, i + 1, used);

            track.pop_back();
            trackSum -= candidates[i];
            used[i] = false;
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        res.clear();
        track.clear();
        vector<bool> used(candidates.size(), false);
        sort(candidates.begin(), candidates.end());
        trackSum = 0;
        backtrack(candidates, target, 0, used);
        return res;
    }
};

131. 分割回文串

131. 分割回文串

题目描述

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

回文串 是正着读和反着读都一样的字符串。

思路

组合：
① 得到字符串从当前下标开始的回文子串，依次进行组合
② 利用双指针写一个判断子串是否是回文的函数

结束条件： s 遍历结束， 下标超出 s.size()
路径： 已经走过的回文子串
选择： 当前下标之后的可能的回文子串

代码

class Solution {
private:
    vector<vector<string>> res;
    vector<string> track;
    bool isPalindrome(const string& s, int l, int r)
    {
        for (int i = l, j = r; i < j; i++, j--)
        {
            if (s[i] != s[j])
            {
                return false;
            }
        }
        return true;
    }
    void backtrack(const string& s, int start)
    {
        if (start >= s.size())
        {
            res.push_back(track);
            return;
        }

        for (int i = start; i < s.size(); i++)
        {
            if (isPalindrome(s, start, i))
            {
                string str = s.substr(start, i - start + 1);
                track.push_back(str);
            }
            else
            {
                continue;
            }
            backtrack(s, i + 1);
            track.pop_back();
        }
    }
public:
    vector<vector<string>> partition(string s) {
        res.clear();
        track.clear();

        backtrack(s, 0);
        return res;
    }
};