回溯算法学习总结

回溯算法

本文学习笔记总结于，代码随想录，教学视频
https://www.bilibili.com/video/BV1cy4y167mM/?spm_id_from=pageDriver&vd_source=97c991340bba665b3dc08208fe547287

一、什么是 回溯算法

回溯法也可以叫做回溯搜索法，它是⼀种搜索的⽅式。
只要有递归就会有回溯，他们是相辅相成的。
回溯通常隐藏在递归函数的下面

二、回溯法的效率

回溯法的性能如何呢，这⾥要和⼤家说清楚了，虽然回溯法很难，很不好理解，但是回溯法
并不是什么⾼效的算法 。
因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法⾼效⼀
些，可以加⼀些剪枝的操作，但也改不了回溯法就是穷举的本质。
那么既然回溯法并不⾼效为什么还要⽤它呢？
因为没得选，⼀些问题能暴⼒搜出来就不错了，撑死了再剪枝⼀下，还没有更⾼效的解法。
此时⼤家应该好奇了，都什么问题，只能暴⼒搜索

三、回溯法解决的问题

组合问题：N个数⾥⾯按⼀定规则找出k个数的集合
切割问题：⼀个字符串按⼀定规则有⼏种切割⽅式
⼦集问题：⼀个N个数的集合⾥有多少符合条件的⼦集
排列问题：N个数按⼀定规则全排列，有⼏种排列⽅式
棋盘问题：N皇后，解数独等等

3.1 什么是组合，什么是排列

例如：{1, 2} 和 {2, 1} 在组合上，就是⼀个集合，因为不强调顺序，⽽要是排列的话，{1, 2}和 {2, 1} 就是两个集合了。
记住组合⽆序，排列有序，就可以了。

四、回溯法模板

五、组合问题

题目：

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

⽰例:
输⼊: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
思路：
直接的解法当然是使⽤for循环，例如⽰例中k为2，很容易想到 ⽤两个for循环，这样就可以输出 和⽰例中⼀样的结果。
代码如下：

public static void main(String[] args) {
        int n = 4;
        for (int i = 1; i <= n; i++) {
            for (int j = i + 1; j <= n; j++) {
                System.out.println(i + "" + j);
            }
        }
    }

输⼊：n = 100, k = 3
那么就三层for循环，代码如下：

public static void main(String[] args) {
        int n = 4;
        for (int i = 1; i <= n; i++) {
            for (int j = i + 1; j <= n; j++) {
                for (int u = j + 1; u <= n; u++) {
                    System.out.println(i + "" + j + u);
                }
            }
        }
    }

如果n为100，k为50呢，那就50层for循环，是不是开始窒息。
此时就会发现虽然想暴⼒搜索，但是⽤for循环嵌套连暴⼒都写不出来！

public class Solution {

    public static List<List<Integer>> res = new ArrayList<>();

    public static List<Integer> path = new ArrayList<>();

    public static void main(String[] args) {
        backtracking(4, 2, 1);
        res.forEach((e -> System.out.println(e.toString())));
    }

    public static void backtracking(int n, int k, int start) {
        //终止代码
        if (path.size() == k) {
            res.add(new ArrayList<Integer>(path));
            return;
        }
        //递归逻辑
        for (int i = start; i <= n - k + path.size() + 1; i++) {
            path.add(i);
            backtracking(n, k, start + 1);
            path.remove(path.size() - 1);
        }
    }
}

五、剪枝优化

如果for循环选择的起始位置之后的元素个数 已经不⾜ 我们需要的元素个数了，那么就没有必要搜索了。

接下来看⼀下优化过程如下：

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

为什么有个+1呢，因为包括起始位置，我们要是⼀个左闭的集合。
举个例⼦，n = 4，k = 3， ⽬前已经选取的元素为0（path.size为0），n - (k - 0) + 1 即 4 - (3 - 0) + 1 = 2。
从2开始搜索都是合理的，可以是组合[2, 3, 4]