回溯算法1：回溯理论、组合问题、组合优化、电话号码的字母组合

小小小码猿

已于 2023-07-28 21:16:07 修改

阅读量158

点赞数

分类专栏： #代码随想录学习打卡文章标签：算法 java 数据库

于 2023-07-19 19:34:52 首次发布

本文链接：https://blog.csdn.net/evildoerxmf/article/details/131770717

版权

#代码随想录学习打卡专栏收录该内容

38 篇文章 0 订阅

订阅专栏

1.回溯算法理论基础

回溯算法分类

什么是回溯法

回溯法也可以叫做回溯搜索法，它是一种搜索方式。回溯是递归的副产品，只要有递归就会有回溯。
所以，回溯函数也就是递归函数。

回溯法的效率

回溯并不是高效的算法，本质是穷举，穷举所有可能，选出我们想要的答案。如果想让回溯法效率更高，可以采用剪枝的操作，不过也改变不了它是穷举的本质。

回溯法解决的问题

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

组合是不强调顺序的，排列强调顺序
例如，{1,2}和{2,1}在组合中是一个集合，而在排列中则是两个不同的集合。

如何理解回溯法

回溯法解决的问题可以抽象为树形结构。因为回溯法解决的都是在集合中递归查找子集，集合的大小构成了树的宽度，递归的深度，都构成树的深度。
递归就要有终止条件，因此必然是一棵高度有限的树（N叉树）。

回溯法模板

回溯三部曲：

回溯函数模板返回值以及参数
回溯法的函数返回值一般为void。
因为回溯算法需要的参数不像二叉树递归的时候那么容易一次性确定下来，所以一般先写逻辑，然后需要什么参数就填什么参数。
void backtracking(参数)
回溯终止条件
树中搜索到叶子节点，就找到了满足条件的一条答案，把这个答案存放起来，并结束本层递归。

if(终止条件){
存放结果；
return;
}

回溯搜索的遍历过程
回溯法一般是在集合中递归搜索，集合的大小构成了树的宽度，递归的深度构成了树的深度。

注意：这里树中的孩子节点与集合大小是相等的。
回溯函数遍历代码如下：

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

for是遍历集合区间，一个节点有多少个孩子，for就执行多少次。
可以将for循环看做横向遍历，backtracking看做纵向遍历，这样就把一棵树遍历完了。
所以，回溯法的代码模板如下：

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

2.组合问题

例题77：给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按任何顺序返回答案。

回溯法思路：

暴力法k是多少，就有几层for循环，如果k过大，则无法解决。
因此，回溯法怎么暴力搜呢？回溯法就用递归来解决嵌套层数的问题。
递归来做for嵌套，每一次的递归中嵌套一个for循环，那么递归就可以用于解决多层嵌套循环的问题了。
把组合问题抽象为以下树形结构：
回溯遍历
一开始集合是{1,2，3,4}，从左向右取数，取过的数，不再重复取。
每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围。
图中可以发现n相当于树的宽度，k相当于树的深度。

那么如何在树上遍历，然后找到我们需要的结果？
如果找到叶子节点，就找到了一个结果。
相当于把达到叶子节点的结果收集起来，就可以求得N个数中K个数的组合集合。

77题解法：

递归的返回值和参数

List<List<Integer>> res=new List<List<>>;//存放所有结果
LinkedList<Integer> path=new LinkedList<>;//存放符合条件的结果

这里的全局变量也可以以参数的形式加入递归中，不过参数过多代码可解释性不强。
这里还要有一个参数，int startIndex即每次递归集合从哪里开始遍历。用来防止出现重复的组合。
在下图中，集合取了1之后，在下一层递归就从{2,3，4}中取数了，那么下一层递归如何知道从哪里开始取数，靠的就是startIndex。

所以整体代码为：

List<List<Integer>> res=new List<List<>>;//存放所有结果
LinkedList<Integer> path=new LinkedList<>;//存放符合条件的结果
void backtracking(int n,int k,int startIndex)

确定回溯终止条件
什么时候达到了所谓的叶子节点？

如果path的大小达到k，就说明找到了一个子集大小为k的组合了，在图中path存放的就是根节点到叶子节点的路径。如图红色部分：

此时，就用res将path存放起来：

if( path.size()==k){
res.add(path);
return;
}

单层搜索的过程
回溯法的搜索过程就是一个树形结构的遍历过程，如下图，用for循环来横向遍历，递归的过程是纵向遍历。

如此，遍历树时从startIndex开始for循环，用path保存遍历的节点值。
代码如下：

for(int i=startInex;i<=n;i++){
path,add(i);//处理节点
backtrackin(n,k,i+1);
path.remove();//回溯，撤销处理的节点
}

可以看出backtracking通过不断调用自己一直往深度遍历，总会遇到叶子节点，遇到叶子节点就要返回。
回溯法怎么优化剪枝呢？
例如，n=4,k=4的话，那么第一层for循环的时候，从元素2开始的遍历就没有意义了。第二层for循环时，从3开始的遍历就没有意义了。因为后面可遍历的元素数量已经小于k了。

而剪枝优化的地方就在于每一层for循环开始的起始位置。
如果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]。

这里大家想不懂的话，建议也举一个例子，就知道是不是要+1了。

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

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

