回溯算法的基本原理与组合问题

参考代码随想录的总结

基础原理

什么是回溯算法？

递归与回溯是相辅相成的，回溯函数就是递归的回溯。
回溯算法是一个纯暴力的方法，可以通过剪枝的方法提高一些效率，但是仍然还是穷举的本质。

回溯法能解决的问题

• 组合问题：N个数里面按一定的规则找出k个数的集合。
• 切割问题 ： 给一个字符串，有几种切割的方式。
• 子集问题：一个N个数的集合中有多少符合条件的子集。
• 排列问题：N个数按照一定规则全排列，有几种排列方式。
• 棋盘问题：N皇后，解数独等等。

理解回溯法与模板

将回溯法的问题抽象为树形结构。回溯法解决的都是在集合中递归查找⼦集，集合的⼤⼩就构成了树的宽度，递归的深度构成的树的深度。递归是有终止的，所以回溯法可以理解成一个高度有限的N叉树。

回溯三部曲

• 回溯函数返回值以及参数

void backtracking(para)

• 终止条件
• 回溯搜索的遍历过程

for (选择：本层集合中元素(树中节点孩⼦的数量就是集合的⼤⼩)) {
	处理节点;
	backtracking(路径，选择列表); // 递归
	回溯，撤销处理结果
}

总框架

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

组合问题

第77题 组合

题目链接
给定两个整数 n 和 k，返回 1 ~ n 中所有可能的 k 个数的组合。
示例:
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

思路

1. 当k等于2的时候，可以使用两个for循环。第一个for从1遍历到n的size，第2层从i+1到size，打印i和j的组合就可以实现。当k等于3的时候，可以用3层for循环。但是这很明显无法实现更多层的情况。因此这个思路是行不通的。
2. 这里就需要用回溯的思路去做。

代码

public class combineClass {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>(); //为了使用其中removeLat
    void backtracking(int n, int k, int startIndex) {
        if (path.size() == k) {
            result.add(new ArrayList<>(path)); //合并的时候要转换成ArrayList
            return;
        }
        for (int i = startIndex; i <= n; i++) {
            path.add(i);
            backtracking(n, k, i + 1);
            path.removeLast();
        }
    }

    public List<List<Integer>> combine(int n, int k) {
        backtracking(n, k, 1);
        return  result;
    }
}

组合问题再剪枝

可以剪枝的地⽅就在递归中每⼀层的for循环所选择的起始位置。如果for循环选择的起始位置之后的元素个数 已经不⾜ 我们需要的元素个数了，那么就没有必要搜索了。
接下来看⼀下优化过程如下：

1. 已经选择的元素个数：path.size();
2. 还需要的元素个数为: k - path.size();
3. 在集合n中⾄多要从该起始位置 : n - (k - path.size()) + 1，开始遍历

for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) // i为本次搜索的起始位置

组合总和问题

第39题

给你一个 无重复元素 的整数数组 candidates 和一个目标整数target ,找出candidates中可以使数字和为目标数 target 的所有不同组合 ，并以列表形式返回。你可以按任意顺序返回这些组合。candidates 中的同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
对于给定的输入，保证和为 target 的不同组合数少于 150 个。
来源链接

思路

代码

static List<List<Integer>> result = new ArrayList<>();
    static LinkedList<Integer> path = new LinkedList<>();
    public static List<List<Integer>> combinationSum(int[] candidates, int target) {
        int Sum = 0;
        backtracking(candidates, target, Sum, 0);
        return result;
    }
    private static void backtracking(int[] candidates, int target, int Sum, int StartIndex) {
        if (Sum > target) {
            return;
        }
        if (Sum == target) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = StartIndex; i < candidates.length; i++) {
            Sum += candidates[i];
            path.add(candidates[i]);
            backtracking(candidates, target, Sum, i);
            Sum -= candidates[i];
            path.removeLast();
        }
    }

第216题力扣题目

力扣链接
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
说明：
所有数字都是正整数。
解集不能包含重复的组合。
示例 1: 输入: k = 3, n = 7 输出: [[1,2,4]]
示例 2: 输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]]

思路

这一道题的组合是由1-9的数组组成，所以可以看做是一个9层的树。然后求和等于目标数，且可数等于k的组合。找到就存起来。
首先定义path用来保存经过树的枝叶的路径值。当path的长度等于要求的k的时候，判断和是不是与目标的n一致。如果一致就找到了所需的值。
最后剪枝可以当path的和大于目标n的时候就不继续遍历。

代码

public class combinationSumClassIII {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracking(n, k, 0, 1);
        return result;
    }

    public void backtracking(int targetSum, int k, int sum, int StartIndex) {
        if (sum > targetSum) {
            return;
        }
        if (path.size() == k) {
            if (sum == targetSum) {
                result.add(new ArrayList<>(path));
            }
            return;
        }
        for (int i = StartIndex; i <= 9; i++) {
            sum += i;
            path.add(i);
            backtracking(targetSum, k, sum, i + 1);
            sum -= i;
            path.removeLast();
        }
    }
}

40题

这一题与39题有区别：

1. 本题的candidates中的数字在每个组合中只能使用一次。
2. 本题数组candidates中的元素是有重复的，且要求结果不能有重复
   因此本题要进行去重操作。
   因此我们定义一个Boolean型的数组uesd，该数组会将用过的位置置为true，来表示没有个元素是否使用过。如果当candidates的i值和i-1值相等时，used[i-1] == false,说明前一个i-1的相同值没有取，也就是在同一层，所以该项就应该不取。

List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    int Sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        boolean[] used = new boolean[candidates.length];
        backtracking(candidates, target, 0, used); //从0开始
        return result;
    }

    public void backtracking(int[] candidates, int target, int index, boolean[] used) {
        if (Sum == target) {
            result.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] && !used[i - 1]) {
                continue;
            }
            used[i] = true;
            Sum += candidates[i];
            path.add(candidates[i]);
            backtracking(candidates, target, i + 1, used);//每个节点只能选择一次，因此i+1
            path.removeLast();
            Sum -= candidates[i];
            used[i] = false;
        }
    }