代码训练营Day.27 | 39. 组合总和、40. 组合总和II、131. 分割回文串

最新推荐文章于 2024-11-16 21:36:47 发布

怕批龙-_-#

最新推荐文章于 2024-11-16 21:36:47 发布

阅读量351

点赞数 4

文章标签：算法

本文链接：https://blog.csdn.net/papilon_/article/details/135449302

版权

文章讲述了在LeetCode中解决的三个问题：组合总和允许重复数字、组合总和II避免重复组合、以及分割回文串的递归策略。通过回溯和剪枝优化算法，展示了如何用递归方法求解这些问题。

摘要由CSDN通过智能技术生成

39. 组合总和

1. LeetCode链接

. - 力扣（LeetCode）

2. 题目描述

3. 解法

与其他组合总和题目不同的是，这一次数组中的数字可以重复使用。

回溯：

1. 参数和返回值。参数：数组、遍历起点、目标值。

2. 终止条件。target < 1 则终止。

3. 单层递归逻辑。遍历数组，将每一个数当作当前递归层的候选值，然后进一步递归。因为可以重复使用，所以下一层的起点仍然是当前值的位置而不用+1；target -= vec[i]。当target == vec[i]时，将result压入results。

class Solution {
public:
    vector<vector<int>> results;
    vector<int> result;
    void backtracking(vector<int>& vec, int start, int target) {
        if (target < 1) return;
        for (int i = start; i < vec.size(); i++) {
            result.push_back(vec[i]);
            if (target == vec[i]) results.push_back(result);
            else backtracking(vec, i, target - vec[i]);
            result.pop_back();
        }
        return;
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtracking(candidates, 0, target);
        return results;
    }
};

40. 组合总和II

1. LeetCode链接

. - 力扣（LeetCode）

2. 题目描述

3. 解法

与其他组合总和不同的是，数组中含有相同数字，而仍然要求两种答案不可重复。

方法就是先排序，再组合，当前递归层的候选值只选每种数字的第一个。

注意，在跳过重复数字时，不要额外i++。

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

剪枝：

class Solution {
public:
    vector<vector<int>> results;
    vector<int> result;
    void backtracking(vector<int>& vec, int start, int target) {
        if (target == 0) {
            results.push_back(result);
            return;
        }
        for (int i = start; i < vec.size() && target >= vec[i]; i++) { // 剪枝
            if (i > start && (vec[i] == vec[i - 1])) {
                continue;
            }
            result.push_back(vec[i]);
            backtracking(vec, i + 1, target - vec[i]);
            result.pop_back();
        }
        return;
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, 0, target);
        return results;
    }
};

131. 分割回文串

1. LeetCode链接

. - 力扣（LeetCode）

2. 题目描述

3. 解法

比较难想到，但仍然是组合问题，组合总和问题是本层递归要选哪个数字为候选值，分割回文串问题是本层递归要分割前几个合为回文串的字符作为候选字符串。

每一层的要割的回文串起点，取决于上一层递归割的终点。

所以不难想到：

class Solution {
public:
    vector<vector<string>> results;
    vector<string> result;
    bool huiwen(string s) {
        for (int left = 0, right = s.size() - 1; left < s.size(); left++, right--) {
            if (s[left] != s[right]) return false;
        }
        return true;
    }
    void backtracking(string& s, int start) {
        if (start == s.size()) {
            results.push_back(result);
            return;
        }
        for (int i = start; i < s.size(); i++) {
            string ss(s.begin() + start, s.begin() + i + 1);
            if (!huiwen(ss)) continue;
            result.push_back(ss);
            backtracking(s, i + 1);
            result.pop_back();
        }
        return;
    }
    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return results;
    }
};