UVa 633 A Chess Knight

原创于 2026-07-07 09:48:28 发布 · 159 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

图遍历

BFS

题目描述

在一个 $2N \times 2N$ 的棋盘上（ $\le N \le 20$ ），有一只“动态骑士”。它可以执行三种类型的移动：

$K\texttt{K}$ 型：与常规国际象棋骑士相同，即沿水平或垂直方向移动 $2$ 格，再沿垂直方向移动 $1$ 格，共有 $8$ 个可能的方向。
$B\texttt{B}$ 型：沿对角线方向移动 $2$ 格，共有 $4$ 个可能的方向。
$T\texttt{T}$ 型：沿棋盘的水平中轴或垂直中轴进行镜像反射，即坐标 $(x, y)$ 变为 $(2 N + 1 - x, y)$ 或 $(x, 2 N + 1 - y)$ 。

骑士不能走出棋盘，也不能落在障碍物上。此外，骑士不能连续两次使用相同类型的移动（第一次移动可以任意类型）。给定起点和终点，求从起点到终点的最少移动次数。如果无法到达，则报告无解。

输入格式

输入包含多组测试用例。每个测试用例的第一行为一个整数 $N$ （ $N > 0$ ），棋盘大小为 $2N \times 2N$ 。第二行为起点坐标 $x_s, y_s)$ ，第三行为终点坐标 $x_t, y_t)$ 。随后若干行给出障碍物的坐标，每行两个整数，以 0 0 结束障碍物描述。输入以单独的 $N = 0$ 结束。

输出格式

对于每个测试用例：

若起点与终点相同，输出 Result : 0。
若终点是障碍物，输出 Solution doesn't exist。
否则，输出最少移动次数，格式为 Result : X，其中 $X$ 为步数；若不可达，则输出 Solution doesn't exist。

样例

输入

输出

Result : 0
Solution doesn't exist
Result : 6
Result : 4

题目分析

本题要求在带障碍物的棋盘上求最短路径，但移动规则比常规骑士复杂，且包含三种不同类型的移动，并限制不能连续使用同类型。由于移动类型只有三种，且每种类型的移动数量有限（ $K\texttt{K}$ 型 $8$ 种， $B\texttt{B}$ 型 $4$ 种， $T\texttt{T}$ 型 $2$ 种），棋盘最大尺寸为 $40 \times 40$ ，状态总数可控。

最短路问题可以用广度优先搜索（ $BFS\texttt{BFS}$ ）求解，但状态不仅包含坐标 $(x, y)$ ，还需要记录上一步使用的移动类型，因为规则限制了连续相同类型。因此每个位置对应 $4$ 个状态（上一步为无、 $K\texttt{K}$ 、 $B\texttt{B}$ 、 $T\texttt{T}$ ），分别标记访问情况。 $BFS\texttt{BFS}$ 从起点开始，每次扩展所有合法移动，并确保新移动的类型与上一步不同。当扩展到终点时，当前步数即为最少步数。

解题思路

状态表示与访问标记

定义结构体 movement 包含坐标 x、y、当前步数 steps 以及上一步移动类型 lastMoveType（ $0$ 表示起点，无上一步； $1$ 表示 $K\texttt{K}$ ； $2$ 表示 $B\texttt{B}$ ； $3$ 表示 $T\texttt{T}$ ）。使用三维数组 visited[x][y][type] 记录是否已访问过该状态，其中 type 对应上一步的类型（ $0$ 到 $3$ ）。若 visited[x][y][type] 为真，则不再入队，因为 $BFS\texttt{BFS}$ 首次访问即最优。

移动生成

$K\texttt{K}$ 型：枚举 $8$ 个偏移量 $(Δx,Δy)∈{(−2,−1),(−1,−2),(1,−2),(2,−1),(2,1),(1,2),(−1,2),(−2,1)}(\Delta x, \Delta y) \in \{(-2,-1),(-1,-2),(1,-2),(2,-1),(2,1),(1,2),(-1,2),(-2,1)\}$ ，检查目标坐标是否在棋盘内且非障碍物。
$B\texttt{B}$ 型：枚举 $4$ 个偏移量 $(Δx,Δy)∈{(−2,−2),(2,−2),(2,2),(−2,2)}(\Delta x, \Delta y) \in \{(-2,-2),(2,-2),(2,2),(-2,2)\}$ ，同样检查合法性。
$T\texttt{T}$ 型：计算镜像坐标 $(2 N + 1 - x, y)$ 和 $(x, 2 N + 1 - y)$ ，若目标非障碍物则入队。

搜索流程

