code 回溯总结

1、回溯三部曲

一、回溯函数的返回值以及参数

// 返回值
List<List<Integer>> res = new ArrayList<>();
// 路径
Deque<Integer> path = new LinkedList<>();

二、回溯函数的终止条件

//定义 回溯
public void backTrack（）{
//终止条件
	if（终止条件）{
		//存放结果
		res.add(new ArrayList（path）);
		return；
	}
}

三、回溯搜索过程

for(选择：本层集合中元素（树中节点孩子的数量就是集合的大小){
	//处理
	path.push();
	//递归
	backtrack();
	//回溯，撤销处理结果
	path.pop();
}

案例

1、continue 用来同层搜索 break 用来深度搜索
2、index 什么时候用 同一个集合用 不同集合不用 
3、used[i - 1] == true，说明同一树枝nums[i - 1]使用过
  used[i - 1] == false，说明同一树层nums[i - 1]使用过
Deque<Integer> path = new LinkedList<>();
path.push(candidates[i]);
path.pop();

List<Integer> path = new ArrayList<>();
path.add(candidates[i]);
path.remove(path.size()-1);

40. 组合总和 II

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    Deque<Integer> path = new LinkedList<>();
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        boolean[] flag = new boolean[candidates.length];
        backTracking(candidates,target,0,flag);
        return res;
    }
    public void backTracking(int[] candidates,int target, int index,boolean[] flag){
        if(sum == target){
            res.add(new ArrayList(path));
            return;
        }

        for(int i = index;i < candidates.length && candidates[i] + sum <= target;i++){
            if(i > 0 && candidates[i] == candidates[i-1] &&  !flag[i-1]){
                continue;
            }
            flag[i] = true;
            sum +=candidates[i];
            path.push(candidates[i]);
            backTracking(candidates,target,i+1,flag);
            flag[i] = false;
            int remp = path.pop();
            sum -= remp;
        }
    }
}

39.组合总和

class Solution {

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        Arrays.sort(candidates);
        backtrack(candidates,target,0,0,result,path);
        return result;
    }
    public void backtrack(int[] candidates, int target,int sum,int index,List<List<Integer>> result,List<Integer> path){
        if(sum == target){
            result.add(new ArrayList<>(path));
            return ;
        }
        for(int i = index;i <candidates.length;i++){
            //1
            if(sum + candidates[i]>target) break;
            path.add(candidates[i]);
            //2
            backtrack(candidates,target,sum + candidates[i],i,result,path);
            path.remove(path.size()-1);

        }
    }
}