2023-04-19 算法面试中常见的递归和回溯问题

递归和回溯

0 递归与回溯的异同

参考文章

• 递归与回溯
• 递归与回溯的理解
• 回溯和递归区别

比较

	递归	回溯
定义	为了描述问题的某一状态，必须用到该状态的上一状态，而描述上一状态，又必须用到上一状态的上一状态……这种用自已来定义自己的方法，称为递归定义。形式如 f(n) = n*f(n-1), if n=0,f(n)=1.	从问题的某一种可能出发, 搜索从这种情况出发所能达到的所有可能, 当这一条路走到” 尽头 “的时候, 再倒回出发点, 从另一个可能出发, 继续搜索. 这种不断” 回溯 “寻找解的方法, 称作” 回溯法 “。
不同	递归是一种算法结构，递归会出现在子程序中自己调用自己或间接地自己调用自己。最直接的递归应用就是计算连续数的阶乘，计算规律：n!=(n-1)!*n。	回溯是一种算法思想，可以用递归实现。通俗点讲回溯就是一种试探，类似于穷举，但回溯有“剪枝”功能，比如求和问题。给定7个数字，1 2 3 4 5 6 7，求和等于7的组合，从小到大搜索，选择1+2+3+4 =10>7，已经超过了7，之后的5 6 7就没必要在继续了，这就是一种搜索过程的优化。如果还有不清楚的可以看一下8皇后问题。
问题举例	玩转算法面试第7章_二叉树与递归	玩转算法面试第8章_递归与回溯

举例

用一个比较通俗的说法来解释递归和回溯：
我们在路上走着，前面是一个多岔路口，因为我们并不知道应该走哪条路，所以我们需要尝试。尝试的过程就是一个函数。

• 我们选择了一个方向，后来发现又有一个多岔路口，这时候又需要进行一次选择。所以我们需要在上一次尝试结果的基础上，再做一次尝试，即在函数内部再调用一次函数，这就是递归的过程。
• 这样重复了若干次之后，发现这次选择的这条路走不通，这时候我们知道我们上一个路口选错了，所以我们要回到上一个路口重新选择其他路，这就是回溯的思想。

1~2 树形问题与回溯

17.电话号码的字母组合

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

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

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

class Solution {
    // 每个按键(数组的下标)对应的可能的字符串，0和1不对应任何字符，所以这里为空
    String[] letterMap = {
            "", // 0
            "", // 1
            "abc", // 2
            "def", // 3
            "ghi", // 4
            "jkl", // 5
            "mno", // 6
            "pqrs", // 7
            "tuv",  // 8
            "wxyz"  // 9
    };

    public List<String> letterCombinations(String digits) {
        // 存储最终结果的列表
        List<String> result = new ArrayList<>();
        if ("".equals(digits)){
            return result;
        }
        findCombinations(digits, 0, "", result);
        return result;
    }

    /**
     * 寻找digits[index]匹配的字母，获得digits[0...index]对应的解
     *
     * @param digits 原始数字字符串
     * @param index 要看digits的哪一个数字
     * @param s      s保存了此时从digits[0...index-1]翻译得到的一个字母字符串
     * @param result 保存最终可能的字符串
     */
    private void findCombinations(String digits, int index, String s, List<String> result) {
        // 所有数字都遍历完了，递归退出
        if (index == digits.length()) {
            result.add(s);
            return;
        }
        // 拿到index对应的数字字符
        char c = digits.charAt(index);
        // 获取当前数字字符可能对应的键盘上的字符串
        String lettersStr = letterMap[c - '0'];
        // 第当前数字对应的字符串进行遍历拼接
        for (int i = 0; i < lettersStr.length(); i++) {
            findCombinations(digits, index + 1, s + lettersStr.charAt(i), result);
        }
    }
}

93.复原IP地址

class Solution {
    private boolean validId(String ip) {
        if (ip.length() > 1 && ip.charAt(0) == '0') {
            return false;
        }
        if (ip.length() > 3 || Integer.parseInt(ip) > 255) {
            return false;
        }
        return true;
    }

