LeetCode刷题笔记 回溯算法集合
组合总和
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
class Solution {
public List<List<Integer>> combinationSum(int[] candidates, int target) {
List<List<Integer>> listAll = new ArrayList<>();
List<Integer> list = new ArrayList<>();
Arrays.sort(candidates);
find(listAll, list, candidates, target, 0);
return listAll;
}
public void find(List<List<Integer>> listAll, List<Integer> temp, int[] candidates, int target, int index) {
if(target == 0) {
listAll.add(temp);
return;
}
if(target < candidates[0]) return;
for(int i = index; i < candidates.length && candidates[i] <= target; i++) {
List<Integer> list = new ArrayList<>(temp);
list.add(candidates[i]);
find(listAll, list, candidates, target-candidates[i], i);
}
}
}
组合总和 II
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
class Solution {
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
Arrays.sort(candidates);
List<List<Integer>> res = new ArrayList<>();
find(res, 0, 0, new ArrayList<Integer>(), candidates, target);
return res;
}
public void find(List<List<Integer>> res, int index, int sum, List<Integer> tmp_list, int[] candidates, int target) {
if(sum == target) {
res.add(new ArrayList<>(tmp_list));
return;
}
for(int i = index; i < candidates.length; i++) {
if (sum + candidates[i] > target) break;
if (i > index && candidates[i] == candidates[i - 1]) continue; //去重
tmp_list.add(candidates[i]);
find(res, i+1, sum + candidates[i], tmp_list, candidates, target);
tmp_list.remove(tmp_list.size()-1); //去重,防止一个组合里面有相同的数,上面是防止有两个相同的数组
}
}
}
组合总和 III
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
class Solution {
public List<List<Integer>> combinationSum3(int k, int n) {
int[] nums = new int[]{1,2,3,4,5,6,7,8,9};
List<List<Integer>> ans = new ArrayList<List<Integer>>();
dfs(nums,0,n,k,new ArrayList<Integer>(),ans);
return ans;
}
private void dfs(int[] nums,int i,int left,int k,ArrayList<Integer> cur,List<List<Integer>> ans) {
if (left < 0) return ;
if (k == 0) {
if (left == 0) {
ans.add(new ArrayList<Integer>(cur));
return ;
} else return ;
}
for (int j = i;j < nums.length;j++) {
if (nums[j] > left) break;
cur.add(nums[j]);
dfs(nums,j+1,left - nums[j],k-1,cur,ans);
cur.remove(cur.size()-1);
}
}
}
全排列
给定一个没有重复数字的序列，返回其所有可能的全排列。
class Solution {
public List<List<Integer>> permute(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
List<Integer> t = new ArrayList<>();
for(int i = 0; i < nums.length; i++) {
t.add(nums[i]);
find(res, t, nums);
t.remove(0);
}
return res;
}
private void find(List<List<Integer>> res, List<Integer> tmp, int[] nums) {
if(tmp.size() == nums.length) {
res.add(new ArrayList<>(tmp));
return;
}
for(int i = 0; i < nums.length; i++) {
if(!tmp.contains(nums[i])) {
tmp.add(nums[i]);
find(res, tmp, nums);
tmp.remove(tmp.size()-1);
}
}
}
}
/* 方法二：不对数组进行加减操作，而是交换，这种方法更快 ----------------------------------*/
class Solution {
public List<List<Integer>> permute(int[] nums) {
//思路：运用递归的方法，
int len=nums.length;//记录数组的长度
int first=0;//
List<List<Integer>> output=new LinkedList<List<Integer>>();//建立一个输出的数组
//将数组转换成链表的形式，是因为定义的输出数组中的元素要求List类型的。
ArrayList<Integer> nums_li=new ArrayList<Integer>();
for(int num:nums){
nums_li.add(num);
}
digui(len,output,nums_li,first);//调用递归函数
return output;
}
//递归函数
public static void helper(int len,List<List<Integer>> output
,ArrayList<Integer>nums_li,int first){
//结束条件：当到数组中的最后一个元素时，即已经排列组合完毕，则输出
if(first==len){
output.add(new ArrayList<Integer>(nums_li));
}
int i;
for(i=first;i<len;i++){
Collections.swap(nums_li,first,i);
helper(len,output,nums_li,first+1);
Collections.swap(nums_li,first,i);
}
}
}
/* 方法三: 三个for循环，其实和for循环很像 -------------------------------------*/
class Solution {
public List<List<Integer>> permute(int[] nums) {
List<List<Integer>> result = new ArrayList<List<Integer>>();
List<Integer> l1 = new ArrayList<Integer>();
l1.add(nums[0]);
result.add(l1);
for(int i = 1;i<nums.length;i++){
List<List<Integer>> resultx = new ArrayList<List<Integer>>();
for(List<Integer> list:result){
// System.out.println(list);
for(int j =0;j<=list.size();j++ ){
List<Integer> list2 = new ArrayList<Integer>();
list2.addAll(list);
list2.add(j,nums[i]);
resultx.add(list2);
}
}
result = resultx;
}
return result;
}
}
全排列 II
给定一个可包含重复数字的序列，返回所有不重复的全排列。
class Solution {
public List<List<Integer>> permuteUnique(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
Arrays.sort(nums);
// 添加visited数组，区分相等数字，以及同一排列里面相等但不相同的数字
int[] visited = new int[nums.length];
backtrack(res, nums, visited, new ArrayList<Integer>());
return res;
}
private void backtrack(List<List<Integer>> res, int[] nums, int[] visited, ArrayList<Integer> tmp) {
if (tmp.size() == nums.length) {
res.add(new ArrayList<>(tmp));
return;
}
for (int i = 0; i < nums.length; i++) {
if (visited[i] == 1 || (i > 0 && visited[i - 1] == 0 && nums[i - 1] == nums[i])) continue;
visited[i] = 1;
tmp.add(nums[i]);
backtrack(res, nums, visited, tmp);
tmp.remove(tmp.size() - 1);
visited[i] = 0;
}
}
}
子集
给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
class Solution {
public List<List<Integer>> subsets(int[] nums) {
ArrayList<List<Integer>> res = new ArrayList<>();
subsetsCore(res, new ArrayList<Integer>(), nums, 0);
return res;
}
private void subsetsCore(ArrayList<List<Integer>> res, ArrayList<Integer> list, int[] nums, int index) {
res.add(new ArrayList<>(list));
for (int i = index; i < nums.length; i++) {
list.add(nums[i]);
subsetsCore(res, list, nums, i + 1);
list.remove(list.size() - 1);
}
}
}
/* 方法二: 两个for循环完成 -------------------------------------*/
class Solution {
public List<List<Integer>> subsets(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
result.add(new ArrayList<>());
for(int n : nums){
int size = result.size();
for(int i=0; i<size; i++){
List<Integer> subset = new ArrayList<>(result.get(i));
subset.add(n);
result.add(subset);
}
}
return result;
}
}
子集 II
给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。
class Solution {
public List<List<Integer>> subsetsWithDup(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
Arrays.sort(nums);
backTrack(res,nums,new ArrayList<Integer>(),0);
return res;
}
public void backTrack(List<List<Integer>> res,int []nums,List<Integer>tmp,int start){
res.add(new ArrayList<>(tmp));
for(int i=start;i<nums.length;i++){
if(i > start && nums[i] == nums[i-1]) continue;
tmp.add(nums[i]);
backTrack(res,nums,tmp,i+1);
tmp.remove(tmp.size()-1);
}
}
}
组合
给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
class Solution {
public List<List<Integer>> combine(int n, int k) {
List<List<Integer>> res = new ArrayList<>();
helper(n, k, 1, res, new ArrayList<Integer>());
return res;
}
private void helper(int n, int k, int start, List<List<Integer>> res, List<Integer> temp) {
if(temp.size() == k) {
res.add(new ArrayList<>(temp));
return;
}
for(int j = start; j <= n - (k - temp.size()) + 1; j++) {
temp.add(j);
helper(n, k, j+1, res, temp);
temp.remove(temp.size()-1);
}
}
}
93. 复原IP地址
给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
class Solution {
public List<String> restoreIpAddresses(String s) {
List<String> res = new ArrayList<>();
helper(0, "", 4, s, res, s.length());
return res;
}
private void helper(int start, String temp, int flag, String s, List<String> list, int len) {
if(start==len && flag==0) {
list.add(temp.substring(0, temp.length()-1)); //-1是为了把最后的"."去掉
return;
}
if(flag < 0) return;
for(int i = start; i < start+3; i++) {
if(i < len) {
if(start==i && s.charAt(i)=='0') { //如果是子字符串的首位且为0
helper(i+1, temp+s.charAt(i)+".", flag-1, s, list, len);
break;
}
if(Integer.parseInt(s.substring(start, i+1)) <= 255)
helper(i+1, temp+s.substring(start, i+1)+".", flag-1,
s, list, len);
}
}
}
}
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/permutation-sequence