A Knight's Journey （搜索）

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

一个骑士的旅行，骑士只能走图中白色的圆点标记的八个方向，问题是骑士能不能走完所有的点！ 如果能按字典序输出走每个点的先后顺序。

按字典序输出，一定要注意搜索的方向，主要把路径记录下来，设置一个访问的节点数sum。sum == m*n时搜索结束，设置一个path数组，每次记录行列值即可！

代码如下：

#include<iostream>
#include<cstdio>
#include<map>
#include<math.h>
#include<cstring>
#include<algorithm>
using namespace std;

int dir[8][2] = {-2,-1,-2,1,-1,-2,-1,2,1,-2,1,2,2,-1,2,1}; // 8个方向！ 按字典序！
int vis[9][9], path[65][2], s, m ,n;

void dfs(int i, int j, int sum)
{
    if(s)
        return ;
    path[sum][0] = i; 
    path[sum][1] = j;//记录下每次走过的点的行列值
    if(sum == m * n)
    {
        s = 1;
    }
    for(int k = 0; k < 8; k++)
    {
        int dx = i + dir[k][0];
        int dy = j + dir[k][1];
        if(vis[dx][dy] && dx > 0 && dx <= n && dy > 0 && dy <= m)
        {
            vis[dx][dy] = 0;
            dfs(dx,dy,sum + 1);
            vis[dx][dy] = 1;
        }
    }
}

int main()
{
    int t, q = 1, flag = 1, i;
    scanf("%d",&t);
    while(t--)
    {
        if(!flag)
            printf("\n");
        else
            flag = 0;
        scanf("%d%d",&m,&n);//m为列，n为行！反过来搜索方向要改变
        memset(vis, 1, sizeof(vis));
        s = 0;
        vis[1][1] = 0;
        dfs(1,1,1);
        if(s)
        {
            printf("Scenario #%d:\n",q++);
            for(i = 1; i <= m * n; i++)
            {
                printf("%c%d",path[i][0] + 'A' - 1, path[i][1]);//输出
            }
            printf("\n");
        }
        else
        {
            printf("Scenario #%d:\n",q++);
            printf("impossible\n");
        }
    }
}