    private String concatList(List<String> numList) {
        StringBuilder sb = new StringBuilder();
        for (String numStr : numList) {
            sb.append(numStr).append(".");
        }
        // 最后的一个.要去掉
        return sb.substring(0, sb.length() - 1);
    }

    // 把s分成四分，判断这四份组成的ip的合理性
    // 递归过程：不断取字符串的前几个字符，每出现一个合法的字符串就接着往下取
    private void findIp(String s, List<String> numList, List<String> result) {
        if (numList.size() == 4) {
            result.add(concatList(numList));
            // 当s字符串已经被分割成空时，分割完毕，退出本层递归即可
            return;
        }
        for (int i = 1; i <= s.length(); i++) {
            if (numList.size() == 3) {
                // 前面已经分成3份了，这里直接把剩下的作为IP即可
                i = s.length();
            }
            String tmp = s.substring(0, i);
            if (!validId(tmp)) {
                continue;
            }
            numList.add(tmp);
            // i往后的字符串
            findIp(s.substring(i), numList, result);
            // 退出上一层递归，就要从numList中删除最后一个num
            numList.remove(numList.size() - 1);
        }
    }

    public List<String> restoreIpAddresses(String s) {
        List<String> result = new ArrayList<>();
        if ("".equals(s) || s.length() < 4 || s.length() > 12) {
            return result;
        }
        List<String> numList = new ArrayList<>();
        findIp(s, numList, result);
        return result;
    }
}

131.分割回文串

验证字符串是否用125.验证回文串的代码

class Solution {
    /**
     * 参考LeetCode125.验证回文串
     */
    public boolean isPalindrome(String s) {
        s = s.toLowerCase();
        int l = 0;
        int r = s.length() - 1;
        while (l < r) {
            // 只要还没相遇就接着往下走
            if (!Character.isLetterOrDigit(s.charAt(l))) {
                // 左边的字符不是字母或数字
                l++;
                continue;
            }
            if (!Character.isLetterOrDigit(s.charAt(r))) {
                // 右边的字符不是字母或数字
                r--;
                continue;
            }
            // 左右两边都是字母或数字，只要不相等就说明不是回文
            if (s.charAt(l) != s.charAt(r)) {
                return false;
            }
            // 相等地话，继续向中间靠拢
            l++;
            r--;
        }
        return true;
    }

    /**
     * 获取本次循环中的回文串
     *
     * @param s           原始字符串
     * @param palindromes 本次循环中的回文串
     * @param result      存储所有回文串列表的列表
     */
    void getAllPalindromes(String s, List<String> palindromes, List<List<String>> result) {
        if ("".equals(s)) {
            // 当到头时，把回文串列表加入到result中并返回，列表是引用传值，所以必须new一个list
            result.add(new ArrayList<>(palindromes));
            return;
        }
        for (int i = 1; i <= s.length(); i++) {
            String tmp = s.substring(0, i);
            if (!isPalindrome(tmp)) {
                // 不是回文串就直接退出本层递归
                continue;
            }
            palindromes.add(tmp);
            getAllPalindromes(s.substring(i), palindromes, result);
            // 退出本层递归，需要移除一个回文串
            palindromes.remove(palindromes.size() - 1);
        }
    }

    public List<List<String>> partition(String s) {
        List<List<String>> result = new ArrayList<>();
        List<String> palindromes = new ArrayList<>();
        getAllPalindromes(s, palindromes, result);
        return result;
    }
}

3 组合

用基于递归的回溯法解决组合问题

46.全排列

class Solution {
    private void calPermutations(List<Integer> numList, List<Integer> curList, List<List<Integer>> result) {
        if (numList.size() == 0) {
            result.add(new ArrayList<>(curList));
            return;
        }
        for (int i = 0; i < numList.size(); i++) {
            curList.add(numList.get(i));
            List<Integer> numListNext = new ArrayList<>(numList);
            numListNext.remove(i);
            calPermutations(numListNext, curList, result);
            // 递归退出就删除一个元素
            curList.remove(curList.size() - 1);
        }
    }

    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> curList = new ArrayList<>();
        List<Integer> numList = new ArrayList<>();
        for (int num : nums) {
            numList.add(num);
        }
        calPermutations(numList, curList, result);
        return result;
    }
}

