数据结构与算法基础篇--迷宫问题处理

力扣：499， 505

能通过的为0，不能通过的为1，找最短路径长

直接上基本迷宫解法

package com.rojer;

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

public class Labyrinth {

    public static int labyrinth(int [][] arrayElement, int[] start, int[] end) {
        // 判断起点与终点是否一致
        if (start == end) {
            return 0;
        }
        int m = arrayElement.length; // 获取x长
        int n = arrayElement[0].length; // 获取y长

        // 创建遍历点Queue
        Queue<int[]> queue = new LinkedList<>();
        // 将起点加入队列
        queue.add(new int[]{start[0], start[1]});

        // 创建距离二维数组图
        int[][] dp = new int[m][n];
        // 将距离图赋予最大值
        for (int [] a : dp) {
            Arrays.fill(a, Integer.MAX_VALUE);
        }
        // 将起点置为0
        dp[start[0]][start[1]] = 0;

        // 创建方位二维图
        int [][] ac ={{0,1}, {0,-1}, {1,0}, {-1,0}};

        // 遍历所有节点
        while (!queue.isEmpty()) {
            int[] poll = queue.poll();
            // 初始方位
            int x = poll[0], y = poll[1];
            int distance = dp[x][y];
            for (int[] a : ac) {
                // 创建临时变量用于后续循环遍历
                int dx = x;
                int dy = y;
                // 满足条件时进入循环
                while (dx + a[0] < m && dx + a[0] >= 0 && dy + a[1] < n && dy + a[1] >= 0
                        && arrayElement[dx + a[0]][dy + a[1]] == 0) {
                    dx += a[0];
                    dy += a[1];

                    // 判断当条件等于时， 取最优步长可以不用这一步
                    if (dx == end[0] && dy == end[1]) {
                        // 计算路长
                        return distance + Math.abs(dx - x) + Math.abs(dy - y);
                    }
                    // 总是取最小值
                    if (dp[dx][dy] > distance + Math.abs(dx - x) + Math.abs(dy - y)) {
                        dp[dx][dy] = distance + Math.abs(dx - x) + Math.abs(dy - y);
                        // 增加下一个遍历起点
                        queue.add(new int[]{dx, dy});
                    }
                }
            }
        }
        return dp[end[0]][end[1]] == Integer.MAX_VALUE ? -1 : dp[end[0]][end[1]];
    }

    public static void main(String[] args) {
        int [][] arrayElement = {{0,0,1,0},{1,1,0,0},{0,0,0,1},{0,0,1,0},{0,0,0,1}};
        int[] start = {0,3};
        int[] end = {4,0};
        System.out.println(labyrinth(arrayElement, start, end)); // 应输出7
        int[] start1 = {0,3};
        int[] end1 = {1,2};
        System.out.println(labyrinth(arrayElement, start1, end1)); // 应输出2
        int[] start2 = {0,3};
        int[] end2 = {2,3};
        System.out.println(labyrinth(arrayElement, start2, end2)); // 应输出-1
    }
}