算法笔记（java）—

算法笔记（java）——回溯篇

回溯算法解决问题最有规律性，借用一下卡哥的图：
在这里插入图片描述

只要遇到上述问题就可以考虑使用回溯，回溯法的效率并不高，是一种暴力解法，其代码是嵌套在for循环中的递归，用来解决暴力算法解决不了的问题，即可以通过回溯控制递归的层数，递归后可以进行回溯操作，这样下一次循环就不会收到上一次的影响。解决回溯问题的关键就在于清楚整个回溯递归过程，毕竟是嵌套在for循环中的递归，最好的办法就是把所有情况画成一个树，这样就比较清晰了。

递归通用模版和常用API

void backtracking(参数) {if (终止条件) {存放结果;return;}for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {处理节点;backtracking(路径，选择列表); // 递归回溯，撤销处理结果}
}

常用API

temp常用LinkedList，因为可以在回溯的时候快速删除最后一个元素，添加使用add，删除使用removeLast
将temp添加进result时，要new一个新的arrayList将temp传入构造器，因为temp是全局共享的，如果不new那么result里没有值
如果需要下一层递归指向下一个数，那么要加参数startIndex，如果是排列问题等，每次从头开始，就不需要了

回溯简单示例

力扣题目：

第77题. 组合

给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。

示例: 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]

暴力for循环是没法解决本题的，因为不知道要写多少层，所以使用回溯法。
本题图解：
在这里插入图片描述
本题代码：

class Solution {List<List<Integer>> result = new ArrayList<>();LinkedList<Integer> temp = new LinkedList<>();public List<List<Integer>> combine(int n, int k) {backTracking(n,k,1);return result;}public void backTracking(int n,int k,int startIndex){if(temp.size() == k){result.add(new ArrayList<Integer>(temp));return;}for(int i=startIndex;i<=n-(k-temp.size())+1;i++){temp.add(i);backTracking(n,k,i+1);temp.removeLast(); //  回溯}}
}

去重问题

去重是使用回溯算法时遇到的最重要的问题，卡哥将去重分为了树枝去重以及数层去重，就是for循环的去重和各层递归的去重，一个横向一个纵向。

最常用的去重思路：
先对原数组排序，使用used数组，对横向for循环去重，对纵向递归不去重。

力扣题目：

40. 组合总和 II

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

本题图示：
在这里插入图片描述
可以看到只要排序好，进行横向去重就行了。used数组的作用就是去重的时候不要误删纵向情况，因为used数组有回溯操作，下一次for循环的used[i-1]是false了已经,而下一层递归是true，以此为条件进行判断。

class Solution {// 去重，去重横向的，纵向递归的不去重，要用used[i-1]防止纵向的被去重的时候误删List<List<Integer>> result = new ArrayList<>();LinkedList<Integer> temp = new LinkedList<>();public List<List<Integer>> combinationSum2(int[] candidates, int target) {if(candidates == null && candidates.length == 0){return null;}Arrays.sort(candidates);boolean[] used = new boolean[candidates.length];backtracking(candidates,target,0,0,used);return result;}public void backtracking(int[] candidates,int target,int sum,int startIndex,boolean[] used){if(sum == target){result.add(new ArrayList<>(temp));return;}for(int i=startIndex;i<candidates.length && sum+candidates[i]<=target;i++){if(i>0 && candidates[i] == candidates[i-1] && used[i-1] == false){continue;}sum += candidates[i];temp.add(candidates[i]);used[i] = true;backtracking(candidates,target,sum,i+1,used);used[i] = false;temp.removeLast();sum -= candidates[i];}}
}

还有用used数组去重不了的情况
Set去重
力扣题目：

491. 递增子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中至少有两个元素。你可以按任意顺序返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

这道题显然是不能用used数组的，因为没法排序，排序后就判断不了递增子序列了。使用hashset或者数组进行去重

class Solution {// 不能排序的去重，使用hashsetList<List<Integer>> result = new ArrayList<>();LinkedList<Integer> temp = new LinkedList<>();public List<List<Integer>> findSubsequences(int[] nums) {backTracking(nums,0);return result;}public void backTracking(int[] nums,int startIndex){if(judge(temp)){result.add(new ArrayList<>(temp));}HashSet<Integer> set = new HashSet<>();for(int i= startIndex;i<nums.length;i++){if(set.contains(nums[i])){continue;}set.add(nums[i]);temp.add(nums[i]); backTracking(nums,i+1);temp.removeLast();}}public boolean judge(List<Integer> list){if(list.size()<2){return false;}for(int i=0,j=0;j<list.size()-1;i++){j=i+1;if(list.get(i)>list.get(j)){return false;}}return true;}
}

每层递归都有自己的hastSet，然后可以对横向for循环去重，因为每一层递归set都不一样，所以不会影响到纵向递归。使用数组同理，和set差不多。

其他问题

排列和组合的区别：

排列是每次递归都是从头开始的：
力扣题目：

46. 全排列

在这里插入图片描述

使用used数组是来判断这个元素有没有在上层递归使用过，毕竟每次都是从0开始

class Solution {List<List<Integer>> result = new ArrayList<>();LinkedList<Integer> temp = new LinkedList<>();public List<List<Integer>> permute(int[] nums) {boolean[] used =new boolean[nums.length];backTracking(nums,used);return result;}public void backTracking(int[] nums,boolean[] used){if(temp.size() == nums.length){result.add(new ArrayList<>(temp));return;}for(int i=0;i<nums.length;i++){if(used[i] == true){continue;}temp.add(nums[i]);used[i] = true;backTracking(nums,used);used[i] = false;temp.removeLast();}}
}