47.全排列II

只需要在上面46题的递归退出逻辑上加一句!result.contains(curList)即可

class Solution {
    private void calPermutations(List<Integer> numList, List<Integer> curList, List<List<Integer>> result) {
        if (numList.size() == 0 && !result.contains(curList)) {
            result.add(new ArrayList<>(curList));
            return;
        }
        for (int i = 0; i < numList.size(); i++) {
            curList.add(numList.get(i));
            List<Integer> numListNext = new ArrayList<>(numList);
            numListNext.remove(i);
            calPermutations(numListNext, curList, result);
            // 递归退出就删除一个元素
            curList.remove(curList.size() - 1);
        }
    }

    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> curList = new ArrayList<>();
        List<Integer> numList = new ArrayList<>();
        for (int num : nums) {
            numList.add(num);
        }
        calPermutations(numList, curList, result);
        return result;
    }
}

4~5 组合问题

利用递归回溯法解决组合问题.

77.组合

和46、47差不多，简单适配下即可,通过变化索引的方式去遍历子数组要比新建一个子数组效率高很多

class Solution {
    private void calCombinations(int[] nums, int start, List<Integer> curList, List<List<Integer>> result, int k) {
        if (curList.size() == k) {
            result.add(new ArrayList<>(curList));
            return;
        }
        for (int i = start; i < nums.length; i++) {
            curList.add(nums[i]);
            calCombinations(nums,i+1, curList, result, k);
            // 递归退出就删除一个元素
            curList.remove(curList.size() - 1);
        }
    }

    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> curList = new ArrayList<>();
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = i+1;
        }
        calCombinations(nums, 0, curList, result, k);
        return result;
    }
}

39.组合总和

class Solution {
    private void calCombinations(int[] nums, List<Integer> curList, int start, int target, List<List<Integer>> result) {
        if (target < 0) {
            return;
        }
        if (target == 0) {
            result.add(new ArrayList<>(curList));
            return;
        }
        // 从start开始是为了能重复使用start位置的元素
        for (int i = start; i < nums.length; i++) {
            curList.add(nums[i]);
            // 下一层递归还是用这些元素，通过索引来遍历子数组而不要额外建立空间
            calCombinations(nums, curList, i, target - nums[i], result);
            // 递归退出就删除一个元素
            curList.remove(curList.size() - 1);
        }
    }

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        // 排序后输出结果比较统一
        Arrays.sort(candidates);
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> curList = new ArrayList<>();
        calCombinations(candidates, curList, 0, target, result);
        return result;
    }
}

40.组合总和 II

和39类似，就是把i换成i+1，然后再添加到result前判重一下即可

class Solution {
    private void calCombinations(int[] nums, List<Integer> curList, int start, int target, List<List<Integer>> result) {
        if (target < 0) {
            return;
        }
        if (target == 0) {
            if(!result.contains(curList)){
                result.add(new ArrayList<>(curList));
            }
            return;
        }
        // 从start开始是为了能重复使用start位置的元素
        for (int i = start; i < nums.length; i++) {
            curList.add(nums[i]);
            // 下一层递归还是用这些元素，通过索引来遍历子数组而不要额外建立空间
            calCombinations(nums, curList, i + 1, target - nums[i], result);
            // 递归退出就删除一个元素
            curList.remove(curList.size() - 1);
        }
    }

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        // 排序后输出结果比较统一
        Arrays.sort(candidates);
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> curList = new ArrayList<>();
        calCombinations(candidates, curList, 0, target, result);
        return result;
    }
}

216.组合总和 III

和40题类似。执行用时 : 1 ms , 在所有 Java 提交中击败了 99.29% 的用户

