BFS 寻找矩阵中两点之间的最短距离

找指定两坐标间的最短距离

这一类 找两点间最短距离的问题一般是使用BFS来解决。

题目描述

给定一个矩阵,x 为坐标起点,即可以用作出发的地方,T 为终点, 即要到达的地方,那么请给出 从 X 出发能到达 T 的最短的路径长度, 以及起点 X 的坐标。

输入:矩阵地图

5 6
X00100
00000X
01T000
0X1010
00000X

输出:一行是最短的路径距离,接着一行是起始点 X 的坐标。

4
0 0 1 5

思路

考虑 BFS

再说一次,广度优先搜索可回答两类问题。

 第一类问题:从节点A出发,有前往节点B的路径吗?(在你的人际关系网中,有芒果销

售商吗?)

 第二类问题:从节点A出发,前往节点B的哪条路径最短?(哪个芒果销售商与你的关系

最近?)

【算法图解】

代码

import java.util.*;

// 第二题
/*
5 6
X00100
00000X
01T000
0X1010
00000X

4
0 0 1 5
 */
public class FindShortestPath {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char[][] board;
        PddNo2 pdd = new PddNo2();
        while (sc.hasNext()){
            String[] nm = sc.nextLine().split(" ");
            int N = Integer.valueOf(nm[0]);
            int M = Integer.valueOf(nm[1]);
            board = new char[N][M];
            for (int i = 0; i < N; i++) {
                board[i] = sc.nextLine().toCharArray();
            }

            Map<Integer, List<Integer>> res = pdd.getRes(board);
            Set<Map.Entry<Integer, List<Integer>>> entries = res.entrySet();

            Iterator it = entries.iterator();
            //while (it.hasNext()){
                Map.Entry<Integer, List<Integer>> myres = (Map.Entry<Integer, List<Integer>>) it.next();
                System.out.println(myres.getKey());
                List<Integer> list = myres.getValue();
                for (int i = 0; i < list.size(); i++) {
                    System.out.print(list.get(i));
                    if(i!=list.size())
                        System.out.print(" ");
                }
                System.out.println();
//            }
        }
    }
}

class PddNo2 {
    public char[][] board;
    public int N, M;
    //    public boolean[][] marked;
    public Map<Integer, List<Integer>> res;
    public int[][] directions = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    public int count = 0;

    public Map<Integer, List<Integer>> getRes(char[][] board) {
        if (board == null || board.length == 0 || board[0].length == 0)
            return res;
        // 默认升序排序
        this.res = new TreeMap<>();
        this.board = board;
        this.N = board.length;
        this.M = board[0].length;

        List<Integer> list;
        Queue<int[]> queue = new LinkedList<>();
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (board[i][j] == 'X') {
//                    System.out.println("起点 "+" x -> "+i+" y -> "+j);
                    queue.clear();
                    queue.add(new int[]{i, j});
                    list = BFS(queue, i, j);
                    if (list != null && list.size() != 0) {
                        int key = list.get(0).intValue();

                        if (res.containsKey(key)) {
                            List temp = res.get(key);
                            temp.add(list.get(1));
                            temp.add(list.get(2));
                        } else {
                            List<Integer> temp = new ArrayList<>();
                            temp.add(list.get(1));
                            temp.add(list.get(2));
                            res.put(key, temp);
                        }
                    }
                }

            }
        }
        return res;
    }

    // list 存储 [length, newX, newY] 表示 (i,j) 到 (newX, newY)的路径长度 length
    public List<Integer> BFS(Queue<int[]> queue, int i, int j) {
        // 这里必须要 创建新的 visited 访问表 因为 每一个起始点开始, 都是全新的路程 这里不会和之前的结果产生联系
        boolean[][] visited = new boolean[N][M];
        // 这个路径表 是用来记录每一 从 (i,j) 为起点的到自己这里的路径长度
        // 使用一个新的路径长度表记录
        int[][] gridLen = new int[N][M];
        // 起始点到自己的 路径长度为 0
        gridLen[i][j] = 0; // 起点

        List<Integer> res = new ArrayList<>();
        while (!queue.isEmpty()) {
            // 移除队列头部的坐标
            int[] xy = queue.remove();
            // 作为起点
            int length = gridLen[xy[0]][xy[1]];
            visited[xy[0]][xy[1]] = true;
            for (int k = 0; k < 4; k++) {
                int newX = xy[0] + directions[k][0];
                int newY = xy[1] + directions[k][1];

                if (!inArea(newX, newY) || board[newX][newY] == '1' || visited[newX][newY])
                    continue;

                queue.add(new int[]{newX, newY});
                gridLen[newX][newY] = length + 1;

                if (board[newX][newY] == 'T') {
                    res.add(gridLen[newX][newY]);
                    res.add(i);
                    res.add(j);
                    return res;
                }
            }
        }
        return null;
    }

    public boolean inArea(int x, int y) {
        return x >= 0 && x < N && y >= 0 && y < M;
    }
}
  • 1
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,我会尝试回答你的问题。首先,我需要澄清一下,作为一个语言模型 AI,我并不是一个可以直接进行代码实现的工具。不过,我可以为你提供一些关于实现这些功能的思路和一些参考资料。 1. 邻接矩阵的有向图和无向图 邻接矩阵是一种表示图的常用方式,可以用二维数组来表示。对于有向图,邻接矩阵的元素 a[i][j] 表示从顶点 i 到顶点 j 是否有一条有向边;对于无向图,a[i][j] 表示顶点 i 和顶点 j 是否有一条无向边。 2. 无向网和有向网 在有向网和无向网,每条边都有一个权重或者距离,表示两个顶点之间的关系。有向网和无向网在表示方法上和有向图、无向图类似,只不过邻接矩阵的元素 a[i][j] 不再表示是否有边,而是表示顶点 i 到顶点 j 的边的权重或者距离。 3. 图的遍历及操作 图的遍历可以分为深度优先搜索(DFS)和广度优先搜索(BFS)两种方式。在DFS,我们从一个顶点开始,不断沿着一条路径前进,直到无法前进为止,然后回退到上一个顶点,继续寻找其他路径。在BFS,我们从一个顶点开始,先访问它的所有邻居,然后再访问邻居的邻居,直到遍历完整个图。除了遍历操作,图还可以进行其他一些操作,比如添加顶点、添加边、删除顶点、删除边等等。 4. 最小生成树 最小生成树是指一个连通无向图,所有边的权值和最小的生成树。常用的算法有Kruskal算法和Prim算法。Kruskal算法的基本思想是按边权值从小到大选择边加入生成树,直到生成树有 n-1 条边为止;Prim算法的基本思想是从一个顶点开始,不断选择与之相邻的权值最小的边,直到生成树有 n-1 条边为止。 5. 最短路径 最短路径是指在一个加权图,从一个顶点到另一个顶点的路径,边的权值之和最小的路径。常用的算法有 Dijkstra算法和Floyd算法。Dijkstra算法的基本思想是从起点开始,每次选择一个离起点最近的顶点,然后更新与它相邻的顶点的距离;Floyd算法的基本思想是利用动态规划的思想,依次计出从任意一个顶点到任意一个顶点的最短路径。 6. 每一对点之间最短路径 每一对点之间最短路径可以通过多次运用最短路径算法来实现。具体来说,如果要求顶点 i 到顶点 j 的最短路径,可以先用 Dijkstra 算法求出从顶点 i 到所有其他顶点的最短路径,然后再用从顶点 j 到所有其他顶点的最短路径,最后将两个最短路径加起来即可。 以上是我对你提出的问题的回答,希望对你有所帮助。如果你有更多的问题,可以继续问我。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值