代码随想录刷题第26天

代码随想录刷题第26天

组合总和

/*
* @lc app=leetcode.cn id=39 lang=cpp
*
* [39] 组合总和
*
* https://leetcode.cn/problems/combination-sum/description/
*
* algorithms
* Medium (72.62%)
 * Likes:    2346
* Dislikes: 0
 * Total Accepted:    671.9K
* Total Submissions: 925.2K
 * Testcase Example:  '[2,3,6,7]\n7'
*
* 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target
* 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
* 
* candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 
* 
* 对于给定的输入，保证和为 target 的不同组合数少于 150 个。
* 
* 
* 
* 示例 1：
* 
* 
* 输入：candidates = [2,3,6,7], target = 7
* 输出：[[2,2,3],[7]]
* 解释：
* 2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
* 7 也是一个候选， 7 = 7 。
* 仅有这两种组合。
* 
* 示例 2：
* 
* 
* 输入: candidates = [2,3,5], target = 8
* 输出: [[2,2,2,2],[2,3,3],[3,5]]
* 
* 示例 3：
* 
* 
* 输入: candidates = [2], target = 1
* 输出: []
* 
* 
* 
* 
* 提示：
* 
* 
* 1 <= candidates.length <= 30
* 2 <= candidates[i] <= 40
* candidates 的所有元素 互不相同
* 1 <= target <= 40
* 
* 
*/
 
// @lc code=start
#include <vector>
#include<algorithm>
using namespace std;
class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    int sum = 0;
    void    backtracking(vector<int>& candidates, int target,int index){
        if (sum == target)
        {
            result.push_back(path);
            return ;
        }
 
        for (int i = index; i < candidates.size() && candidates[i] + sum <= target ; i++)
        {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates,target,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);
            return result;
    }
};
// @lc code=end
 
 

组合总和 II

/*
* @lc app=leetcode.cn id=40 lang=cpp
*
* [40] 组合总和 II
*
* https://leetcode.cn/problems/combination-sum-ii/description/
*
* algorithms
* Medium (60.19%)
 * Likes:    1234
* Dislikes: 0
 * Total Accepted:    391.3K
* Total Submissions: 650.1K
 * Testcase Example:  '[10,1,2,7,6,1,5]\n8'
*
* 给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
* 
* candidates 中的每个数字在每个组合中只能使用 一次 。
* 
* 注意：解集不能包含重复的组合。 
* 
* 
* 
* 示例 1:
* 
* 
* 输入: candidates = [10,1,2,7,6,1,5], target = 8,
* 输出:
* [
* [1,1,6],
* [1,2,5],
* [1,7],
* [2,6]
* ]
* 
* 示例 2:
* 
* 
* 输入: candidates = [2,5,2,1,2], target = 5,
* 输出:
* [
* [1,2,2],
* [5]
* ]
* 
* 
* 
* 提示:
* 
* 
* 1 <= candidates.length <= 100
* 1 <= candidates[i] <= 50
* 1 <= target <= 30
* 
* 
*/
 
// @lc code=start
#include <vector>
#include<algorithm>
using namespace std;
class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    int sum = 0;
    void backtracking(vector<int>& candidates, int target,int index,vector<bool> & used){
        if (sum == target)
        {
            result.push_back(path);
            return;
        }
 
        for (int i = index; i <candidates.size() && sum + candidates[i] <= target ; i++)
        {
            if (i > 0 && candidates[i] == candidates[i-1] && used[i-1] == false)
            {
                continue;
            }
 
           sum += candidates[i];
            used[i] = true;
            path.push_back(candidates[i]);
            backtracking(candidates,target,i+1,used);
            used[i] = false;
            sum -= candidates[i];
            path.pop_back();
 
        }
 
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        vector<bool> used(candidates.size(),false);
        backtracking(candidates,target,0,used);
        return result;
    }
};
// @lc code=end
 
 

分割回文串

/*
* @lc app=leetcode.cn id=131 lang=cpp
*
* [131] 分割回文串
*
* https://leetcode.cn/problems/palindrome-partitioning/description/
*
* algorithms
* Medium (73.40%)
* Likes:    1380
* Dislikes: 0
* Total Accepted:    262.5K
* Total Submissions: 357.6K
* Testcase Example:  '"aab"'
*
* 给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。
* 
* 回文串 是正着读和反着读都一样的字符串。
* 
* 
* 
* 示例 1：
* 
* 
* 输入：s = "aab"
* 输出：[["a","a","b"],["aa","b"]]
* 
* 
* 示例 2：
* 
* 
* 输入：s = "a"
* 输出：[["a"]]
* 
* 
* 
* 
* 提示：
* 
* 
* 1 
* s 仅由小写英文字母组成
* 
* 
*/

// @lc code=start
#include<vector>
#include<algorithm>
#include<string>
usingnamespacestd;
classSolution{
public:
vector<vector<string>> result;
vector<string> path;

//回文子串的判断函数
boolisHuiwen(strings){
intright = s.size()-1;
intleft  = 0;
while(left <= right)
{
if(s[left] != s[right])
{
returnfalse;
}
left++;
right--;
}
returntrue;
}


//回溯函数
voidbacktracking(string&s,intindex){

if(index == s.size())
{
result.push_back(path);
return;
}

for(inti = index; i < s.size(); i++)
{
string str = s.substr(index,i - index + 1);
if(isHuiwen(str))
{
path.push_back(str);
// return ;
}else{
continue;
}
backtracking(s,i+1);
path.pop_back();


}

}
vector<vector<string>> partition(strings) {
backtracking(s,0);
returnresult;
}
};
// @lc code=end