1、题目

image.png

2、分析

基本上直接套用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++;
    }
}

3、代码

class Solution {
    //某个轮盘加一
    public String up(String s, int i){
        char[] ch = s.toCharArray();
        if(ch[i] == '9'){
            ch[i] = '0';
        }
        else{
            ch[i] += 1;
        }
        return new String(ch);
    }
    //某个轮盘减一
    public String down(String s, int i){
        char[] ch = s.toCharArray();
        if(ch[i] == '0'){
            ch[i] = '9';
        }
        else{
            ch[i] -= 1;
        }
        return new String(ch);
    }

    public int openLock(String[] deadends, String target) {
        //队列
        Queue<String> queue = new LinkedList<>();
        //存储已经走过的节点，防止走回头路
        Set<String> visited = new HashSet<>();
        Set<String> deadSet = new HashSet<>();
        for(String s : deadends) deadSet.add(s);
        queue.offer("0000");
        visited.add("0000");
        int times = 0;
        while(!queue.isEmpty()){
            int size = queue.size();
            //遍历这一步所有的结果
            for(int i = 0; i < size; i++){
                String cur = queue.poll();
                //找到结果，或者包含在死锁中
                if(deadSet.contains(cur)) continue;
                if(cur.equals(target)) return times;
                //某一个结果，下一步有哪几种可能都列出来，加到队列中
                for(int j = 0; j < 4; j++){
                    String up = up(cur, j);
                    if(!visited.contains(up)){
                        queue.offer(up);
                        visited.add(up);
                    }
                    String down = down(cur, j);
                    if(!visited.contains(down)){
                        queue.offer(down);
                        visited.add(down);
                    }
                }
            }
            //步数加一
            times++;
        }
        return -1;
    }
}