代码随想录【Day 26】 | 39. 组合总和、40.组合总和II、131.分割回文串

最新推荐文章于 2024-06-16 20:54:56 发布

Pittsman

最新推荐文章于 2024-06-16 20:54:56 发布

阅读量76

点赞数

分类专栏： LeetCode 代码随想录训练营文章标签：算法 leetcode 职场和发展

本文链接：https://blog.csdn.net/Pittsman/article/details/128950410

版权

LeetCode 同时被 2 个专栏收录

24 篇文章 0 订阅

订阅专栏

代码随想录训练营

24 篇文章 0 订阅

订阅专栏

代码随想录【Day 26】 | 39. 组合总和、40.组合总和II、131.分割回文串

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

39. 组合总和

题目链接：39. 组合总和

卡尔文解

视频讲解

解题思路及注意事项：

题目中的无限制重复被选取，吓得我赶紧想想出现0 可咋办，然后看到下面提示：1 <= candidates[i] <= 200，我就放心了。

本题和77.组合 (opens new window)，216.组合总和III (opens new window)的区别是：本题没有数量要求，可以无限重复，但是有总和的限制，所以间接的也是有个数的限制。

本题搜索的过程抽象成树形结构如下：

在这里插入图片描述

注意图中叶子节点的返回条件，因为本题没有组合数量要求，仅仅是总和的限制，所以递归没有层数的限制，只要选取的元素总和超过target，就返回！

而在77.组合 (opens new window)和216.组合总和III (opens new window)中都可以知道要递归K层，因为要取k个元素的组合。

代码实现：

class Solution {

vector<int> path;
vector<vector<int>> result;
int sum = 0;

void back_tracking( vector<int>& candidates, int target_sum, int sum, int startIdx ){

    if( sum > target_sum ) return;
    if( sum == target_sum) {
        result.push_back( path );
        return;
    }

    for( int idx = startIdx; idx < candidates.size(); idx++ ){

        path.push_back( candidates[ idx ] );
        sum += candidates[ idx ];
        back_tracking( candidates, target_sum, sum, idx );
        sum -= candidates[ idx ];
        path.pop_back();

    }


}

public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {

        if( candidates.empty() ) return {};

        back_tracking( candidates, target, sum, 0 );

        return result;
        
    }
};

40.组合总和II

题目链接：40.组合总和II

卡尔文解

视频讲解

解题思路及注意事项：

这道题目和39.组合总和 (opens new window)如下区别：

本题candidates 中的每个数字在每个组合中只能使用一次。
本题数组candidates的元素是有重复的，而39.组合总和 (opens new window)是无重复元素的数组candidates
最后本题和39.组合总和 (opens new window)要求一样，解集不能包含重复的组合。

本题的难点在于区别2中：集合（数组candidates）有重复元素，但还不能有重复的组合。

一些同学可能想了：我把所有组合求出来，再用set或者map去重，这么做很容易超时！

所以要在搜索的过程中就去掉重复组合。

很多同学在去重的问题上想不明白，其实很多题解也没有讲清楚，反正代码是能过的，感觉是那么回事，稀里糊涂的先把题目过了。

这个去重为什么很难理解呢，所谓去重，其实就是使用过的元素不能重复选取。这么一说好像很简单！

都知道组合问题可以抽象为树形结构，那么“使用过”在这个树形结构上是有两个维度的，一个维度是同一树枝上使用过，一个维度是同一树层上使用过。没有理解这两个层面上的“使用过” 是造成大家没有彻底理解去重的根本原因。

那么问题来了，我们是要同一树层上使用过，还是同一树枝上使用过呢？

回看一下题目，元素在同一个组合内是可以重复的，怎么重复都没事，但两个组合不能相同。

所以我们要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重。

为了理解去重我们来举一个例子，candidates = [1, 1, 2], target = 3，（方便起见candidates已经排序了）

强调一下，树层去重的话，需要对数组排序！

选择过程树形结构如图所示：
在这里插入图片描述

代码实现：

class Solution {

private:
    vector<int> path;
    vector<vector<int>> result;

    void back_tracking( vector<int>& candidates, int target, int sum, int startIdx, vector<int> &used ){

        if( sum > target ) return;

        if( target == sum ){
            result.push_back( path );
            return;
        }

        for( int i = startIdx; i < candidates.size(); i++ ){
            

            if( ( i > 0 ) && ( candidates[ i ] == candidates[ i - 1 ]) && !used[ i - 1 ] )
                continue;

            path.push_back( candidates[ i ] );
            sum += candidates[ i ];
            used[ i ] = 1;
            
            back_tracking( candidates, target, sum, i + 1, used );

            used[ i ] = 0;
            sum -= candidates[ i ];
            path.pop_back();
        }
    }


public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target ) {

        sort( candidates.begin(), candidates.end() );
        vector<int> used( candidates.size(), 0 );

        back_tracking( candidates, target, 0, 0, used );

        return result;
    }
};

131.分割回文串

题目链接：131.分割回文串

卡尔文解

视频讲解

解题思路及注意事项：

本题这涉及到两个关键问题：

切割问题，有不同的切割方式
判断回文

相信这里不同的切割方式可以搞懵很多同学了。

这种题目，想用for循环暴力解法，可能都不那么容易写出来，所以要换一种暴力的方式，就是回溯。

一些同学可能想不清楚回溯究竟是如何切割字符串呢？

我们来分析一下切割，其实切割问题类似组合问题。

例如对于字符串abcdef：

组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中再选取第三个…。
切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中再切割第三段…。
感受出来了不？

所以切割问题，也可以抽象为一棵树形结构，如图：

在这里插入图片描述

代码实现：

class Solution {
private:

    vector<string> path;
    vector<vector<string>> result;

    bool isPalindrome(const 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 back_tracking( string &s, int startIdx ){
        
        if( startIdx >= s.size() ){
            result.push_back( path );
            return;
        }

        for( int i = startIdx; i < s.size(); i++ ){

            if( !isPalindrome( s, startIdx, i ) )
                continue;
       
            path.push_back( s.substr( startIdx, ( i - startIdx + 1 )));

            back_tracking( s, i + 1 );

            path.pop_back();
        }
    }

public:
    vector<vector<string>> partition(string s) {

        back_tracking( s, 0 );
        return result;
    }
};