算法打卡之BFS

例题1：走迷宫

给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。

最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。

请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。

数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。

输入格式

第一行包含两个整数 n 和 m。

接下来 n 行，每行包含 m 个整数（0 或 1），表示完整的二维数组迷宫。

输出格式

输出一个整数，表示从左上角移动至右下角的最少移动次数。

数据范围

1≤n,m≤100

输入样例：

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出样例：

8

答案：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;

public class Main {

    static int m, n;
    static int[][] a;
    static int[][] step;

    public static int bfs() {
        int[][] t = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        Queue<Edge> queue = new LinkedList<>();
        queue.add(new Edge(0, 0));
        step[0][0] = 0;
        while (!queue.isEmpty()) {
            Edge edge = queue.poll();
            if (edge.x == n - 1 && edge.y == m - 1)
                break;
            for (int i = 0; i < 4; i++) {
                int x = edge.x + t[i][0];
                int y = edge.y + t[i][1];
                if (x >= 0 && x < n && y >= 0 && y < m) {
                    if (a[x][y] == 0 && step[x][y] == -1) {
                        queue.add(new Edge(x, y));
                        step[x][y] = step[edge.x][edge.y] + 1;
                    }
                }
            }
        }
        return step[n - 1][m - 1];
    }

    public static void main(String[] args) throws Exception {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String[] str = bufferedReader.readLine().split(" ");
        n = Integer.parseInt(str[0]);
        m = Integer.parseInt(str[1]);
        a = new int[n][m];
        step = new int[n][m];
        for (int i = 0; i < n; i++) {
            str = bufferedReader.readLine().split(" ");
            for (int j = 0; j < m; j++) {
                a[i][j] = Integer.parseInt(str[j]);
                step[i][j] = -1;
            }
        }
        System.out.println(bfs());
    }
}

class Edge {
    int x, y;

    public Edge(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

例题2： 单词接龙

字典 wordList 中从单词 beginWord 和 endWord 的 转换序列 是一个按下述规格形成的序列：

序列中第一个单词是 beginWord 。
序列中最后一个单词是 endWord 。
每次转换只能改变一个字母。

转换过程中的中间单词必须是字典 wordList 中的单词。
给你两个单词 beginWord 和 endWord 和一个字典 wordList ，找到从 beginWord 到 endWord 的 最短转换序列 中的 单词数目 。如果不存在这样的转换序列，返回 0。

示例 1：

输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]
输出：5
解释：一个最短转换序列是 “hit” -> “hot” -> “dot” -> “dog” -> “cog”, 返回它的长度 5。

示例 2：

输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”]
输出：0
解释：endWord “cog” 不在字典中，所以无法进行转换。

提示：

1 <= beginWord.length <= 10
endWord.length == beginWord.length
1 <= wordList.length <= 5000
wordList[i].length == beginWord.length
beginWord、endWord 和 wordList[i] 由小写英文字母组成
beginWord != endWord
wordList 中的所有字符串 互不相同

答案

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if(!wordList.contains(endWord))
            return 0;
        Map<String, Integer> map = new HashMap<>();
        map.put(beginWord,1);
        Queue<String> ue = new LinkedList<>();//
        ue.add(beginWord);//
        int n = wordList.size();
        boolean[] flag = new boolean[n];
        while (!ue.isEmpty()){//
            String s = ue.poll();
            int v = 0;
            if(s.length()==endWord.length()){
                for (int j=0;j<s.length();j++)
                    if(s.charAt(j)!=endWord.charAt(j))
                        v++;
                if(v==1){
                    endWord = s;
                    map.put(s,map.get(s)+1);
                    break;
                }
            }
            for (int j=0;j<n;j++){
                String t = wordList.get(j);
                if(!flag[j]&&s.length()==t.length()){
                    v = 0;
                    for (int x=0;x<t.length();x++)
                        if(s.charAt(x)!=t.charAt(x))
                            v++;
                    if(v==1){
                        map.put(t,map.get(s)+1);
                        ue.add(t);
                        flag[j] = true;
                    }
                }
            }
        }
        if(map.containsKey(endWord))
        return map.get(endWord);
        return 0;
    }
}