第七届蓝桥杯决赛真题：路径之谜

题目描述：

小明冒充X星球的骑士，进入了一个奇怪的城堡。
城堡里边什么都没有，只有方形石头铺成的地面。

假设城堡地面是 n x n 个方格。【如图1.png】所示。

按习俗，骑士要从西北角走到东南角。
可以横向或纵向移动，但不能斜着走，也不能跳跃。
每走到一个新方格，就要向正北方和正西方各射一箭。
（城堡的西墙和北墙内各有 n 个靶子）

同一个方格只允许经过一次。但不必做完所有的方格。

如果只给出靶子上箭的数目，你能推断出骑士的行走路线吗？

有时是可以的，比如图1.png中的例子。

本题的要求就是已知箭靶数字，求骑士的行走路径（测试数据保证路径唯一）

输入：
第一行一个整数N(0<N<20)，表示地面有 N x N 个方格
第二行N个整数，空格分开，表示北边的箭靶上的数字（自西向东）
第三行N个整数，空格分开，表示西边的箭靶上的数字（自北向南）

输出：
一行若干个整数，表示骑士路径。

为了方便表示，我们约定每个小格子用一个数字代表，从西北角开始编号: 0,1,2,3…
比如，图1.png中的方块编号为：

0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15

示例：
用户输入：
4
2 4 3 4
4 3 3 3

程序应该输出：
0 4 5 1 2 3 7 11 10 9 13 14 15

解题思路：

深搜回溯，找到每一条出路后，就判断箭的个数是不是符合题目要求。

参考代码：

 static List<Integer> list = new ArrayList<>();

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr1 = new int[n];
        int[] arr2 = new int[n];
        int[] a1 = new int[n];
        int[] a2 = new int[n];
        for (int i = 0; i < n; i++) {
            arr1[i] = sc.nextInt();
        }
        for (int i = 0; i < n; i++) {
            arr2[i] = sc.nextInt();
        }
        int[][] map = new int[n][n];
        int temp = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                map[i][j] = temp++;
            }
        }

        dfs(map, 0, 0, arr1, arr2, a1, a2);

    }

    private static void dfs(int[][] map, int i, int j, int[] arr1, int[] arr2, int[] a1, int[] a2) {
        if (i < 0 && j < 0 && i >= map.length && j >= map[0].length) {
            return;
        }
        if (a1[i] > arr2[i])
            return;
        if (a2[j] > arr1[j])
            return;
        if (map[i][j] == map.length * map.length - 1) {
            if (check(a1, arr2) && check(a2, arr1)) {
                list.add(map[i][j]);
                for (int k = 0; k < list.size(); k++) {
                    System.out.print(list.get(k) + " ");
                }
                System.out.println();
            } else {
                return;
            }
        }
        int temp = map[i][j];
        list.add(map[i][j]);//结果添加到list中
        a1[i]++;//分别表示xy方向的箭
        a2[j]++;

        map[i][j] = -1;//标记走过的路径，防止死循环
        if (i + 1 < map.length && map[i + 1][j] != -1)
            dfs(map, i + 1, j, arr1, arr2, a1, a2);
        if (j + 1 < map[0].length && map[i][j + 1] != -1)
            dfs(map, i, j + 1, arr1, arr2, a1, a2);
        if (i - 1 >= 0 && map[i - 1][j] != -1)
            dfs(map, i - 1, j, arr1, arr2, a1, a2);
        if (j - 1 >= 0 && map[i][j - 1] != -1)
            dfs(map, i, j - 1, arr1, arr2, a1, a2);
        map[i][j] = temp;//回溯
        list.remove(list.size() - 1);//回溯
        a1[i]--;//回溯
        a2[j]--;//回溯
    }

    //判断两个数组是否相同，将xy方向的箭的个数分别放两个数组里面，然后每一条路径都比较一下是否符合要求
    private static boolean check(int[] arr1, int arr2[]) {
        for (int i = 0; i < arr1.length - 1; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        if (arr1[arr1.length - 1] != arr2[arr2.length - 1] - 1)
            return false;
        return true;
    }