第二十二天|回溯算法| 理论基础，77. 组合（剪枝），216. 组合总和III，17. 电话号码的字母组合

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

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

回溯三部曲：

回溯函数模板返回值以及参数

回溯算法中函数返回值一般为void。先写逻辑，然后需要什么参数，就填什么参数。

回溯函数终止条件

一般来说搜到叶子节点了，也就找到了满足条件的一条答案，把这个答案存放起来，并结束本层递归。

回溯搜索的遍历过程

for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。

补充一个JAVA基础知识

什么时候用ArrayList什么时候用LinkedList

存储结构与基本概念：

ArrayList:
- 底层是基于数组的数据结构。
- 元素是连续存储的，这意味着可以通过索引快速访问元素。
- 如果数组容量不足时，ArrayList会创建一个更大的数组并将原数组的元素复制到新数组中。
LinkedList:
- 底层是基于双向链表的数据结构。
- 每个节点存储元素值及前一个和后一个节点的引用。
- 元素在内存中不必是连续的 ，增删节点时不需要像ArrayList那样复制数组。

选择依据：

使用ArrayList的场景：
- 需要频繁访问元素 ：由于ArrayList基于数组结构，可以通过索引在O(1)时间内访问任意元素，因此如果你的主要操作是访问而不是插入和删除，ArrayList会更适合。
- 元素数量较多，但插入和删除操作较少 ：ArrayList在添加元素时，只要不超出容量，添加时间是O(1)，但当数组需要扩容时，时间复杂度会变为O(n)。
- 遍历操作较多 ：ArrayList因为底层是连续内存存储，遍历时缓存命中率较高，因此在遍历时性能会比LinkedList好。
使用LinkedList的场景：
- 需要频繁的插入和删除操作 ：LinkedList在头部或中间插入/删除元素时，不需要移动其他元素，只需要调整指针即可，效率更高。如果你的操作集中在头部或尾部，LinkedList会表现更好。
- 需要在列表的任意位置频繁插入/删除 ：在这种情况下，LinkedList可以通过调整节点的指向来高效完成操作，而ArrayList则需要移动元素来维护数组的连续性。
- 存储的元素数量不大且不需要频繁访问 ：LinkedList的随机访问时间是O(n)，因此如果需要频繁通过索引访问元素，LinkedList性能较差。

总结选择：

如果主要是读操作（访问元素） ：选择ArrayList。
如果主要是写操作（插入、删除） ，并且特别是在头部或中间：选择LinkedList。
如果数据规模大，并且需要高效的遍历：ArrayList更好。
如果数据规模小，并且操作模式比较多变：LinkedList的灵活性更好。

示例应用场景：

使用ArrayList:

java 复制代码

List<String> arrayList = new ArrayList<>();
arrayList.add("a");  // O(1) - 添加元素
arrayList.get(0);    // O(1) - 通过索引访问

使用LinkedList:

java 复制代码

LinkedList<String> linkedList = new LinkedList<>();
linkedList.addFirst("a");  // O(1) - 在头部插入
linkedList.removeFirst();  // O(1) - 从头部删除

77. 组合

本题是回溯法的经典题目。

把组合问题抽象为如下树形结构：

图中每次搜索到了叶子节点，我们就找到了一个结果。

相当于只需要把达到叶子节点的结果收集起来，就可以求得 n个数中k个数的组合集合。

未剪枝优化

回溯法三部曲

递归函数的返回值以及参数

cpp 复制代码

vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件单一结果
void backtracking(int n, int k, int startIndex)

函数里一定有两个参数，既然是集合n里面取k个数，那么n和k是两个int型的参数。

然后还需要一个参数，为int型变量startIndex，这个参数用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。startIndex 就是防止出现重复的组合。需要startIndex来记录下一层递归，搜索的起始位置。

回溯函数终止条件

path这个数组的大小如果达到k，说明我们找到了一个子集大小为k的组合了，在图中path存的就是根节点到叶子节点的路径。

此时用result二维数组，把path保存起来，并终止本层递归。

cpp 复制代码

