Java题解-回溯算法（附力扣题目详解）

概述

1. 所谓回溯算法，又称为“试探法”。解决问题时，每进行一步，都是抱着试试看的态度，如果发现当前选择并不是最好的，或者这么走下去肯定达不到目标，立刻做回退操作重新选择。这种走不通就回退再走的方法就是回溯算法。
2. 以深度优先的方式系统地搜索问题的解的方法称为回溯法
3. 回溯算法是深度优先策略的典型应用，回溯算法就是沿着一条路向下走，如果此路不通了，则回溯到上一个分岔路，再选一条路走，一直这样递归下去，直到遍历完所有的路径。
4. 回溯算法的解空间结构可以组成成子集树（0-1背包问题、全排列）、排列树。会画出解决某个问题的解空间树，比如会画出描述3个物品的背包问题的解空间树等

回溯解题一般步骤

1. 确定方法返回值和参数
	回溯方法一般返回值都为空
	参数部分，可以先确定几个主要部分，在编写具体逻辑的过程中，可以在添加所需求的参数
2. 确定递归（回溯）结束的条件
	回溯通常在递归之后，而递归最重要的部分之一就是终止条件，所以，确定回溯的终止条件也是极其重要的
3. 确定单层遍历逻辑
	通常根据具体题意来进行编写，大家可以参考下午的力扣题解

回溯算法可以解决的题型

1. 组合问题
2. 组合总和
3. 分割字符串问题
4. 子集问题
5. 排列问题
6. N皇后
7. 解数独 等等

回溯力扣题解----JAVA版本

1. 力扣17题详解

1. 1 问题

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

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

示例:

输入："23"
输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

说明：尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。

1.2 思路

从示例上来说，输入"23"，最直接的想法就是两层for循环遍历了吧，正好把组合的情况都输出了。

如果输入"233"呢，那么就三层for循环，如果"2333"呢，就四层for循环…

大家应该感觉出和力扣77题.组合

(opens new window)遇到的一样的问题，就是这for循环的层数如何写出来，此时又是回溯法登场的时候了。

理解本题后，要解决如下三个问题：

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

1.3 树形图理解

1.4 回溯解题三步骤

• 确定回溯函数参数和方法返回值

 //设置全局列表存储最后的结果
  List<String> list = new ArrayList<>();
  public void backTracking(String digits, String[] numString, int num) {
  		。。。。。。
  }

• 确定终止条件

例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。

那么终止条件就是如果index 等于 输入的数字个数（digits.size）了（本来index就是用来遍历digits的）。

然后收集结果，结束本层递归。
  //遍历全部一次记录一次得到的字符串
   if (num == digits.length()) {
       list.add(temp.toString());
       return;
   }

• 确定单层遍历逻辑

首先要取index指向的数字，并找到对应的字符集（手机键盘的字符集）。

然后for循环来处理这个字符集，代码如下：
//str 表示当前num对应的字符串
 String str = numString[digits.charAt(num) - '0'];
 for (int i = 0; i < str.length(); i++) {
     temp.append(str.charAt(i));
     //c
     backTracking(digits, numString, num + 1);
     //剔除末尾的继续尝试
     temp.deleteCharAt(temp.length() - 1);
 }

1.5 完整代码

代码一：
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"};
        //迭代处理
        backTracking(digits, numString, 0);
        return list;

    }

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

    //比如digits如果为"23",num 为0，则str表示2对应的 abc
    public void backTracking(String digits, String[] numString, int num) {
        //遍历全部一次记录一次得到的字符串
        if (num == digits.length()) {
            list.add(temp.toString());
            return;
        }
        //str 表示当前num对应的字符串
        String str = numString[digits.charAt(num) - '0'];
        for (int i = 0; i < str.length(); i++) {
            temp.append(str.charAt(i));
            //c
            backTracking(digits, numString, num + 1);
            //剔除末尾的继续尝试
            temp.deleteCharAt(temp.length() - 1);
        }
    }
}
代码二：

class Solution {
    static HashMap<Character,String> map = new HashMap<>();

    static {
        map.put('2',"abc");
        map.put('3',"def");
        map.put('4',"ghi");
        map.put('5',"jkl");
        map.put('6',"mno");
        map.put('7',"pqrs");
        map.put('8',"tuv");
        map.put('9',"wxyz");
    }
    List<String> result = new ArrayList<>();

    public List<String> letterCombinations(String digits) {
        if (digits.length() == 0) {
            return result;
        }

        String s = "";
        backtracking(digits,0,s);
        return result;
    }
    private void backtracking(String digits , int index , String s ){
        if (index == digits.length()) {
            result.add(s);
            return ;
        }

        String letter = map.get(digits.charAt(index));
        for (int i = 0; i < letter.length(); i++) {
            backtracking(digits,index+1,s+Character.toString(letter.charAt(i)));
        }
    }

}

1.6 复杂度分析

复杂度分析

时间复杂度：O(3m×4n)O(3^m \times 4^n)O(3m×4n)，其中 mmm 是输入中对应 333 个字母的数字个数（包括数字 222、333、444、555、666、888），nnn 是输入中对应 444 个字母的数字个数（包括数字 777、999），m+nm+nm+n 是输入数字的总个数。当输入包含 mmm 个对应 333 个字母的数字和 nnn 个对应 444 个字母的数字时，不同的字母组合一共有 3m×4n3^m \times 4^n3m×4n 种，需要遍历每一种字母组合。

空间复杂度：O(m+n)O(m+n)O(m+n)，其中 mmm 是输入中对应 333 个字母的数字个数，nnn 是输入中对应 444 个字母的数字个数，m+nm+nm+n 是输入数字的总个数。除了返回值以外，空间复杂度主要取决于哈希表以及回溯过程中的递归调用层数，哈希表的大小与输入无关，可以看成常数，递归调用层数最大为 m+nm+nm+n。

1.7 总结

一般而言，回溯过程之后，都要进行剪枝操作，因为回溯本身就是暴力破解的方式。这里大家可能一听到暴力破解？那为什么还要学呀。其他有些题目，就比如上述题目，能用暴力求解出答案就很不错了。所以回溯的应用还是很重要的。好的算法都是改出来的。而回溯之后的剪纸，就是我们修改代码的过程。具体的剪纸，要根据题目而有所区别，但一般情况下都在确定单层遍历逻辑，也就是for循环的范围，那里，和递归结束条件进行剪纸，而具体的情况，要有题目具体分析。

因篇幅有限，后续会陆续更新自己学习过程中的一些心得。