当前位置：首页 > news >正文

蓝桥杯真题—路径之谜

news 来源：原创 2025/6/25 0:08:35

题目

小明冒充 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

分析

已知北墙和西墙箭靶上的箭数，需要找出骑士的行走路径。整体采用深度优先搜索（DFS）算法来探索所有可能的路径，直到找到满足条件的唯一路径。

DFS

具体步骤

输入处理：

读取城堡地面方格的边长 n。
读取北墙箭靶上的箭数，存储在 cntx 数组中。
读取西墙箭靶上的箭数，存储在 cnty 数组中。

初始化：

初始化 visited 数组，用于标记每个方格是否已经被访问过。
初始化 paths 数组，用于记录骑士的行走路径。
初始化 success 变量，用于标记是否已经找到满足条件的路径。

深度优先搜索（DFS）：

从起点 (1, 1) 开始进行深度优先搜索。
在每次递归调用中，将当前方格的编号记录到 paths 数组中，并标记该方格为已访问。
减少当前方格对应的北墙和西墙箭靶上的箭数。
检查是否到达终点 (n, n) 且所有箭靶上的箭都已被拔掉（通过 check 函数），如果是，则标记 success 为 true，记录路径长度，并返回。
尝试向四个方向（上、下、左、右）移动到下一个方格：
- 检查下一个方格是否合法（未越界且未被访问过）。
- 检查下一个方格对应的箭靶上是否还有箭，如果有，则继续递归搜索。
- 如果递归搜索没有找到满足条件的路径，则回溯，恢复当前方格的访问状态和箭靶上的箭数。

输出结果：

当找到满足条件的路径后，按照实际路径长度输出 paths 数组中的方格编号。

时间复杂度：O( $2^{n^{2}}$ )

空间复杂度：O( $n^{2}$ )

#include <iostream>
using namespace std;

const int MAXN = 404;
// 存储路径
int paths[MAXN];
// 控制走的方向
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
// 记录两个方向上每个箭靶中箭的数量
int cntx[MAXN], cnty[MAXN];
// 方格的边长
int n;
// 标记是否已经到达终点
bool success = false;
// 标记某点是否已经走过
bool visited[MAXN][MAXN];
// 记录实际路径长度
int pathLength = 0;

// 检查所有箭靶上的箭是否都已被拔掉
bool check() {
    for (int i = 1; i <= n; ++i) {
        if (cntx[i] != 0 || cnty[i] != 0) {
            return false;
        }
    }
    return true;
}

// 深度优先搜索函数
void dfs(int x, int y, int num) {
    // 将该点编号记录到路径中
    paths[num] = (y - 1) * n + x - 1;
    // 标记该点为已经走过的状态
    visited[x][y] = true;
    // 拔掉对应的箭
    cntx[x]--;
    cnty[y]--;

    if (x == n && y == n && check()) {
        success = true;
        pathLength = num;
        return;
    }

    for (int i = 0; i < 4; ++i) {
        int xx = x + dx[i];
        int yy = y + dy[i];
        if (!success && !visited[xx][yy] && xx >= 1 && xx <= n && yy >= 1 && yy <= n) {
            if (cntx[xx] > 0 && cnty[yy] > 0) {
                dfs(xx, yy, num + 1);
                if (success) {
                    return;
                }
                // 回溯操作
                visited[xx][yy] = false;
                cntx[xx]++;
                cnty[yy]++;
            }
        }
    }
}

int main() {
    // 读取方格的边长
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> cntx[i];
    }
    for (int i = 1; i <= n; ++i) {
        cin >> cnty[i];
    }

    // 从起点开始深度优先搜索
    dfs(1, 1, 1);

    // 输出路径
    for (int i = 1; i <= pathLength; ++i) {
        if (i > 1) {
            cout << " ";
        }
        cout << paths[i];
    }
    cout << endl;
    return 0;
}