if (path.size() == k) {
    result.push_back(path);
    return;
}

单层搜索的过程

回溯法的搜索过程就是一个树型结构的遍历过程，在如下图中，可以看出for循环用来横向遍历，递归的过程是纵向遍历。

for循环每次从startIndex开始遍历，然后用path保存取到的节点i。

可以看出backtracking（递归函数）通过不断调用自己一直往深处遍历，总会遇到叶子节点，遇到了叶子节点就要返回。

backtracking的下面部分就是回溯的操作了，撤销本次处理的结果。

时间复杂度: O(n * 2^n)
空间复杂度: O(n)

整体代码如下：

java 复制代码

    class Solution {
        List<List<Integer>> result = new ArrayList<>();
        LinkedList<Integer> path = new LinkedList<>();

        public List<List<Integer>> combine(int n, int k) {
            // 未剪枝优化
            backtracking(n, k, 1);
            return result;
        }

        // 递归的每一层在执行完所有可能的路径（所有从startIndex到n的i）之后，会自然退出当前循环，并结束当前的backtracking调用。
        public void backtracking(int n, int k, int startIndex) {
            if (path.size() == k) {
                result.add(new ArrayList<>(path));
                return;
            }
            for (int i = startIndex; i <= n; i++) {
                path.add(i);
                backtracking(n, k, i + 1);
                // 在递归调用返回之后，path.removeLast()会将最后添加的元素移除，以准备下一轮循环中添加不同的元素。
                path.removeLast();
            }
        }
    }

剪枝优化

剪枝的目标是减少不必要的递归调用，避免继续探索那些不可能满足条件的路径，从而提高效率。

来举一个例子，n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。在第二层for循环，从元素3开始的遍历都没有意义了。

这么说有点抽象，如图所示：

可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。

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

优化过程如下：

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

所以优化之后的for循环是：

cpp 复制代码

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

为什么是 n - (k - path.size()) + 1：（重点理解一下）

n - (k - path.size()) + 1的含义是：
- k - path.size()：当前还需要选择的元素数量。
- n - (k - path.size())：表示当前可选择元素的最大起始位置 ，即从这个位置开始，剩余的元素刚好足够填充到k个。
- +1是为了让i的范围包含这个起始位置。
例如，如果n = 5，k = 3，并且当前path.size() = 1，也就是已经选择了一个元素，还需要选择2个元素。
- 此时，k - path.size() = 3 - 1 = 2。
- n - (k - path.size()) = 5 - 2 = 3。
- 所以，i的最大值是3 + 1 = 4。
- 换句话说，从i = 4开始时，只有4和5两个元素可选，这正好可以凑齐3个元素的组合。

剪枝示例进一步理解：

假设n = 5，k = 3，我们在不同的递归层次下看i的取值范围：

当path.size() = 0（还没选任何元素）时：
- 需要选k = 3个元素。
- 可选择范围是：i <= 5 - (3 - 0) + 1 = 3，所以i可以从1到3。
- 选择1时，递归进入下一层。
当path.size() = 1（已选择1）时：
- 需要再选2个元素。
- 可选择范围是：i <= 5 - (3 - 1) + 1 = 4，所以i可以从2到4。
当path.size() = 2（已选择1, 2）时：
- 需要再选1个元素。
- 可选择范围是：i <= 5 - (3 - 2) + 1 = 5，所以i可以从3到5。
以此类推，当path.size() == k时，就停止递归，将结果存入result。

优化后整体代码如下：

java 复制代码

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> combine(int n, int k) {
        combineHelper(n, k, 1);
        return result;
    }

    /**
     * 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
     * @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
     */
    private void combineHelper(int n, int k, int startIndex){
        //终止条件
        if (path.size() == k){
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){
            path.add(i);
            combineHelper(n, k, i + 1);
            path.removeLast();
        }
    }
}

216. 组合总和III

本题就是在77基础上多了一个求和的限制罢了，简单。

注意：处理过程和回溯过程是一一对应的，处理有加，回溯就要有减

这里我自己写的时候漏了一个sum -= i的回溯

