蓝桥杯：路径之谜

目录

题目描述

输入描述

输出描述

输入输出样例

 题目分析：暴力深搜

AC代码（Java）: 

---

题目描述

小明冒充 X 星球的骑士，进入了一个奇怪的城堡。

城堡里边什么都没有，只有方形石头铺成的地面。

假设城堡地面是n×n 个方格。如下图所示。

按习俗，骑士要从西北角走到东南角。可以横向或纵向移动，但不能斜着走，也不能跳跃。每走到一个新方格，就要向正北方和正西方各射一箭。（城堡的西墙和北墙内各有 n 个靶子）同一个方格只允许经过一次。但不必走完所有的方格。如果只给出靶子上箭的数目，你能推断出骑士的行走路线吗？有时是可以的，比如上图中的例子。

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

输入描述

第一行一个整数 N（0≤N≤20)，表示地面有 N×N 个方格。

第二行 N 个整数，空格分开，表示北边的箭靶上的数字（自西向东）

第三行 N 个整数，空格分开，表示西边的箭靶上的数字（自北向南）

输出描述

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

为了方便表示，我们约定每个小格子用一个数字代表，从西北角开始编号: 0,1,2,3 ⋯

比如，上图中的方块编号为：

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

 题目分析：暴力深搜

        1. 图的搜索，一般都是确定四个方向（我习惯用顺时针）。

        2.但是题目有特殊要求，他给了额外的箭靶数（也就是每行，每列能走的格子），也就是需要根据箭靶数来走，题目也说了，只有唯一解，所以我们拿到箭靶数，然后填充一个全部没有走过的地图（可以用boolean，true代表走了）。

        3.关于箭靶，我用两个一维数组，一个north（记录每列能走的数量），一个west（记录每行能走的数量），然后当我们走到row，col处，我们就可以让north[col]减少一根箭，也就是north[col]--; west[row]也同理自减。

        4.从0，0处走到n-1，n-1处，也就是0，0是开始，n-1，n-1是终点。我们只需要DFS搜索能够走到n-1,n-1处的走法即可。走法我用一个列表来存。

        5.但是题目数据量偏大，如果全部搜索的话肯定会超时，所以我使用了箭靶，每走到一个点，就分别让正北（north）和正西（west）的箭靶数量自减。如果小于=0了，那么就代表这个方向不能走。

        6。要注意回溯，遇到了错误的走法，就回溯丢弃掉。

一开始的写法（只通过了两个测试用例，其余全部超时）：

import java.util.*;

// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    static int N;
    //创建两个箭靶，存放北方（行），西方（列）每个位置的箭靶数量
    static int[] north;
    static int[] west;
    //因为地图只有两种状态，要么是走过的路，要么就是没走过的路，所以用boolean存放行走信息
    static boolean[][] map;

    static List list = new ArrayList<>();
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        N = scan.nextInt();
        //创建两个箭靶，然后分别拿到箭靶的值
        north = new int[N];
        west = new int[N];
        for(int row = 0;row0 && map[row][col-1]!=true){
            dfs(row,col-1);
            map[row][col-1] = false;
            list.remove(list.size()-1);
        }
        if(row>0 && map[row-1][col]!=true){
            dfs(row-1,col);
            map[row-1][col] = false;
            list.remove(list.size()-1);
        }
    }
}

        分析了一遍代码下来，原因就是由于搜索的次数过多，导致后面N越大，耗时越多，所以我就考虑直接用north和west作为搜索的条件之一，需要判断north和west是否能继续往下搜索。

AC代码（Java）: 

import java.util.*;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    //之后要计算坐标，所以设为全局
    static int N ;
    //设置两个箭靶，分别是正北（列）和正西（行）
    static int[] north ; //正北（列）
    static int[] west ;  //正西（行）
    //因为地图只有两种状态，走过或者没有走过，所以我们用boolean来记录，true就是走过
    static boolean[][] map;
    //用一个列表来记录走过的格子
    static List list = new ArrayList<>();
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //拿到N和箭靶数据
        N = scan.nextInt();
        north = new int[N];
        for(int col = 0;col0 && west[row]>0) ) {
            dfs(row,col+1);
            //进行回溯（箭靶数量也要回溯）
            map[row][col+1] = false;
            list.remove(list.size()-1);
            north[col+1]++;
            west[row]++;
        }
        if(row0 && west[row+1]>0) ) {
            dfs(row+1,col);
            //进行回溯（箭靶数量也要回溯）
            map[row+1][col] = false;
            list.remove(list.size()-1);
            north[col]++;
            west[row+1]++;
        }
        if(col>0 && map[row][col-1]==false && (north[col-1]>0 && west[row]>0) ) {
            dfs(row,col-1);
            //进行回溯（箭靶数量也要回溯）
            map[row][col-1] = false;
            list.remove(list.size()-1);
            north[col-1]++;
            west[row]++;
        }
        if(row>0 && map[row-1][col]==false && (north[col]>0 && west[row-1]>0) ) {
            dfs(row-1,col);
            //进行回溯（箭靶数量也要回溯）
            map[row-1][col] = false;
            list.remove(list.size()-1);
            north[col]++;
            west[row-1]++;
        }
    }
    //检查箭靶数量是否都是0了，如果都是0了，那么代表该路径是唯一了
    public static boolean check(){
        //遍历查找箭靶数量
        for(int col = 0;col