class Solution {
    private void calCombinations(int[] nums, List<Integer> curList, int start, int target, List<List<Integer>> result, int k) {
        if (target < 0) {
            return;
        }
        if (target == 0) {
            if(curList.size() == k){
                result.add(new ArrayList<>(curList));
            }
            return;
        }
        // 从start开始是为了能重复使用start位置的元素
        for (int i = start; i < nums.length; i++) {
            curList.add(nums[i]);
            // 下一层递归还是用这些元素，通过索引来遍历子数组而不要额外建立空间
            calCombinations(nums, curList, i + 1, target - nums[i], result, k);
            // 递归退出就删除一个元素
            curList.remove(curList.size() - 1);
        }
    }

    public List<List<Integer>> combinationSum3(int k, int n) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> curList = new ArrayList<>();
        int[] nums = {1,2,3,4,5,6,7,8,9};
        calCombinations(nums, curList, 0, n, result, k);
        return result;
    }
}

78.子集

class Solution {
    private void calSubsets(int[] nums, int start, List<Integer> curList, List<List<Integer>> result){
        if(start == nums.length){
            return;
        }
        for(int i = start; i < nums.length; i++){
            curList.add(nums[i]);
            if(!result.contains(curList)){
                result.add(new ArrayList<>(curList));
            }
            calSubsets(nums, i + 1, curList, result);
            curList.remove(curList.size() - 1);
        }
    }
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> curList = new ArrayList<>();
        result.add(new ArrayList<>());
        calSubsets(nums, 0, curList, result);
        return result;
    }
}

90.子集II

和上一个题相比就加了个Arrays.sort(nums);

class Solution {
    private void calSubsets(int[] nums, int start, List<Integer> curList, List<List<Integer>> result){
        if(start == nums.length){
            return;
        }
        for(int i = start; i < nums.length; i++){
            curList.add(nums[i]);
            if(!result.contains(curList)){
                result.add(new ArrayList<>(curList));
            }
            calSubsets(nums, i + 1, curList, result);
            curList.remove(curList.size() - 1);
        }
    }
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> curList = new ArrayList<>();
        result.add(new ArrayList<>());
        calSubsets(nums, 0, curList, result);
        return result;
    }
}

401.二进制手表

class Solution {
    private void getResult(int[] nums, int start, int k, List<Integer> curList, List<List<Integer>> result){
        if(curList.size() == k){
            result.add(new ArrayList(curList));
            return;
        }
        for(int i = start; i < nums.length; i++){
            curList.add(nums[i]);
            getResult(nums, i + 1, k, curList, result);
            curList.remove(curList.size() - 1);
        }
    }
    private List<String> trans(List<List<Integer>> result){
        List<String> list = new ArrayList<>();
        for(List<Integer> lightList : result){
            int[] flags = new int[10];
            for(int i = 0; i < 10; i++){
                if(lightList.contains(i)){
                    flags[i] = 1;
                }else {
                    flags[i] = 0;
                }
            }
            int hour = 8 * flags[0] + 4 * flags[1] + 2 * flags[2] + flags[3];
            int minute = 32 * flags[4] + 16 * flags[5] + 8 * flags[6] + 4 * flags[7] + 2 * flags[8] + flags[9];
            if(hour > 11 || minute > 59){
                continue;
            }
            if(minute < 10){
                list.add(hour + ":0" + minute);
            }else{
                list.add(hour + ":" + minute);
            } 
        }
        Collections.sort(list);
        return list;
    }
    // 组合问题
    public List<String> readBinaryWatch(int num) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> curList = new ArrayList<>();
        // 下标0~3的元素表示上面四个灯，下标4~9的元素表示下面6个灯
        int[] nums = {0,1,2,3,4,5,6,7,8,9};
        getResult(nums, 0, num, curList, result);
        return trans(result);
    }
}

6 二维平面的搜索

参考Part2BasicGraph/第06章_图论问题建模和floodfill,这里是floodfill的四连通分量问题，可以用DFS解决，在递归回退时记得要把相关状态重置下

79.单词搜索

class Solution {
    /**
     * 当前点求上右下左四个点时用到的矢量差,dirs 是directions的意思
     */
    private int[][] dirs = {
            {-1, 0},
            {0, 1},
            {1, 0},
            {0, -1}
    };

    /**
     * 传进来的grid有多少行(Row)多少列(Col)
     */
    private int R, C;

