POJ 2488 A Knight's Journey (回溯法 | DFS)

题目链接：http://poj.org/problem?id=2488

题意：

　　在国际象棋的题盘上有一个骑士，骑士只能走“日”，即站在某一个位置，它可以往周围八个满足条件的格子上跳跃，现在给你一个p * q的矩形格子，让你找一个跳跃顺序(起点自选)，使得这个顺序恰好经过矩阵的每一个格子，且每一个格子仅经过一次，即找一个符合跳跃条件的序列，遍历整个矩形格子。如果有多个，那么就输出字典序最小的。

思路：

　　貌似可以利用哈密顿通路来解决，但是感觉有点太麻烦，没怎么细想，感觉还是回溯法比较好。首先题目要求字典须，所以拓展节点的顺序不能是随意的，这里把图抽象一下：

    A  B C  D  E  F  G 

1| *  *  3  *  5  *  *

2| *  1  *  *  *  7  *

3| *  *  *  @ *  *  *

4| *  2  *  *  *  8  *

5| *  *  4  *  6  *  *

假设“@”为骑士某时某刻的位置，可以想到先考虑位置“1”为字典需最小的，紧接着2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8为字典序依次增大的选择，所以每次的选择必须按照上面路径才可保证第一个找到的为字典需最大的。由于这道题的特殊性，可以直接以“A1”为起点，搜索路径，而不用枚举起点进行搜索，大概是因为题目给的所有数据都有以“A1”为起点的路径吧。

代码：

#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <stack>
#include <queue>
#include <vector>
#include <algorithm>
#include <string>
#define memst(a, b) memset((a), (b), sizeof((a)))

typedef long long LL;
using namespace std;
const int MAXN = 26;
int map[MAXN + 3][MAXN + 3];
int stepX[] = {-1, 1, -2, 2, -2, 2, -1, 1};//字典序依次增大的选择
int stepY[] = {-2, -2, -1, -1, 1, 1, 2, 2};
int ok;
int p, q;

typedef struct Chess{
    char ch;//字母
    int nu;//数字
}chess;
chess ve[MAXN + 7];

int check(int x, int y) {//剪掉不可能的搜索子树
    if(x <= 0 || y <= 0 || x > p || y > q) return 0;
    if(map[x][y]) return -1;
    return 1;
}

void backtrack(int x, int y, int n) {
    if(ok) return ;
    if(n == p * q) {//找到了一条路经
        chess tp;
        tp.ch = y + 'A' - 1, tp.nu = x;
        ve[n] = tp;
        ok = 1;
        return ;
    }
    else {
        for(int i = 0; i < 8; i++) {//往周围八个方向进行试探
            int nex = x + stepX[i], ney = y + stepY[i];
            chess tp;
            tp.ch = y + 'A' - 1, tp.nu = x;
            ve[n] = tp;
            if(check(nex, ney) > 0) {//剪枝
                map[nex][ney] = 1;
                backtrack(nex, ney, n + 1);
                map[nex][ney] = 0; //恢复现场
            }
        }
    }
}

int main() {
    int T;
    scanf("%d", &T);
    int kas = 1;
    while(T--) {
        scanf("%d%d", &p, &q);
        memset(map, 0, sizeof(map));
        ok = 0;
        int stX = 1, stY = 1;//起点
        map[stX][stY] = 1;
        memset(&ve, 0, sizeof(chess));
        backtrack(stX, stY, 1);
        printf("Scenario #%d:\n", kas++);
        if(ok) {
            for(int i = 1; i <= p * q; i++) {
                printf("%c%d", ve[i].ch, ve[i].nu);
            }
            printf("\n");
        }
        else printf("impossible\n");
        if (T)printf("\n");
    }
    return 0;
}