【Day27】代码随想录回溯算法——组合总和、组合总和II、分割回文串

最新推荐文章于 2024-10-16 19:08:56 发布

李白不爱吃红烧肉

最新推荐文章于 2024-10-16 19:08:56 发布

阅读量865

点赞数 19

分类专栏： 2-数据结构与算法文章标签：算法数据结构

本文链接：https://blog.csdn.net/weixin_44043786/article/details/135739375

版权

2-数据结构与算法专栏收录该内容

60 篇文章 0 订阅

订阅专栏

本文讲述了如何使用回溯算法解决LeetCode中的组合总和（39、40题）问题，涉及递归、剪枝以及针对重复元素的处理。同时介绍了如何解决分割回文串（131题）的问题，关注切割逻辑和判断回文的方法。

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

昨天是周末正好学习，因为我的方向是嵌入式（单片机这种的），昨天就看了些八股，因为自己的技能树有限，Linux相关的那些东西也都没有学，开始有点压力了，暂定的是先把单片机学好，找到实习之后再学习Linux应用相关。但是算法部分也不能落下，开冲！！！

今日任务：

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

回顾下回溯算法的模板：

void backtracking(){
	if(终止条件){
		收集结果；
		return;	
	}
	for(){
		处理逻辑；
		递归函数；
		回溯
	}
	return;
}

题目一：39.组合总和

Leetcode题目：【39.组合总和】
参考：【代码随想录之组合总和】

在这里插入图片描述
思路：
1、利用target和来确定树的深度，当sum>target的时候直接return即可；
2、因为元素是可以重复的，所以应该在递归的时候传入的是i，而非i+1；
其余部分相对来说都是按照模板来即可。

class Solution {
public:

    vector<vector<int>> result;
    vector<int> path;

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

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

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

如何去做剪枝处理呢？当前的sum + 下一个元素一定要小于等于target的时候才能可以进入下一层递归，否则无法进入。
其次，剪枝操作通常都是在for循环中做文章的，然后 数组也需要先进行排序。

for(int  i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++)

所以完整代码如下：

class Solution {
public:

    vector<vector<int>> result;
    vector<int> path;

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

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

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end()); // 需要排序
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

题目二：40.组合总和II

Leetcode题目：【40.组合总和II】
参考：【代码随想录之组合总和II】

在这里插入图片描述
最开始的思路：
（1）还是跟上一个题一样，得出结果；
（2）新开辟一块vector，先对原数组进行排序，然后放入的时候和末尾一个进行比较，不一样就插入

但是这个代码会超出内存限制

class Solution {
public:

    vector<vector<int>> result;
    vector<vector<int>> final_result;
    vector<int> path;

    void backtracing(vector<int>& candidates, int target, int sum, int startIndex){
        if(sum > target) return;
        if(sum == target){
            result.push_back(path);
            return;
        }

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

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backtracing(candidates, target, 0, 0);
        sort(result.begin(), result.end());
        for(int i = 0; i < result.size(); i++){
            if(final_result.empty() || final_result.back() != result[i]){
                final_result.push_back(result[i]);
            }
        }
        return final_result;
    }
};

那如何在搜索过程中进行去重。卡哥自创了2个词：树层去重与树枝去重，我们主要处理的是树层去重，那如何区分是树枝去重还是树层去重呢？采用的是used数组，然后如果不处理的话，直接continue就可以了。

下面used的就是按照树形结构来写的

class Solution {
public:

    vector<vector<int>> result;
    vector<int> path;

    void backtracing(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used){
        if(sum > target) return;
        if(sum == target){
            result.push_back(path);
            return;
        }

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

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

题目三：131.分割回文串（困难）

Leetcode题目：【131.分割回文串】
参考：【代码随想录之分割回文串】

在这里插入图片描述
两个关键问题：
1、切割问题，有不同的切割方式
2、判断回文

正确的切割逻辑为：
在这里插入图片描述
startIndex表示切割的那个板。
终止条件比较很容易确定，当startIndex>=s.size()

单层递归的逻辑：
要截取的字串：[startIndex, i]，因为i是++的

class Solution {
public:

    vector<vector<string>> result;
    vector<string> path;
    bool isHuiWen(string& s, int start, int end){
        for(int i = start, j= end; i<j; i++, j--){
            if(s[i] != s[j]){
                return false;
            }
        }
        return true;
    }

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

        for(int i = startIndex; i<s.size(); i++){
            if(isHuiWen(s, startIndex, i)){
                path.push_back(s.substr(startIndex, i-startIndex + 1));
            }else{
                continue;
            }
            backtracking(s, i+1);
            path.pop_back();

        }

    }

    vector<vector<string>> partition(string s) {
        backtracking(s, 0);
        return result;

    }
};