A Knight's Journey

                                           A Knight's Journey

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 26808		Accepted: 9140

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 <stdlib.h> 
#include <iostream>

using namespace std;

#define MAX 10

bool vis[MAX][MAX], flag;                                                            //标记已访问，是否查找到结果
int m, n, cnt = 1, dir[8][2] = {{-2, -1}, {-2, 1}, {-1, -2}, {-1, 2}, {1, -2}, {1, 2}, {2, -1}, {2, 1}};  //方向， 注意如果按字典序输出的话必须x从小到大，y从小到大
typedef struct Elem                                                                   //用来记录路径的结构体
{
	int x;
	int y;
}elem;

elem ans[100];                                                                         //用来记录路径的结构体

void dfs(int count, elem pos)                                                          //用深搜搜出路径
{	
	if(flag)
	{
	    return;
	}
	elem temp;
    if(count == m * n)                                                                  //找到路径， 打印结果
	{
		printf("Scenario #%d:\n", cnt++);
		for(int i = 0; i < m*n; i++)
		{
			printf("%c%d", ans[i].x+65, ans[i].y+1);
		}
		printf("\n\n");                                                                 //注意此处超坑要加空行
		flag = 1;
		return;
	}
	for(int j = 0; j < 8; j++)
	{
        temp.x = pos.x + dir[j][0];
		temp.y = pos.y + dir[j][1];
	    if(temp.x >= 0 && temp.x < n && temp.y >= 0 && temp.y < m && !vis[temp.x][temp.y])    //不多说老套深搜
		{
		    ans[count] = temp;
			vis[temp.x][temp.y] = 1;
			dfs(count+1, temp);
			vis[temp.x][temp.y] = 0;
		}
	}
}

int main()
{
	int k;
	elem sp = {0, 0};                                                                   //起点
    scanf("%d", &k);
	while(k--)
	{
	    scanf("%d%d", &m, &n);
		memset(vis, 0, sizeof(vis));
		flag = 0;
		ans[0] = sp;
		vis[0][0] = 1;
		dfs(1, sp);
		if(!flag)                                                                        //未找到路径
		{
		    printf("Scenario #%d:\nimpossible\n\n", cnt++);
		}
	}
    return 0;
}