回溯算法的套路/BFS/DFS

回溯算法框架

result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return

    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

全排列问题

返回一个数组元素的全排列
力扣：46. 全排列

List<List<Integer>> res = new LinkedList<>();

/* 主函数，输入一组不重复的数字，返回它们的全排列 */
List<List<Integer>> permute(int[] nums) {
    // 记录「路径」
    LinkedList<Integer> track = new LinkedList<>();
    backtrack(nums, track);
    return res;
}

// 路径：记录在 track 中
// 选择列表：nums 中不存在于 track 的那些元素
// 结束条件：nums 中的元素全都在 track 中出现
void backtrack(int[] nums, LinkedList<Integer> track) {
    // 触发结束条件
    if (track.size() == nums.length) {
        res.add(new LinkedList(track));
        return;
    }

    for (int i = 0; i < nums.length; i++) {
        // 排除不合法的选择
        if (track.contains(nums[i]))
            continue;
        // 做选择
        track.add(nums[i]);
        // 进入下一层决策树
        backtrack(nums, track);
        // 取消选择
        track.removeLast();
    }
}

二叉树的DFS

剑指 Offer 34. 二叉树中和为某一值的路径

这个题看起来不就是DFS嘛，而DFS既然是搜索问题，题目又是二叉树，那是不是就代表着我们又可以使用之前的二叉树遍历框架呢！

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    LinkedList<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> track = new LinkedList<>();
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        if(root==null) return res;
        backtrack(root,sum);
        return res;
    }
    public void backtrack(TreeNode root, int sum){
        if(root==null) return;
        //添加路径
        track.add(root.val);
        sum=sum-root.val;
        if(sum==0&&root.left==null&&root.right==null){
            res.add(new LinkedList(track));
        }
        backtrack(root.left,sum);
        backtrack(root.right,sum);
        //撤销路径
        track.removeLast();
    }
}

二叉树的BFS

BFS框架

// 计算从起点 start 到终点 target 的最近距离
int BFS(Node start, Node target) {
    Queue<Node> q; // 核心数据结构
    Set<Node> visited; // 避免走回头路

    q.offer(start); // 将起点加入队列
    visited.add(start);
    int step = 0; // 记录扩散的步数

    while (q not empty) {
        int sz = q.size();
        /* 将当前队列中的所有节点向四周扩散 */
        for (int i = 0; i < sz; i++) {
            Node cur = q.poll();
            /* 划重点：这里判断是否到达终点 */
            if (cur is target)
                return step;
            /* 将 cur 的相邻节点加入队列 */
            for (Node x : cur.adj())
                if (x not in visited) {
                    q.offer(x);
                    visited.add(x);
                }
        }
        /* 划重点：更新步数在这里 */
        step++;
    }
}

剑指 Offer 32 - II. 从上到下打印二叉树 II

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        //这个new的方式非常巧妙需要注意
        List<List<Integer>> res =new ArrayList<>();
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while(queue.peek()!=null){
            List<Integer> temp= new ArrayList<>();
            //这个就是保证了每次都是存一层
            int num=queue.size();
            for(int i=0;i<num;i++){
                TreeNode t=queue.poll();
                temp.add(t.val);
                if(t.left!=null) queue.offer(t.left);
                if(t.right!=null) queue.offer(t.right);
            }
            res.add(temp);
        }
        return res;
    }
}