    /**
     * 岛屿网格的情况
     */
    private char[][] grid;
    private boolean[][] visited;

    /**
     * 判断第x行第y列的点(x, y)是否在grid所在的范围内
     */
    private boolean inArea(int x, int y) {
        return x >= 0 && x < R && y >= 0 && y < C;
    }

    /**
     * 图的初始化
     *
     * @param board 二维的图
     * @param word  要找的单词
     * @return
     */
    public boolean exist(char[][] board, String word) {
        this.grid = board;
        if (grid == null) {
            return false;
        }
        R = grid.length;
        if (R == 0) {
            // 如果行数为0说明图为空，直接返回
            return false;
        }
        C = grid[0].length;
        if (C == 0) {
            // 如果列数为0说明图为空，直接返回
            return false;
        }
        visited = new boolean[R][C];
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                // 点没有被访问而且字符等于word的第一个字符，才以这个点作为起点进行DFS遍历
                if (grid[i][j] == word.charAt(0)) {
                    // 以(i,j)作为起点进行DFS，看看遍历结果能否组成提供的单词
                    List<Character> cList = new ArrayList<>();
                    cList.add(word.charAt(0));
                    dfs(i, j, 1, word, cList);
                    if (cList.size() == word.length()) {
                        return true;
                    }
                    // 每次递归DFS遍历完，数组要重新初始化
                    visited = new boolean[R][C];
                }
            }
        }
        return false;
    }

    private void dfs(int x, int y, int start, String word, List<Character> cList) {
        if (cList.size() == word.length()) {
            return;
        }
        visited[x][y] = true;
        // 遍历节点(x, y)所有的邻接点,判断是陆地的
        for (int d = 0; d < dirs.length; d++) {
            int nextX = x + dirs[d][0];
            int nextY = y + dirs[d][1];
            // 点(next_x, next_y)必须在grid区域内 + 没被访问过 + 是陆地(点(x, y)是陆地)
            if (inArea(nextX, nextY) && !visited[nextX][nextY] && grid[nextX][nextY] == word.charAt(start)) {
                cList.add(grid[nextX][nextY]);
                dfs(nextX, nextY, start + 1, word, cList);
                if (cList.size() == word.length()) {
                    break;
                }
                // 状态重置：列表和访问数组
                cList.remove(cList.size() - 1);
                visited[nextX][nextY] = false;
            }
        }
    }

    /**
     * char[][] board = {{'A', 'B', 'C', 'E'}, {'S', 'F', 'C', 'S'}, {'A', 'D', 'E', 'E'}};
     * String word = "ABCCED";
     * 

     * char[][] board = {{'C', 'A', 'A'}, {'A', 'A', 'A'}, {'B', 'C', 'D'}};
     * String word = "AAB";
     * 

     * char[][] board = {{'A','B','C','E'},{'S','F','E','S'},{'A','D','E','E'}};
     * String word  = "ABCEFSADEESE";
     */
    public static void main(String[] args) {
        char[][] board = {{'C', 'A', 'A'}, {'A', 'A', 'A'}, {'B', 'C', 'D'}};
        String word = "AAB";
        System.out.println(new Solution().exist(board, word));
    }
}

7 floodfill(实际就是DFS)

二维图的搜索实际就是DFS

200.岛屿数量

实际就是DFS求连通分量的个数

public class Solution {
    /**
     * 当前点求上右下左四个点时用到的矢量差,dirs 是directions的意思
     */
    private int[][] dirs = {
            {-1, 0},
            {0, 1},
            {1, 0},
            {0, -1}
    };

    /**
     * 传进来的grid有多少行(Row)多少列(Col)
     */
    private int R, C;

    /**
     * 岛屿网格的情况
     */
    private char[][] grid;
    private boolean[][] visited;
    /**
     * 连通分量的个数
     */
    private int cCount = 0;

    /**
     * 判断第x行第y列的点(x, y)是否在grid所在的范围内
     */
    private boolean inArea(int x, int y) {
        return x >= 0 && x < R && y >= 0 && y < C;
    }

