图论搜索与人工智能BFS

最新推荐文章于 2024-09-22 18:17:21 发布

Fellow@

最新推荐文章于 2024-09-22 18:17:21 发布

阅读量680

点赞数 1

分类专栏：图论

本文链接：https://blog.csdn.net/qq_40512890/article/details/105753311

版权

笔试中的BFS问题-LeetCode1091

在一个 N × N 的方形网格中，每个单元格有两种状态：空（0）或者阻塞（1）。

一条从左上角到右下角、长度为 k 的畅通路径，由满足下述条件的单元格 C_1, C_2, ..., C_k 组成：

相邻单元格 C_i 和 C_{i+1} 在八个方向之一上连通（此时，C_i 和 C_{i+1} 不同且共享边或角）
C_1 位于 (0, 0)（即，值为 grid[0][0]）
C_k 位于 (N-1, N-1)（即，值为 grid[N-1][N-1]）
如果 C_i 位于 (r, c)，则 grid[r][c] 为空（即，grid[r][c] == 0）
返回这条从左上角到右下角的最短畅通路径的长度。如果不存在这样的路径，返回 -1 。

 

示例 1：

输入：[[0,1],[1,0]]

输出：2

示例 2：

输入：[[0,0,0],[1,1,0],[1,1,0]]

输出：4

 

提示：

1 <= grid.length == grid[0].length <= 100
grid[i][j] 为 0 或 1

这是一个8联通（米字形）问题。并且这是求解无权图的最短路径长度。同样，我们可以不单独建图，直接在二维矩阵中进行计算。

import java.util.LinkedList;
import java.util.Queue;

public class Solution {
   
    private int[][] grid;
    private int R, C;
    private boolean[][] visited;
    private int[][] dist;
    private int[][] dirs = {
   {
   -1, 0}, {
   -1, -1}, {
   0, -1}, {
   1, -1}, {
   1, 0}, {
   1, 1}, {
   0, 1}, {
   -1, 1}};

    public int shortestPathBinaryMatrix(int[][] grid) {
   
        if(grid.length==0 || grid[0][0] ==1)
            return -1;

        this.grid = grid;
        R = grid.length;
        C = grid[0].length;
        visited = new boolean[R][C];
        pre = new int[R][C];
        bfs(0, 0);
        if (!visited[R - 1][C - 1])
            return -1;
        else
            return pre[R - 1][C - 1];
    }
    // 从左上角进行一次广度优先遍历 入队，需要把二维坐标转换成1维坐标

    private void bfs(int x, int y) {
   
        visited[x][y] = true;
        dist[x][y] = 1;
        int start = x * C + y;// 初始起点 将二维转换成1维
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(start);
        while (!queue.isEmpty()) {
   
            int v = queue.poll();
            int vx = v / C;
            int vy = v % C;
            for (int d = 0; d < 8; d++) {
   
                int newx = vx + dirs[d][0];
                int newy = vy + dirs[d][1];
                // 需要满足3个条件 不越界 没访问 不阻塞  不越界需要首先判断
                if (inArea(newx, newy) && !visited[newx][newy] && grid[newx]																	[newy] == 0) {
   
                    queue.offer(newx * C + newy);
                    visited[newx]