代码随想录算法训练营Day23 | 39. 组合总和 | 40.组合总和II | 131.分割回文串

今日任务

39. 组合总和

• 题目链接： https://leetcode.cn/problems/combination-sum/description/
• 题目描述：

Code

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> ans;
        // vector<int> path;
        // int n = candidates.size();
        // function<void(int, int)> dfs = [&](int i, int t)->void{
        //     if(t == 0){
        //         ans.emplace_back(path);
        //         return;
        //     }
        //     if(i >= n || t < 0){
        //         return;
        //     }
        //     // 不选
        //     dfs(i + 1, t);

        //     path.push_back(candidates[i]);
        //     dfs(i, t - candidates[i]);
        //     path.pop_back();
        // };
        // dfs(0, target);
        // return ans;

        // ranges::sort(candidates);
        // vector<int> path;
        // int n = candidates.size();
        // function<void(int, int)> dfs = [&](int i, int t)->void{
        //     if(t == 0){
        //         ans.emplace_back(path);
        //         return;
        //     }
        //     if(i == n || t < candidates[i]){
        //         return;
        //     }
        //     dfs(i + 1, t);

        //     path.push_back(candidates[i]);
        //     dfs(i, t - candidates[i]);
        //     path.pop_back(); 
        // };
        // dfs(0, target);
        // return ans;

        ranges::sort(candidates);
        vector<int> path;
        int n = candidates.size();
        function<void(int, int)> dfs = [&](int i, int t)->void{
            if(t == 0){
                ans.emplace_back(path);
                return;
            }
            if(t < candidates[i]){
                return;
            }

            for(int j = i; j < n; j++){
                path.push_back(candidates[j]);
                dfs(j, t - candidates[j]);
                path.pop_back(); 
            }
        };
        dfs(0, target);
        return ans;
    }
};

40.组合总和II

• 题目链接： https://leetcode.cn/problems/combination-sum-ii/description/
• 题目描述 ：
  

Code

class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<vector<int>> ans;
        vector<int> path;
        ranges::sort(candidates);
        int n = candidates.size();
        function<void(int, int)> dfs = [&](int i, int t)->void{
            if(t == 0){
                ans.emplace_back(path);
                return;
            }
            if(i == n || t < candidates[i]){
                return;
            }

            // for(int j = i; j < n; j++){
            //     if(j == i || j > i && candidates[j] != candidates[j - 1]){
            //         path.push_back(candidates[j]);
            //         dfs(j + 1, t - candidates[j]);
            //         path.pop_back(); 
            //     }
            // }

        };
        dfs(0, target);
        return ans;
    }
};

131.分割回文串

• 题目链接： https://leetcode.cn/problems/palindrome-partitioning/description/
• 题目描述 ：
  

Code

class Solution {
    bool isPalindrome(string &s, int left, int right){
        while(left < right){
            if(s[left++] != s[right--]){
            return false;
            }
        }
        return true;
    }
public:
    vector<vector<string>> partition(string s) {
        vector<vector<string>> ans;
        vector<string> path;
        int n = s.size();

        // function<void(int)> dfs = [&] (int i) -> void {
        //     if(i == n){
        //         ans.emplace_back(path);
        //         return ;
        //     }

        //     for(int j = i; j < n; j++){
        //         if(isPalindrome(s, i, j)){
        //             path.push_back(s.substr(i, j - i + 1));     
        //             dfs(j + 1);
        //             path.pop_back();
        //         }
        //     }

        // };
        // dfs(0);

        // 选或不选逗号
        function<void(int, int)> dfs = [&](int i, int start)->void{
            if(i == n){
                ans.emplace_back(path);
                return;
            }

            if(i < n - 1){
                dfs(i + 1, start);
            }

            if(isPalindrome(s, start, i)){
                path.push_back(s.substr(start, i - start + 1));
                dfs(i + 1, i + 1);
                path.pop_back();
            }
        };
        dfs(0, 0);
        return ans;
    }
};