蓝桥杯_穿越雷区 java

题目描述

X 星的坦克战车很奇怪，它必须交替地穿越正能量辐射区和负能量辐射区才能保持正常运转，否则将报废。

某坦克需要从 A 区到 B 区去（ A，B 区本身是安全区，没有正能量或负能量特征），怎样走才能路径最短？

已知的地图是一个方阵，上面用字母标出了 A，B 区，其它区都标了正号或负号分别表示正负能量辐射区。

例如：

A + - + -

- + - - +

- + + + -

+ - + - +

B + - + -

坦克车只能水平或垂直方向上移动到相邻的区。

输入描述

第一行是一个整数 n，表示方阵的大小， 4≤n<100。

接下来是 n 行，每行有 n 个数据，可能是 A，B，+，- 中的某一个，中间用空格分开。A，B 都只出现一次。

输出描述

输出一个整数，表示坦克从 A 区到 B 区的最少移动步数。

如果没有方案，则输出 -1。

输入输出样例

示例

输入

5
A + - + -
- + - - +
- + + + -
+ - + - +
B + - + -

输出

10

运行限制

• 最大运行时间：1s

• 最大运行内存: 512M

常规bfs题目

代码:

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

public class 穿越雷区 {

    static int n, startX, startY, step = 0;//方阵大小,开始位置,步数
    static char[][] map;//地图
    static boolean[][] vis;//记录访问数组
    static int[][] dir = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };//方向数组 上,右,下,左

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        map = new char[n][n];
        vis = new boolean[n][n];
        //初始化数组
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                map[i][j] = scanner.next().charAt(0);
                //记录开始位置
                if (map[i][j] == 'A') {
                    startX = i;
                    startY = j;
                }
            }
        }
        //调用bfs
        bfs();
    }

    private static void bfs() {
        //初始化队列
        Queue<Node> queue = new LinkedList<>();
        queue.offer(new Node(startX, startY));
        while (!queue.isEmpty()) {
            int len = queue.size();
            while (len-- > 0) {
                //取队首
                Node tNode = queue.poll();
                //出口
                if (map[tNode.x][tNode.y] == 'B') {
                    System.out.println(step);
                    return;
                }
                //向邻居四个方向遍历
                for (int i = 0; i < dir.length; i++) {
                    int tx = tNode.x + dir[i][0];
                    int ty = tNode.y + dir[i][1];
                    //防止越界
                    if (tx >= 0 && tx < n && ty >= 0 && ty < n && vis[tx][ty] == false) {
                        //不能与上一次走的一致
                        if (map[tx][ty] != map[tNode.x][tNode.y]) {
                            //标记为已访问
                            vis[tx][ty] = true;
                            //入队列
                            queue.offer(new Node(tx, ty));
                        }
                    }
                }
            }
            //向邻居遍历完步数就加1
            step++;
        }
        //当退出循环时(即队列为空时)还没有找到就输出-1
        System.out.println(-1);
    }
}

class Node {
    int x;
    int y;

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