代码随想录 - 训练营8期- day 27

最新推荐文章于 2024-10-02 23:40:03 发布

薇薇拉

最新推荐文章于 2024-10-02 23:40:03 发布

阅读量80

点赞数

文章标签：算法 leetcode c++ Powered by 金山文档

本文链接：https://blog.csdn.net/RossQAQ/article/details/129237089

版权

文章介绍了使用回溯算法解决39.组合总和、40.组合总和II和131.分割回文串这三个问题，强调了剪枝优化和处理重复元素的方法。在组合问题中，通过排序和限制条件减少无效搜索；在分割回文串问题中，识别并构造回文子串是关键。

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

● 39. 组合总和
● 40.组合总和II
● 131.分割回文串

39. 组合总和

class Solution {
    int sum {};
    vector<int> path;
    vector<vector<int>> res;
    void BackTracking(vector<int>& candidates, int target, int startIdx) {
        if(sum > target) {
            return;
        }
        if(sum == target) {
            res.push_back(path);
            return;
        }
        for(int i = startIdx; 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) {
        BackTracking(candidates, target, 0);
        return res;
    }
};

剪枝

昨天我就感觉多搜了一层，今天这个题果然如此

记得排序...

class Solution {
    int sum {};
    vector<int> path;
    vector<vector<int>> res;
    void BackTracking(vector<int>& candidates, int target, int startIdx) {
        if(sum == target) {
            res.push_back(path);
            return;
        }
        for(int i = startIdx; i < candidates.size() && candidates[i] + sum <= target; ++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) {
        sort(candidates.begin(), candidates.end());
        BackTracking(candidates, target, 0);
        return res;
    }
};

40. 组合总和 II

这个题首先想到把用过的记录下来，然后就是，我们需要去的是同一层（代表不同解）内元素的重复

要排序，把相同元素放一起，相同的才需要去重，

之后就是 used[i - 1] = false 代表重复（因为上层的元素第一次出现后回溯时置0）

为 true 是在同一解答案里重复

最后就是 index 每次都取 i + 1，毕竟不能选自己

此外 vector<bool> 也有坑，虽然这里没关系

class Solution {
    int sum {};
    vector<int> path;
    vector<vector<int>> res;
    void BackTracking(vector<int>& candidates, vector<bool>& used, int target, int startIdx) {
        if(sum == target) {
            res.push_back(path);
            return;
        }
        for(int i = startIdx; i < candidates.size() && candidates[i] + sum <= target; ++i) {
            if(i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
                continue;
            }
            path.push_back(candidates[i]);
            sum += candidates[i];
            used[i] = true;
            BackTracking(candidates, used, target, i + 1);
            used[i] = false;
            sum -= candidates[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(), false);
        sort(candidates.begin(), candidates.end());
        BackTracking(candidates, used, target, 0);
        return res;
    }
};

131. 分割回文串

用 startIdx 来确定是否切割到底了，如果切割到底那就说明已经是答案了

在循环时判断是否是回文子串

这个题真的好难，要理解一下

主要是回溯时候如何判断是否是子串

class Solution {
    bool Palindrome(const string& str, int begin, int end) {
        int i = begin, j = end;
        while(i < j) {
            if(str[i++] != str[j--]) {
                return false;
            }
        }
        return true;
    }
    vector<string> substr;
    vector<vector<string>> res;
    void BackTracking(const string& s, int startIdx) {
        if(startIdx == s.size()) {
            res.push_back(substr);
            return;
        }
        for(int i = startIdx; i < s.length(); ++i) {
            if(Palindrome(s, startIdx, i)) {
                string str = s.substr(startIdx, i - startIdx + 1);
                substr.push_back(str);
            } else {
                continue;
            }
            BackTracking(s, i + 1);
            substr.pop_back();
        }
    }
public:
    vector<vector<string>> partition(string s) {
        BackTracking(s, 0);
        return res;
    }
};