Awesome算法解题框架——深度优先搜索（DFS）

Awesome算法解题框架系列：致力于探讨算法问题的框架思维，形成解题框架，用一个框架以点带面解决一类问题。问题千变万化，算法思维框架是不变的，以不变应万变。

DFS算法可以用于解决好几类题，是算法中的有力武器，其核心思想就是"一条道走到黑、不撞南墙不回头"，本文来探讨一下能够用DFS解决的3类题型，并总结出DFS通用的算法思想和解题模板。

3类题型

一维深搜："占坑"类问题

"全排列"问题是一种典型的一维深搜问题，其本质就是给你若干个"坑"，从左到右往里面填给定的数，看有多少种填法。如果把这些"坑"都"竖起来"，你会发现填坑的过程其实是一个决策树选择的过程，不同的坑填不同的值，就是选择了不同的决策树路径。

下面以leetcode-cn的第46题——"全排列"为例，看看一维深搜问题怎么解决。

• 题目：

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

• 解答：

class Solution {
    public List> permute(int[] nums) {
        // - 判空
        if (null == nums || nums.length == 0) {
            return new ArrayList<>();
        }

        // - DFS搜索
        List> res = new ArrayList<>();
        dfs(nums, new HashMap<>(), new ArrayList<>(), res);
        
        return res;
    }

    private void dfs(int[] p, Map pb, List chain, List> res) {
        // - 终止条件
        if (chain.size() == p.length) {
            // key-point: 这里一定要深拷贝chain
            res.add(new ArrayList<>(chain));
            return;
        }

        // - 候选
        for (int num: p) {
            if (!pb.getOrDefault(num, false)) {
                pb.put(num, true);
                chain.add(num);
                dfs(p, pb, chain, res);
                chain.remove(chain.size() - 1);
                pb.put(num, false);
            }
        }
    }
}

代码中dfs方法是一个无返回值的void方法，用chain列表存储每次搜索到的一个可行解，并加入到结果集res中，通过res对象隐式返回。

二维深搜：二维矩阵问题

二维矩阵中的深搜一般是寻找从起点到终点的最短路径，或遍历矩阵的某些区域。与广搜相比，深搜是沿着一条路径向纵深方向一路走到底，直到走不通，再后退一步，试另一个方向，并递归进行这个步骤，直到满足终止条件。

下面来做一下leetcode-cn的第1391题——"检查网格中是否存在有效路径"。

• 题目：

给你一个 m x n 的网格 grid。网格里的每个单元都代表一条街道。grid[i][j] 的街道可以是：

1 表示连接左单元格和右单元格的街道。
2 表示连接上单元格和下单元格的街道。
3 表示连接左单元格和下单元格的街道。
4 表示连接右单元格和下单元格的街道。
5 表示连接左单元格和上单元格的街道。
6 表示连接右单元格和上单元格的街道。

你最开始从左上角的单元格 (0,0) 开始出发，网格中的「有效路径」是指从左上方的单元格 (0,0) 开始、一直到右下方的 (m-1,n-1) 结束的路径。该路径必须只沿着街道走。

注意：你 不能 变更街道。

如果网格中存在有效的路径，则返回 true，否则返回 false 。

这是个路径存在性的问题，即只需判断"是否有路径"，而不用求出有哪些路径，这就更简单了，代码如下：

• 解答：

class Solution {
    // 每种街道上下左右可通的点的列表
    private static Map> accessUpMap = new HashMap<>();
    private static Map> accessDownMap = new HashMap<>();
    private static Map> accessLeftMap = new HashMap<>();
    private static Map> accessRightMap = new HashMap<>();
    static {
        List list = Arrays.stream(new int[]{2,3,4}).boxed().collect(Collectors.toList());
        accessUpMap.put(2, list);
        accessUpMap.put(5, list);
        accessUpMap.put(6, list);

        list = Arrays.stream(new int[]{2,5,6}).boxed().collect(Collectors.toList());
        accessDownMap.put(2, list);
        accessDownMap.put(3, list);
        accessDownMap.put(4, list);

        list = Arrays.stream(new int[]{1,4,6}).boxed().collect(Collectors.toList());
        accessLeftMap.put(1, list);
        accessLeftMap.put(3, list);
        accessLeftMap.put(5, list);

        list = Arrays.stream(new int[]{1,3,5}).boxed().collect(Collectors.toList());
        accessRightMap.put(1,list);
        accessRightMap.put(4,list);
        accessRightMap.put(6,list);
    }

    public boolean hasValidPath(int[][] grid) {
        // - 判空

        // - 起点和终点下标
        int[] start = new int[]{0,0};
        int[] end = new int[]{grid.length - 1, grid[0].length - 1};

        // - 深度搜索
        boolean[][] book = new boolean[grid.length][grid[0].length];


        return dfs(grid, start, end, book);
    }

    // DFS搜寻
    private static boolean dfs(int[][] grid, int[] cur, int[] end, boolean[][] book) {
        // 判断是否是终点
        if (cur[0] == end[0] && cur[1] == end[1]) {
            return true;
        }

        // 获取当前点可走的邻居节点列表
        boolean ret = false;
        List neighbors = getAccessNeighbors(grid, cur);
        if (neighbors.size() > 0) {
            for(int[] nei: neighbors) {
            if (!book[nei[0]][nei[1]]) {
                book[nei[0]][nei[1]] = true;
                ret = dfs(grid, nei, end, book);
                if (ret) {
                    return ret;
                }
                book[nei[0]][nei[1]] = false;
            }
            }
        }
        return ret;
    }

