【蓝桥杯】 穿越雷区

题目介绍

此题为第六届蓝桥杯大赛个人决赛赛(软件类)Java语言B组真题.

标题：穿越雷区

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

资源约定：
峰值内存消耗（含虚拟机） < 512M
CPU消耗 < 2000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

题解

一看到这种找路径问题,最先想到的是递归求解,然后看到要找到最短路径,那必须得遍历完所有的路径才可以,自然想到暴力破解法,同时不断求解的过程符合回溯法的基本特征.

实现方式:

• 通过一个boolean数组(book)记录走过的路径
• 依次计算下一步该走的路径(上下左右)
• 递归寻找最优路径

基本算法如下:

import java.util.Scanner;

public class Main {
    public static void main(String[] q) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int len = (int) Math.sqrt(n); //每一个子数组的长度,为根号n
        String[][] arr = new String[len][len];
        boolean[][] book = new boolean[len][len];
        int a = 0, b = 0, x = 0, y = 0;

        for (int i = 0; i < len; i++) {
            for (int j = 0; j < len; j++) {
                arr[i][j] = sc.next();
                if (arr[i][j].equals("A")) {
                    a = i;
                    b = j;
                } else if (arr[i][j].equals("B")) {
                    x = i;
                    y = j;
                }
            }
        }
        System.out.println(new Main().getShortestPath(arr, book, a, b, x, y, a, b, len));
    }

    private int temp_min = 0;
    private int min = Integer.MAX_VALUE;

    /**
     * @param a   A横坐标
     * @param b   A纵坐标
     * @param x   B横坐标
     * @param y   B纵坐标
     * @param c   下一点横坐标
     * @param d   下一点纵坐标
     * @param len 子数组的长度
     */
    private int getShortestPath(String[][] arr, boolean[][] book, int a, int b, int x, int y, int c, int d, int len) {
        book[a][b] = true;
        backtrace(arr, book, a, b, x, y, c, d, len);
        return min == Integer.MAX_VALUE ? -1 : min;
    }

    private void backtrace(String[][] arr, boolean[][] book, int a, int b, int x, int y, int c, int d, int len) {
        if (arr[c][d].equals(arr[x][y])) {//退出
            if (min > temp_min) {
                min = temp_min;
            }
            return;
        }
        int s = c - 1;
        int t = d;
        //上
        if (s >= 0 && !arr[c][d].equals(arr[s][t]) && !book[s][t]) {
            book[s][t] = true;
            temp_min++;
            backtrace(arr, book, a, b, x, y, s, t, len);
            temp_min--;
            book[s][t] = false;
        }
        s = c + 1;
        t = d;
        //下
        if (s < len && !arr[c][d].equals(arr[s][t]) && !book[s][t]) {
            book[s][t] = true;
            temp_min++;
            backtrace(arr, book, a, b, x, y, s, t, len);
            temp_min--;
            book[s][t] = false;
        }
        //左
        s = c;
        t = d - 1;
        if (t >= 0 && !arr[c][d].equals(arr[s][t]) && !book[s][t]) {
            book[s][t] = true;
            temp_min++;
            backtrace(arr, book, a, b, x, y, s, t, len);
            temp_min--;
            book[s][t] = false;
        }
        //右
        s = c;
        t = d + 1;
        if (t < len && !arr[c][d].equals(arr[s][t]) && !book[s][t]) {
            book[s][t] = true;
            temp_min++;
            backtrace(arr, book, a, b, x, y, s, t, len);
            temp_min--;
            book[s][t] = false;
        }
    }
}

测试用例

25
A + - + -
- + - - +
- + + + -
+ - + - +
B + - + -

运行结果 : 10

25
- + - B -
- + - - +
- + - - -
+ - + - -
A + - - -

运行结果 : -1

25
- + - B A
- + - - +
- + - - -
+ - + - -
- + - - -

运行结果 : 1