算法学习——LeetCode力扣回溯篇2

40. 组合总和 II

40. 组合总和 II - 力扣（LeetCode）

描述

给定一个候选人编号的集合 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

代码解析

和39的区别是不能重复使用元素

回溯（无去重，超时）

无去重，只能在最后加入时候find查找是否存在一样，再加入

class Solution {
public:vector<vector<int>> result;vector<int> path;void backtarcking(vector<int>& candidates, int target , int sum ,int indnx){if(sum > target)return;if(sum == target){auto it = find(result.begin(),result.end(),path);if(it == result.end() ) result.push_back(path);return;}for(int i=indnx ; i < candidates.size() && sum + candidates[i] <= target ; i++){path.push_back(candidates[i]);backtarcking(candidates,target,sum+candidates[i],i+1);path.pop_back();}return;}vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {sort(candidates.begin(),candidates.end());backtarcking(candidates,target,0,0);return result;}
};

回溯去重

去重：在同一层上，值一样的元素只能用一次。同一枝上可以多次用

class Solution {
public:vector<vector<int>> result;vector<int> path;void backtarcking(vector<int>& candidates, int target , int sum ,int indnx){if(sum > target)return;if(sum == target){result.push_back(path);return;}for(int i=indnx ; i < candidates.size() && sum + candidates[i] <= target ; i++){//发现一样的元素这一层已经用过了，直接跳过这次if(i > indnx && candidates[i] == candidates[i-1]) continue;path.push_back(candidates[i]);backtarcking(candidates,target,sum+candidates[i],i+1);path.pop_back();}return;}vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {sort(candidates.begin(),candidates.end());backtarcking(candidates,target,0,0);return result;}
};

131. 分割回文串

131. 分割回文串 - 力扣（LeetCode）

描述

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

回文串 是正着读和反着读都一样的字符串。

示例

示例 1：

输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]

示例 2：

输入：s = “a”
输出：[[“a”]]

提示

• 1 <= s.length <= 16
• s 仅由小写英文字母组成

代码解析

class Solution {
public:vector<vector<string>> result;//判断字串是否是回文串bool check(const string &s){for(int i=0 ; i<s.size()/2 ; i++){if(s[i] != s[s.size()- 1 -i]) return false;}return true;}void backtracking(string s , int indnx  ,vector<string> &path){//当循环指针大于等于最大值的时候，认为分割出一种结果if(indnx >= s.size()){result.push_back(path);return;}//循环字符串长度，从index当前的运行指针开始切割回文串for(int i = indnx ; i<s.size() ;i++ ){string tmp;//切割字串，字串是indnx到i之间。for(int j = indnx ; j <= i ;j++){tmp += s[j];}// cout<<tmp<<endl;//检验字串是否为回文串，是回文串压入路径，不是i+1，进行下一个长度加1的字串if(check(tmp)==1)   path.push_back(tmp);else continue;//如果当前字串是回文串，递归indnx加1backtracking(s,i+1,path);//回溯，弹出上一个字串path.pop_back();}return;}vector<vector<string>> partition(string s) {if(s.size()==0) return result;vector<string> path;backtracking(s,0,path);return result;}
};

93. 复原 IP 地址

93. 复原 IP 地址 - 力扣（LeetCode）

描述

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。

例如：“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址。
给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 ‘.’ 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

示例

示例 1：

输入：s = “25525511135”
输出：[“255.255.11.135”,“255.255.111.35”]

示例 2：

输入：s = “0000”
输出：[“0.0.0.0”]

示例 3：

输入：s = “101023”
输出：[“1.0.10.23”,“1.0.102.3”,“10.1.0.23”,“10.10.2.3”,“101.0.2.3”]

提示

• 1 <= s.length <= 20
• s 仅由数字组成

代码解析

class Solution {
public:vector<string> result;vector<string> path;//判断是合法IPbool cheak(string &s){if(s.size()==0)return false;if(s.size() > 1 && s[0]=='0') return false;if (stoi(s) > 255) return false;return true;}void back_tracking(string &s , int indnx ){//IP最大短是4if(path.size() > 4)  return;//循环指针大于等于长度，并且IP段为四段。合法IPif(indnx >= s.size() && path.size()==4){string tmp;for(int i=0 ;i< path.size()-1 ;i++){tmp += path[i];tmp += '.';}tmp += path[path.size()-1];result.push_back(tmp);return;}//循环输入字符串，从index开始截取IP段for(int i=indnx ; i<s.size() ;i++){string tmp;//截取一个IP段，但是不超过3位for(int j = indnx ; j<=i  &&  (j-indnx)<=3 ;j++){tmp += s[j];}//检测是否为合法段，合法压入路径，不合法跳过该段if(cheak(tmp)==1) path.push_back(tmp);else continue;//递归back_tracking(s,i+1);//回溯path.pop_back();}return;}vector<string> restoreIpAddresses(string s) {back_tracking(s,0);return result;}
};

78. 子集

78. 子集 - 力扣（LeetCode）

描述

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示

• 1 <= nums.length <= 10
• -10 <= nums[i] <= 10
• nums 中的所有元素 互不相同

代码解析

与中序遍历N叉树非常的类似
每一个子集就是一个节点，遍历所有的节点

回溯遍历法（不要简单问题复杂化）

class Solution {
public:vector<vector<int>> result;vector<int> path;void backtracking(vector<int>& nums , int indnx  ){//每一个节点都加入，无须判断节点result.push_back(path);//如果遍历指针大于等于最深处，就返回if(indnx >= nums.size()) return;//横向循环for(int i=indnx ; i < nums.size() ; i++ ){//新值压入path.push_back(nums[i]);backtracking(nums,i+1);//递归path.pop_back();//回溯}return;}vector<vector<int>> subsets(vector<int>& nums) {backtracking(nums,0);return result;}
};

90. 子集 II

90. 子集 II - 力扣（LeetCode）

描述

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示

• 1 <= nums.length <= 10
• -10 <= nums[i] <= 10

代码解析

去重分为层次去重和树枝去重

• 层次去重
  是一个元素只能用一次（一样的两个可以用两次，【1，2，2】两个2各自可用一次）。
  if (i > indnx && nums[i] == nums[i - 1] ) continue; 当前的和上一个相同就跳过
• 树枝去重
  是数值一样的元素只能用一个，（一样的两个元素也只能用一次。【1，2，2】两个2只能用一个2）
  回溯去重

class Solution {
public:vector<vector<int>> result;vector<int> path;int pre;void backtracking(vector<int>& nums , int indnx){result.push_back(path);if(indnx >= nums.size())return;for(int i= indnx ; i < nums.size() ; i++){if (i > indnx && nums[i] == nums[i - 1] ) { continue;}path.push_back(nums[i]);backtracking(nums , i+1);path.pop_back();}return;}vector<vector<int>> subsetsWithDup(vector<int>& nums) {sort(nums.begin(),nums.end());backtracking(nums,0);return result;}
};