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;
}