    public int numIslands(char[][] grid) {
        this.grid = grid;
        if (grid == null) {
            return 0;
        }
        R = grid.length;
        if (R == 0) {
            // 如果行数为0说明图为空，直接返回
            return 0;
        }
        C = grid[0].length;
        if (C == 0) {
            // 如果列数为0说明图为空，直接返回
            return 0;
        }
        visited = new boolean[R][C];
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                // 点没有被访问而且字符等于word的第一个字符，才以这个点作为起点进行DFS遍历
                if (grid[i][j] == '1' && !visited[i][j]) {
                    dfs(i, j);
                    cCount++;
                }
            }
        }
        return cCount;
    }

    private void dfs(int x, int y) {
        visited[x][y] = true;
        // 遍历节点(x, y)所有的邻接点,判断是陆地的
        for (int d = 0; d < dirs.length; d++) {
            int nextX = x + dirs[d][0];
            int nextY = y + dirs[d][1];
            // 点(next_x, next_y)必须在grid区域内 + 没被访问过 + 是陆地(点(x, y)是陆地)
            if (inArea(nextX, nextY) && !visited[nextX][nextY] && grid[nextX][nextY] == '1') {
                dfs(nextX, nextY);
            }
        }
    }
}

139.被围绕的区域

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        boolean[] visited = new boolean[s.length() + 1];
        return dfs(s, 0, wordDict, visited);
    }

    private boolean dfs(String s, int start, List<String> wordDict, boolean[] visited) {
        visited[start] = true;
        for (int i = start; i < s.length(); i++) {
            // 防止递归回退的时候再次经过这个字符
            if (visited[i + 1]) {
                continue;
            }
            String substr = s.substring(start, i + 1);
            if (wordDict.contains(substr)) {
                if (i + 1 == s.length() || dfs(s, i + 1, wordDict, visited)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 输入: s = "leetcode", wordDict = ["leet", "code"]  输出: true
     * 

     * 输入："aaaaaaa"  输出：["aaaa","aaa"]
     */
    public static void main(String[] args) {
        String s = "aaaaaaa";
        String[] words = {"aaaa", "aaa"};
        List<String> wordDict = new ArrayList<>(Arrays.asList(words));
        System.out.println(new Solution().wordBreak(s, wordDict));
    }
}

417.太平洋大西洋水流问题

遍历每个点，DFS找到既能到达太平洋又能到达大西洋的点加入到结果中即可

class Solution {
    /**
     * 当前点求上右下左四个点时用到的矢量差,dirs 是directions的意思
     */
    private int[][] dirs = {
            {-1, 0},
            {0, 1},
            {1, 0},
            {0, -1}
    };

    /**
     * 传进来的grid有多少行(Row)多少列(Col)
     */
    private int R, C;

    /**
     * 岛屿网格的情况
     */
    private int[][] grid;
    private boolean[][] visited;

    /**
     * 判断第x行第y列的点(x, y)是否在grid所在的范围内
     */
    private boolean inArea(int x, int y) {
        return x >= 0 && x < R && y >= 0 && y < C;
    }

    public List<List<Integer>> pacificAtlantic(int[][] matrix) {
        List<List<Integer>> result = new ArrayList<>();
        this.grid = matrix;
        if (grid == null) {
            return result;
        }
        R = grid.length;
        if (R == 0) {
            // 如果行数为0说明图为空，直接返回
            return result;
        }
        C = grid[0].length;
        if (C == 0) {
            // 如果列数为0说明图为空，直接返回
            return result;
        }
        visited = new boolean[R][C];
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                // 点没有被访问而且字符等于word的第一个字符，才以这个点作为起点进行DFS遍历
                boolean pacific = dfs(i, j, true);
                visited = new boolean[R][C];
                boolean atlantic = dfs(i, j, false);
                visited = new boolean[R][C];
                if (pacific && atlantic) {
                    List<Integer> list = new ArrayList<>();
                    list.add(i);
                    list.add(j);
                    result.add(list);
                }
            }
        }
        return result;
    }

    /**
     * dfs遍历看起点是否能到到
     *
     * @param x       行
     * @param y       列
     * @param pacific true代表检查能否到达太平洋()，false代表检查能否到到大西洋
     * @return 是否能到达太平洋或大西洋
     */
    private boolean dfs(int x, int y, boolean pacific) {
        if (pacific) {
            // 检查能否到达太平洋
            if (x == 0 || y == 0) {
                return true;
            }
        } else {
            // 检查大西洋
            if (x == R - 1 || y == C - 1) {
                return true;
            }
        }
        visited[x][y] = true;
        for (int d = 0; d < dirs.length; d++) {
            int nextX = x + dirs[d][0];
            int nextY = y + dirs[d][1];
            // 点(next_x, next_y)必须在grid区域内 + 没被访问过 + 往地处流 + 能到达边界
            if (inArea(nextX, nextY) && !visited[nextX][nextY] && grid[nextX][nextY] <= grid[x][y] && dfs(nextX, nextY, pacific)) {
                return true;
            }
        }
        // 到最后都没能到达边界，则说明无法到到，退出即可
        return false;
    }

    public static void main(String[] args) {
        int[][] matrix = {
                {1, 2, 2, 3, 5},
                {3, 2, 3, 4, 4},
                {2, 4, 5, 3, 1},
                {6, 7, 1, 4, 5},
                {5, 1, 1, 2, 4}
        };
        System.out.println(new Solution().pacificAtlantic(matrix)); 
    }
}

8 递归回溯法是人工智能的基础

51.N皇后问题

图中的i是下面的r，

• 
• 
• 

class Solution {
    boolean[] col = null;
    boolean[] left = null;
    boolean[] right = null;
    List<List<String>> ret = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        // col[i]表示第i列被占用
        col = new boolean[n];
        // 左倾对角线
        left = new boolean[2 * n - 1];
        // 右倾对角线
        right = new boolean[2 * n - 1];
        // 二维平面
        char[][] board = new char[n][n];
        // 回溯法求解问题
        backTrack(board, 0, n);
        return ret;
    }
    // i代表行，j代表列
    void backTrack(char[][] board, int i, int n) {
        if (i >= n) {
            // 找到能一个能摆放皇后的位置，加入到结果列表中
            List<String> list = new ArrayList<>();
            for (int j = 0; j < n; j++) {
                list.add(new String(board[j]));
            }
            ret.add(list);
            return;
        }
        // 初始化棋盘啥都不放
        Arrays.fill(board[i], '.');
        for (int j = 0; j < n; j++) {
            if (!col[j] && !left[i + j] && !right[i - j + n - 1]) {
                // 一、尝试在当前位置摆放皇后
                // 摆放皇后
                board[i][j] = 'Q';
                // 列占用
                col[j] = true;
                // 左倾对角线的规律
                left[i + j] = true;
                // 右倾对角线的规律
                right[i - j + n - 1] = true;
                // 二、递归求解其合法性
                backTrack(board, i + 1, n);
                // 三、递归回退过程中需要恢复初始的状态
                // 拿走皇后
                board[i][j] = '.';
                // 列占用解除
                col[j] = false;
                // 左对角线占用解除
                left[i + j] = false;
                // 右对角线占用解除
                right[i - j + n - 1] = false;
            }
        }
    }
}

