poj 2488 A Knight's Journey http://poj.org/problem?id=2488

Description
Background
The knight is getting bored of seeing the same black and white squares again and again and has decided to make a journey
around the world. Whenever a knight moves, it is two squares in one direction and one square perpendicular to this. The world of a knight is the chessboard he is living on. Our knight lives on a chessboard that has a smaller area than a regular 8 * 8 board, but it is still rectangular. Can you help this adventurous knight to make travel plans?

Problem
Find a path such that the knight visits every square once. The knight can start and end on any square of the board.

Input
The input begins with a positive integer n in the first line. The following lines contain n test cases. Each test case consists of a single line with two positive integers p and q, such that 1 <= p * q <= 26. This represents a p * q chessboard, where p describes how many different square numbers 1, … , p exist, q describes how many different square letters exist. These are the first q letters of the Latin alphabet: A, …

Output
The output for every scenario begins with a line containing “Scenario #i:”, where i is the number of the scenario starting at 1. Then print a single line containing the lexicographically first path that visits all squares of the chessboard with knight moves followed by an empty line. The path should be given on a single line by concatenating the names of the visited squares. Each square name consists of a capital letter followed by a number.
If no such path exist, you should output impossible on a single line.

Sample Input

3
1 1
2 3
4 3

Sample Output

Scenario #1:
A1

Scenario #2:
impossible

Scenario #3:
A1B3C1A2B4C2A3B1C3A4B2C4

#include<stdio.h>
#include<string.h>
#include <queue>
#include <stack>
#include <algorithm>
#define Max 21

using namespace std;

int n, m;
bool vis[30][30];
int x[]={-1, 1, -2, 2,-2, 2,-1, 1};
int y[]={-2,-2, -1,-1, 1, 1, 2, 2};
//从当前马的位置可以走到的8个位置
//在满足字典序最小的前提下 这8个方向的遍历先后不能变动
bool ok;

struct node
{
    int col, row;
}path[1000];
int e=0;

bool sure(int i, int j)
{
    if(i>=1 && i<=n && j>=1 && j<=m)
        return true;
    else
        return false;
}

void dfs(int i, int j, int cnt)//cnt表示我们在当前这次dfs偶中搜索到的节点
{
    path[cnt].col=j; path[cnt].row=i;//当前位置进入路径队列

    if(cnt==n*m){
        ok=true; return; //所有节点都已经遍历到
    }//在这return 开始往回回溯

    int a, b;
    for(int k=0; k<8; k++){

        a=i+x[k];
        b=j+y[k];
        if(sure(a, b) && !vis[a][b]){
            vis[a][b]=true;
            dfs(a, b, cnt+1);
            if(ok==true) return;//在这return 返回主函数
            vis[a][b]=false;
        }
    }
    return;
}

int main()
{
    int tg; scanf("%d", &tg);
    int cnt=1;

    while(tg--)
    {
        scanf("%d %d", &n, &m);
        ok=false;
        if(n==1 && m==1){
            printf("Scenario #%d:\n", cnt++);
            printf("A1\n\n");
            continue;
        }
        else{
            ok=false;
            memset(vis, false, sizeof(vis));
            vis[1][1]=true;
            e=0;
            dfs(1, 1, 1);

            if(!ok){
                printf("Scenario #%d:\n", cnt++);
                printf("impossible\n\n");
            }
            else{
                printf("Scenario #%d:\n", cnt++);
                for(int i=1; i<=n*m; i++)
                {
                    printf("%c%d", path[i].col+'A'-1, path[i].row );
                }
                printf("\n\n");
            }
        }
    }
    return 0;
}