java 复制代码

    class Solution {
        List<List<Integer>> result = new ArrayList<>();
        LinkedList<Integer> path = new LinkedList<>();
        int sum = 0;

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

        private void backTrackingSum(int k, int n, int startIndex) {
            if (sum > n) return; // 剪枝
            if (path.size() == k) {
                if (sum == n) {
                    result.add(new ArrayList<>(path));
                }
                return;
            }
            // 剪枝 9 - (k - path.size()) + 1
            for (int i = startIndex; i <= 10 - (k - path.size()); i++) {
                path.add(i);
                sum += i;
                backTrackingSum(k, n, i + 1);
                sum -= i;  // 回溯
                path.removeLast(); //回溯
            }
        }
    }

复制代码

// 上面剪枝 i <= 9 - (k - path.size()) + 1; 如果还是不清楚
// 也可以改为 if (path.size() > k) return; 执行效率上是一样的

java 复制代码

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

    private void build(int k, int n, int startIndex, int sum) {

        if (sum > n) return;

        if (path.size() > k) return;

        if (sum == n && path.size() == k) {
            ans.add(new ArrayList<>(path));
            return;
        }

        for(int i = startIndex; i <= 9; i++) {
            path.add(i);
            sum += i;
            build(k, n, i + 1, sum);
            sum -= i;
            path.removeLast();
        }
    }
}

17. 电话号码的字母组合

本题需要多理解一下递归逻辑，看着代码

本题就是要解决如下三个问题：

数字和字母如何映射
两个字母就两个for循环，三个字符我就三个for循环，以此类推，然后发现代码根本写不出来
输入1 * #按键等等异常情况

数字和字母如何映射

可以使用map或者定义一个二维数组，例如：string letterMap[10]，来做映射。

回溯法来解决n个for循环的问题

回溯三部曲：

确定回溯函数参数

首先需要一个字符串s来收集叶子节点的结果，然后用一个字符串数组result保存起来。

参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index。

这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。

确定终止条件

终止条件就是如果index 等于输入的数字个数（digits.size）了，就收集结果，结束本层递归。

确定单层遍历逻辑

cpp 复制代码

int digit = digits[index] - '0';        // 将index指向的数字转为int
string letters = letterMap[digit];      // 取数字对应的字符集
for (int i = 0; i < letters.size(); i++) {
    s.push_back(letters[i]);            // 处理
    backtracking(digits, index + 1);    // 递归，注意index+1，一下层要处理下一个数字了
    s.pop_back();                       // 回溯
}

整体代码如下。需要多理解一下：

java 复制代码

    class Solution {
        //设置全局列表存储最后的结果
        List<String> list = new ArrayList<>();

        public List<String> letterCombinations(String digits) {
            if (digits == null || digits.length() == 0) {
                return list;
            }
            //初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串""
            String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
            //迭代处理
            backTraciking(digits, numString, 0);
            return list;
        }

        //每次迭代获取一个字符串，所以会涉及大量的字符串拼接，所以这里选择更为高效的 StringBuilder
        StringBuilder temp = new StringBuilder();

        //比如digits如果为"23",num 为0，则str表示2对应的 abc
        public void backTraciking(String digits, String[] numString, int num) {
            //遍历全部一次记录一次得到的字符串
            if (num == digits.length()) {
                list.add(temp.toString());
                return;
            }
            //str 表示当前num对应的字符串
            //获取当前数字对应的字母字符串：String str = numString[digits.charAt(num) - '0']，
            //digits.charAt(num) 获取当前 num 指向的数字字符，通过减去字符 '0' 转换为对应的数组索引，得到当前数字对应的字符串。
            String str = numString[digits.charAt(num) - '0'];
            for (int i = 0; i < str.length(); i++) {
                temp.append(str.charAt(i));
                //递归，处理下一层
                backTraciking(digits, numString, num + 1);
                //剔除末尾的继续尝试
                temp.deleteCharAt(temp.length() - 1);
            }
        }
    }

第二十二天的总算是结束了，直冲Day23！