类似问题还有52和37

52.N皇后II

把51返回的ret改成ret.size()即可

class Solution {
    boolean[] col = null;
    boolean[] left = null;
    boolean[] right = null;
    List<List<String>> ret = new ArrayList<>();

    public int totalNQueens(int n) {
        // col[i]表示第i列被占用
        col = new boolean[n];
        // 左倾对角线
        left = new boolean[2 * n - 1];
        // 右倾对角线
        right = new boolean[2 * n - 1];
        // 二维平面
        char[][] board = new char[n][n];
        // 回溯法求解问题
        backTrack(board, 0, n);
        // 和51题唯一不同的地方
        return ret.size();
    }
    // i代表行，j代表列
    void backTrack(char[][] board, int i, int n) {
        if (i >= n) {
            // 找到能一个能摆放皇后的位置，加入到结果列表中
            List<String> list = new ArrayList<>();
            for (int j = 0; j < n; j++) {
                list.add(new String(board[j]));
            }
            ret.add(list);
            return;
        }
        // 初始化棋盘啥都不放
        Arrays.fill(board[i], '.');
        for (int j = 0; j < n; j++) {
            if (!col[j] && !left[i + j] && !right[i - j + n - 1]) {
                // 一、尝试在当前位置摆放皇后
                // 摆放皇后
                board[i][j] = 'Q';
                // 列占用
                col[j] = true;
                // 左倾对角线的规律
                left[i + j] = true;
                // 右倾对角线的规律
                right[i - j + n - 1] = true;
                // 二、递归求解其合法性
                backTrack(board, i + 1, n);
                // 三、递归回退过程中需要恢复初始的状态
                // 拿走皇后
                board[i][j] = '.';
                // 列占用解除
                col[j] = false;
                // 左对角线占用解除
                left[i + j] = false;
                // 右对角线占用解除
                right[i - j + n - 1] = false;
            }
        }
    }
}