    // 获取一个点可走的邻居点列表的下标列表，这里的下标为：（行数，列数）， 行数和列数都从0开始
    private static List getAccessNeighbors(int[][] grid, int[] point) {
        List neighbors = new ArrayList<>();

        int row = point[0];
        int col = point[1];
        // 点的街道类型
        int type = grid[row][col];

        // 上邻居
        if (row > 0) {
            if (accessUpMap.getOrDefault(type, new ArrayList<>()).contains(grid[row-1][col])) {
                neighbors.add(new int[]{row-1,col});
            }
        }

        // 下邻居
        if (row < grid.length - 1) {
            if (accessDownMap.getOrDefault(type, new ArrayList<>()).contains(grid[row+1][col])) {
                neighbors.add(new int[]{row+1,col});
            }
        }

        // 左邻居
        if (col > 0) {
            if (accessLeftMap.getOrDefault(type, new ArrayList<>()).contains(grid[row][col-1])) {
                neighbors.add(new int[]{row,col-1});
            }
        }

        // 右邻居
        if (col < grid[0].length - 1) {
            if (accessRightMap.getOrDefault(type, new ArrayList<>()).contains(grid[row][col+1])) {
                neighbors.add(new int[]{row,col+1});
            }
        }

        return neighbors;
    }

}

这个题稍微复杂的地方在于如何获得一个点的可达的邻居节点列表。

树的深搜

树也是一种二维结构，但它又和二维矩阵很不同，树天然具有递归结构，用起来DFS更为方便。

下面以leetcode-cn的第113题——"路径总和 II"为例，来看一下树中DFS的实现方法：

• 题目：

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

说明: 叶子节点是指没有子节点的节点。

• 解答：

class Solution {
    public List> pathSum(TreeNode root, int sum) {
        // - 判空
        if (null == root) {
            return new ArrayList<>();
        }

        // - DFS
        List> res = new ArrayList<>();
        List chain = new ArrayList<>();
        chain.add(root.val);
        dfs(root, chain, sum, res);
        
        return res;
    }

    private void dfs(TreeNode cur, List chain, int targetSum, List> res) {
        // - 终止条件：叶子节点
        if (cur.left == null && cur.right == null) {
            // 判断chain的和是否为目标和
            if (chain.stream().mapToInt(x->x).sum() == targetSum) {
                // key-point: 深拷贝
                res.add(new ArrayList<>(chain));
                return;
            }
        }

        // - 候选：左、右子节点
        if (cur.left != null) {
            chain.add(cur.left.val);
            dfs(cur.left, chain, targetSum, res);
            chain.remove(chain.size() - 1);
        }
        if (cur.right != null) {
            chain.add(cur.right.val);
            dfs(cur.right, chain, targetSum, res);
            chain.remove(chain.size() - 1);
        }
    }

}

DFS算法抽象框架总结

数据对象5要素

从上面三种题型的DFS解法中，可以总结出来DFS算法的5种关键数据对象要素：

• p：原始数据集，一般为给定的一维数组、二维数组或树的根节点；必然需要。
• pb：标记器，一般为一维或二维的布尔数组、或布尔哈希表，用于标记数据集中哪些元素被访问或处理过，其值在每次递归都会发生变化；非必然需要。
• cur：当前元素，可为当前的层级、下标、当前节点或当前的位置坐标等，每次递归都会发生变化；非必然需要。
• chain：已访问路径列表，是一个列表，主要用于存储已访问过的路径上的元素列表，每次递归都会发生变化；非必然需要。
• res：结果对象，一般为数组/列表，用于存储DFS的搜索结果。如果结果是基本类型，res则需要封装一层只有1个元素的一维数组，以便能够正确返回结果；必然需要。

核心步骤5步曲

• 起始条件：4个数据对象（pb、cur、chain、res）的初始值要与递归的定义相匹配。
• 终止、剪枝条件：一般考虑当前下标/层级（cur）是否达到最大值，路径（chain）是否满足某个条件（比如路径和是否为某一个目标值），是否到达终点等。
• 候选：一般找数据集中未被pb标记的元素列表，树中当前节点的非空子节点，二维矩阵中的邻居节点等。
• 筛选：一般结合pb、根据下面几个条件进行判断筛选：是否被标记过、是否可达、是否为空。
• 递归状态设置与恢复：一般筛选之后，先修改pb、chain，用当前候选元素进行递归调用，最后恢复pb、chain为递归之前的状态。

DFS算法抽象框架模板

下面是DFS算法的伪代码抽象模板，解题时可以直接套用：

// 初始化pb、cur、chain、res，然后调用dfs
dfs(...)

// dfs定义，统一定义为void函数，返回值通过res对象返回
void dfs(p, pb, cur, chain, res):
    // 终止条件
    if (...):
        res = ...
        return
    
    // 候选
    for candidate in {可选集}:
        // 筛选
        if (candidate满足某些条件):
            // 递归调用
            pb[candidate] = true
            add candidate to chain
            dfs(p, pb, candidate, chain, res)
            remove candidate from chain
            pb[candidate] = false
    

Java实现时的几点注意事项

• 如果res是基本数据类型，则需要在外面封装一层数组，这样值才能传回去。
• 有时候需要把当前路径chain添加到返回对象res中，这个时候需要深拷贝chain再存入res，否则后面的chain值会覆盖前面的值。

总结

DFS采用了递归的思维，把边界条件、递归路径想清楚，再套用上述模板，就可以快速解决类似问题。