所以，该题的完整代码为：

    public void backtracking(int n,int k,int startIndex){
        //终止
        if(path.size()==k){
             res.add(new ArrayList<>(path));
             // res.add(path);//得到的res为空，必要要新建一个集合存放path
            return;
        }
        for(int i=startIndex;i<=n-(k-path.size())+1;i++){
            path.add(i);
            backtracking(n,k,i+1);
            path.removeLast();//回溯
        }
    }
}

注意java中删除集合中最后一位元素的函数是removeLast()

3.组合（优化）

通过剪枝来优化回溯法，在例题77中，可以发现如果起始的元素到最后元素的数量小于需要的k值后，那么该元素及其后续元素遍历都没有意义，可以pass。
优化如果不画图的话不好理解，所以把整个回溯抽象为一棵树形结构，可以直观地看出剪枝剪的是哪里。

4.组合总和|||

例题216：找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

只使用数字1到9
每个数字最多使用一次
返回所有可能的有效组合的列表。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

public class combinationSum3 {
    static public void main(String[] args){

    }
}

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

    public List<List<Integer>> combinationSum3(int k, int n) {
        if(n<1 || n>60) return null;
        backtracking(k, n, 1,0);
        return res;
    }

    public void backtracking(int k, int n, int startIndex,int sum) {
        if(sum>n){//不能缺少，不然path会溢出
            return;
        }
        if (path.size()==k  && sum==n) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
            path.add(i);
            sum+=i;
            backtracking(k, n, i + 1,sum);
            path.removeLast();
            sum-=i;//处理与回溯是一一对应的，处理要加，回溯就要减
        }
    }
}

注意在回溯中，如果处理节点有什么操作，那么回溯时对应的要做相反的操作，是一一对应的。
java中输出提示用双引号“ ”，单引号是字符。

5.电话号码的字母组合

例题17：给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

1.要解决数字和字母的映射问题，题目没有直接给出；
2.例如digits=“23”。回溯流程如下：每次回溯取的是不同数字对应字符串的一个字符。

3.字符串为null与字符串长度为0是有区别的：

长度为0是要占内存空间的，如String s1=new String("");
为空时不占内存的，如String str;
4.java中找到字符串中的下标为index的字符用str.charAt(index)。
5.java中数组可以用[]取值，与集合用get()取值有所不同。
6.java中StringBuilder与String不同（string的值是不变的，每赋给string一个值就会产生一个新地址，而stringBuilder是在原地址上一直更改节省了大量空间），可以用append()添加元素，也可以用deletecharAt()删除元素。
回溯最重要的是搞清楚每个for循环从哪里取以及取的什么.

class Solution {
    //数字与字母的映射关系
    String[] dig = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    List<String> res = new ArrayList<>();
    StringBuilder path = new StringBuilder();

    public List<String> letterCombinations(String digits) {
        if(digits==null || digits.length()==0) return res;
        //if(digits==null) return res;这样写""会出错，输出的是[""]而不是[]
        backtracking(digits, 0);
        return res;
    }

    public void backtracking(String digits, int startIndex) {
        if (startIndex > digits.length() - 1) {
            res.add(new String(path));
            return;
        }
        int index = digits.charAt(startIndex) - '0';//将字符串中的字符转换为整型数字
        String letters = dig[index];//字符数组可以用[]取值
        for (int i = 0; i < letters.length(); i++) {
            path.append(letters.charAt(i));
            backtracking(digits, startIndex + 1);
            path.deleteCharAt(path.length() - 1);
        }
    }
}

6.回溯法周末总结

1.什么是回溯法？
回溯法是递归的副产品，只要有递归就会有回溯。
回溯其实就是暴力解，列出所以的答案，选择满足需要的，最多剪枝优化。
回溯可以解决的问题：

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

2.回溯法求组合问题（求同个集合间的组合）
用递归控制for循环嵌套的数量。for循环横向遍历得到树的宽度，纵向递归遍历得到树的深度。回溯不断调整结果集。
3.回溯求解组合问题的优化：剪枝。在for循环中的i上做操作。
4.回溯求组合总和（求同个集合间的组合）。有两个剪枝：3提到的i的范围大于需要的数量；如果元素总和已经大于需要的n了，后续遍历可以剪枝。
5.回溯法求字母组合（求不同集合间的组合）：与前面的组合问题（在一个集合中取值）不同，这是在不同的集合中取值。因此，需要搞明白for循环没次处理的什么节点？是每个不同集合中取一个字符，然后递归下一个集合。还需要注意数字与字符串的对应关系。
for循环横向遍历，递归中心遍历，回溯不断调整结果集。

小小小码猿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
回溯算法1：回溯理论、组合问题、组合优化、电话号码的字母组合

1.什么是回溯法？回溯法是递归的副产品，只要有递归就会有回溯。回溯其实就是暴力解，列出所以的答案，选择满足需要的，最多剪枝优化。组合问题：从N个数中按照一定规则选择K个数的集合。排列问题：N个数按照一定规则全排列，有几种排列方式。切割问题：一个字符串按一定的规则有几种切割方式。子集问题：一个N个数的集合里有多少符合条件的子集。棋盘问题：N皇后，解数独等。2.回溯法求组合问题（求同个集合间的组合）用递归控制for循环嵌套的数量。
复制链接

扫一扫