37.解数独

class Solution {
    final int N = 9;
    int[] row = new int [N], col = new int [N];
    //ones数组表示0~2^9 - 1的整数中二进制表示中1的个数:如ones[7] = 3 ones[8] = 1
    //map数组表示2的整数次幂中二进制1所在位置（从0开始） 如 map[1] = 0,map[2] = 1, map[4] = 2
    int[] ones = new int[1 << N], map = new int[1 << N];
    int[][] cell = new int[3][3]; 
    public void solveSudoku(char[][] board) {
        init();
        int cnt = fill_state(board);
        dfs(cnt, board);
    }
    void init(){
        for(int i = 0; i < N; i++) row[i] = col[i] = (1 << N) - 1; 
        for(int i = 0; i < 3; i++)
            for(int j = 0; j < 3; j++)
                cell[i][j] = (1 << N) - 1;
        //以上2个循环把数组的数初始化为二进制表示9个1，即一开始所以格子都可填
        for(int i = 0; i < N; i++) map[1 << i] = i;
        //统计0~2^9 - 1的整数中二进制表示中1的个数
        for(int i = 0; i < 1 << N; i++){
            int n = 0;
            for(int j = i; j != 0; j ^= lowBit(j)) n++;
            ones[i] = n;
        }
    }
    int fill_state(char[][] board){
        int cnt = 0;    //统计board数组空格('.')的个数
        for(int i = 0; i < N; i++){
            for(int j = 0; j < N; j++){
                if(board[i][j] != '.'){
                    int t = board[i][j] - '1';
                    //数独中 i,j位置为数组下标，修改row col cell数组中状态
                    change_state(i, j, t);  
                }else cnt++;
            }
        }
        return cnt;
    }
    boolean dfs(int cnt, char[][] board){
        if(cnt == 0) return true;
        int min = 10, x = 0, y = 0;
        //剪枝，即找出当前所以空格可填数字个数最少的位置 记为x y
        for(int i = 0; i < N; i++){
            for(int j = 0; j < N; j++){
                if(board[i][j] == '.'){
                    int k = ones[get(i, j)];
                    if(k < min){
                        min = k;
                        x = i;
                        y = j;
                    }
                }
            }
        }
        //遍历当前 x y所有可选数字
        for(int i = get(x, y); i != 0; i ^= lowBit(i)){
            int t = map[lowBit(i)];
            
            change_state(x, y, t);
            board[x][y] = (char)('1' + t);
            
            if(dfs(cnt - 1, board)) return true;
            
            //恢复现场
            change_state(x, y, t);
            board[x][y] = '.';
        }
        return false;
    }
    void change_state(int x, int y, int t){
        row[x] ^= 1 << t;
        col[y] ^= 1 << t;
        cell[x / 3][y / 3] ^= 1 << t;
    }
    //对维护数组x行,y列的3个集合(行、列、九宫格)进行&运算
    //就可以获得可选数字的集合(因为我们用1标识可填数字)
    int get(int x, int y){
        return row[x] & col[y] & cell[x / 3][y / 3];
    }
    int lowBit(int x){
        return -x & x;
    }
}