读入 $N$ ，若 $N = 0$ 则结束。
读入起点、终点，并读入障碍物坐标直到 0 0。
若起点与终点重合，输出 Result : 0 并继续下一组。
若终点是障碍物，输出 Solution doesn't exist 并继续。
初始化队列，将起点状态（lastMoveType = 0，步数为 $0$ ）入队，并标记 visited[startx][starty][0] = 1。
执行 $BFS\texttt{BFS}$ ：
- 取出队首状态。
- 若坐标等于终点，输出当前步数并标记找到。
- 否则，对于三种移动类型（若当前上一步类型不等于该类型），尝试所有该类型的合法移动，若目标状态未访问，则入队并标记。
若队列空仍未找到，输出 Solution doesn't exist。

边界与剪枝

棋盘大小最大 $40$ ，状态数为 $40 \times 40 \times 4 = 6400$ ，非常小。
注意 T 型移动可能回到自身（当 $x = N + 0.5$ 时？但 $2 N$ 为偶数，镜像坐标不可能与自身重合，因为 $(2 N + 1 - x) = x$ 得到 $x = N + 0.5$ ，不是整数，所以不会自环）。
障碍物只禁止停留，不禁止经过（移动是跳跃式的，不经过中间格）。

复杂度分析

每个状态最多扩展一次，状态数为 $O((2N)2×4)=O(N2)O((2N)^2 \times 4) = O(N^2)$ ， $\le 20$ ，故状态数不超过 $6400$ 。
每次扩展尝试最多 $8 + 4 + 2 = 14$ 种移动，总扩展次数 $O(N2×14)O(N^2 \times 14)$ ，非常小。
空间复杂度 $O(N^2)$ 。

代码实现

// A Chess Knight
// UVa ID: 633
// Verdict: Accepted
// Submission Date: 2017-06-02
// UVa Run Time: 0.000s
//
// 版权所有（C）2017，邱秋。metaphysis # yeah dot net

#include <bits/stdc++.h>
using namespace std;

struct movement {
    int x, y, steps, lastMoveType;
};

int main() {
    cin.tie(0), cout.tie(0), ios::sync_with_stdio(false);
    int obstacle[64][64], visited[64][64][4], n;
    int offsetK[8][2] = {
        {-2, -1}, {-1, -2}, {1, -2}, {2, -1},
        {2, 1}, {1, 2}, {-1, 2}, {-2, 1}
    };
    int offsetB[4][2] = {
        {-2, -2}, {2, -2}, {2, 2}, {-2, 2}
    };
    while (cin >> n, n > 0) {
        n *= 2;
        memset(obstacle, 0, sizeof(obstacle));
        memset(visited, 0, sizeof(visited));
        int startx, starty, endx, endy;
        cin >> startx >> starty >> endx >> endy;
        int obstaclex, obstacley;
        while (cin >> obstaclex >> obstacley) {
            if (obstaclex == 0 && obstacley == 0) break;
            obstacle[obstaclex][obstacley] = 1;
        }
        if (startx == endx && starty == endy) {
            cout << "Result : 0\n";
            continue;
        }
        if (obstacle[endx][endy]) {
            cout << "Solution doesn't exist\n";
            continue;
        }
        queue<movement> unvisited;
        unvisited.push(movement{startx, starty, 0, 0});
        bool found = false;
        while (!unvisited.empty()) {
            movement m = unvisited.front();
            unvisited.pop();
            if (m.x == endx && m.y == endy) {
                cout << "Result : " << m.steps << '\n';
                found = true;
                break;
            }
            if (m.lastMoveType != 1 && !visited[m.x][m.y][1]) {
                for (int i = 0; i < 8; i++) {
                    int nextx = m.x + offsetK[i][0], nexty = m.y + offsetK[i][1];
                    if (nextx < 1 || nextx > n || nexty < 1 || nexty > n) continue;
                    if (obstacle[nextx][nexty]) continue;
                    unvisited.push(movement{nextx, nexty, m.steps + 1, 1});
                }
                visited[m.x][m.y][1] = 1;
            }
            if (m.lastMoveType != 2 && !visited[m.x][m.y][2]) {
                for (int i = 0; i < 4; i++) {
                    int nextx = m.x + offsetB[i][0], nexty = m.y + offsetB[i][1];
                    if (nextx < 1 || nextx > n || nexty < 1 || nexty > n) continue;
                    if (obstacle[nextx][nexty]) continue;
                    unvisited.push(movement{nextx, nexty, m.steps + 1, 2});
                }
                visited[m.x][m.y][2] = 1;
            }
            if (m.lastMoveType != 3 && !visited[m.x][m.y][3]) {
                int nextx = n - m.x + 1, nexty = m.y;
                if (!obstacle[nextx][nexty])
                    unvisited.push(movement{nextx, nexty, m.steps + 1, 3});
                nextx = m.x, nexty = n - m.y + 1;
                if (!obstacle[nextx][nexty])
                    unvisited.push(movement{nextx, nexty, m.steps + 1, 3});
                visited[m.x][m.y][3] = 1;
            }
        }
        if (!found)  cout << "Solution doesn't exist\n";
    }
    return 0;
}