[POJ2488]A Knight's Journey(DFS)

最新推荐文章于 2025-03-30 16:45:00 发布

原创最新推荐文章于 2025-03-30 16:45:00 发布 · 181 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一种求解字典序最小遍历路径的深度优先搜索算法，该算法适用于特定类型的棋盘问题。通过设定合理的方向数组，确保了遍历路径的最优性，并使用标记数组避免重复遍历。

题目大意

输入一个棋盘的大小（p和q），p为1～p坐标，q为（0～q - 1）+ ‘A’坐标大写字母作为坐标。然后输出字典序最小的遍历，无法完全遍历则输出impossible。

思路

深度优先遍历，字典序是本题的关键，棋走的位置次序很重要。一开始我的dir数组总是没有列对，导致输出的不是最小字典序遍历=_=
首先，数字的ASSIC码小于字母的所以尽量让字母小（从上到下，从左到右）。
其次，为了防止重复遍历，用vis记录。
这里写图片描述

这里写图片描述

总结

刷题量还是太少，没有形成自己的思路。
下一步刷够uva一百道进校队吧。

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;

const int maxn = 30;

struct point {
    int x, y;
} path[maxn];

int dir[8][2] = {{-1, -2}, {1, -2}, {-2, -1}, {2, -1}, {-2, 1}, {2, 1}, {-1, 2}, {1, 2}};   //第二位是字母坐标的改变量
int vis[maxn][maxn];
int p, q;  
bool success;

bool judge(int x, int y) {
    if (x <= p && x >= 1 && y <= q && y >= 1 && !vis[x][y] && !success)
        return true;
    else 
        return false;
}

void dfs(int x, int y, int step) {
    path[step].x = x;
    path[step].y = y;
    if (step == p * q) {
        success = true;
        return;
    }
    for(int i = 0; i < 8; i++) {
        int nx = x + dir[i][0];
        int ny = y + dir[i][1];
        if (judge(nx, ny)) {
            vis[nx][ny] = 1;
            dfs(nx, ny, step + 1);
            vis[nx][ny] = 0;  //撤步
        }
    }
}

void init() {
    success = false;
    memset(vis, 0, sizeof(vis));
    vis[1][1] = 1;
}

int main() {
    //freopen("input.txt", "r", stdin);
    int T;
    int kase = 0;
    cin >> T;
    while(T--) {
        printf("Scenario #%d:\n", ++kase);
        cin >> p >> q;
        init();
        dfs(1, 1, 1);
        if (!success) printf("impossible\n");
        else {
            for(int i = 1; i <= p * q; i++) {
                printf("%c%c", path[i].y + 'A' - 1, path[i].x + '0');
            }
            printf("\n");
        }
        if (T) printf("\n");
    }
    return 0;
}