蓝桥杯：路径之谜

尐镇做题家

已于 2022-06-06 12:05:16 修改

阅读量1.1k

点赞数 4

CC 4.0 BY-SA版权

分类专栏：蓝桥杯文章标签：蓝桥杯

于 2022-06-06 12:05:05 首次发布

本文链接：https://blog.csdn.net/qq_32468603/article/details/125143797

蓝桥杯专栏收录该内容

72 篇文章

订阅专栏

题目描述

小明冒充 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<Integer> 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;row<N;row++){
            north[row] = scan.nextInt();
        }
        for(int col = 0;col<N;col++){
            west[col] = scan.nextInt();
        }
        //初始化地图，默认为false（全都没走过）
        map = new boolean[N][N];
        //从0，0开始搜索
        dfs(0,0);
        scan.close();
    }

    public static void dfs(int row, int col) {
        //设置当前坐标为走过
        map[row][col] = true;
        //然后判断是否是走到终点了，如果走到终点了，就根据路径依次往正北和正西两个方向发射箭矢，看看箭靶上面的数量是否相同
        list.add(col+row*N);
        if(row==N-1 && col==N-1){
            //创建两个空的箭靶，分别是正北和正西的，方便待会我们比较箭矢数量是否相同
            int[] north_compare = new int[N];
            int[] west_compare = new int[N];
            //遍历map，然后根据对应的row,col,往空的箭靶里面放箭，放完之后对比我们拿到的箭靶数量是否相同即可
            for(int r = 0;r<N;r++){
                for(int c = 0;c<N;c++){
                    if(map[r][c]){
                        //如果这个点走过肯定是true
                        //然后我们往我们空的箭靶上面放箭矢（因为每走到一个点，都需要往正北和正西方向分别射一箭）
                        north_compare[c]+=1;
                        west_compare[r]+=1;
                    }
                }
            }
            //比较系统给的标靶数量和我们模拟出来行走的标靶数量
            if( Arrays.equals(north,north_compare) && Arrays.equals(west,west_compare) ){
                //如果他们一致，那么肯定是唯一解
                for(int i = 0;i<list.size();i++){
                    if(i==list.size()-1){
                        System.out.print(list.get(i));
                    }else {
                        System.out.print(list.get(i) + " ");
                    }
                }
            }
            return ;
            //拿完箭矢数据之后和系统给的箭矢数据进行对比，如果相同那么代表
        }
        //直接模拟行走，按照顺时针来走吧，右下左上
        //还必须要回溯，如果当前节点不满足的话，要回溯成false，也就是没有行走过
        if(col<N-1 && map[row][col+1]!=true){
            dfs(row,col+1);
            map[row][col+1] = false;
            list.remove(list.size()-1);
        }
        if(row<N-1 && map[row+1][col]!=true){
            dfs(row+1,col);
            map[row+1][col] = false;
            list.remove(list.size()-1);
        }
        if(col>0 && 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<Integer> 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;col<N;col++){
            north[col] = scan.nextInt();
        }
        west = new int[N];
        for(int row = 0;row<N;row++) {
            west[row] = scan.nextInt();
        }
        scan.close();
        //初始化map
        map = new boolean[N][N];
        //从0，0处开始搜索（0，0处也是题目的起点）
        dfs(0,0);

    }
    public static void dfs(int row,int col) {
        //将当前节点设置为已经走过
        map[row][col] = true;
        //同时将该坐标添加到list中
        list.add(col+row*N);
        //要向正北和正西方向射箭，那么也就是对应位置的箭靶数量分别-1
        north[col]--;
        west[row]--;
        //然后判断是否走到了终点
        if(row == N-1 && col == N-1) {
            if(check()){
                //遍历输出我们走过的坐标
                for(int i = 0;i<list.size();i++){
                    if(i == list.size()-1){
                        System.out.print(list.get(i));
                    }else{
                        System.out.print(list.get(i)+" ");
                    }
                }
            }
            return;
        }

        //如果没有到终点，那么我们按照顺时针，右 下 左 上 开始走
        // (注意箭靶数量，如果箭靶数量小于等于0，那么这个方向肯定是不能走，直接回溯，节省时间空间)
        //先确认是否达到地图边界，再确认该坐标是否走过，再确认箭靶数量，箭靶数量足够的情况下才能让那边走
        if(col<N-1 && 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<N-1 && 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]++;
        }
        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<N;col++){
            if(north[col]!=0){
                return false;
            }
        }
        for(int row = 0;row<N;row++){
            if(west[row]!=0){
                return false;
            }
        }
        return true;
    }
}