A Knight's Journey

A Knight's Journey

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 131072/65536K (Java/Other)

Total Submission(s) : 43   Accepted Submission(s) : 15

Problem 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<iostream>
#include<cstring>
#include<cstdio>

using namespace std;

#define MAX 27
int dir[8][2]= {{-2,-1},{-2,1},{-1,-2},{-1,2},{1,-2},{1,2},{2,-1},{2,1}}; //下一步的八个方向
int step,zx[MAX],zy[MAX],map[MAX][MAX],mark;//记录已经走过的步数，记录走过的网格的横纵坐标，标记该网格是否走过，记录是否找到路径
int p,q;

int dfs(int i,int j)//深搜函数
{
    if(mark)return 0;//如果已经找到路径 返回
    int x,y;
    zx[step]=i;//记录当前网格的横坐标
    zy[step]=j;//记录当前网格的纵坐标
    step++;
    if(step==p*q)//如果走过的步数等于棋盘上网格的总数
    {
        mark=1;//找到路径
        return 0;//返回
    }
    map[i][j]=1;//标记该网格
    for(int k=0; k<8; k++)
    {
        x=i+dir[k][1];//下一步x
        y=j+dir[k][0];//下一步y，这个地方的x，y的顺序千万别错了，为了保证字典续
        if(map[x][y]==0&&x>0&&x<=p&&y>0&&y<=q)//判断是否走过 判断是否越界
        {
            dfs(x,y);//如果没有走过，没有越界，向下深搜
            step--;//如果返回 步数减一
        }
    }
    map[i][j]=0;//清除该网格的标记
    return 0;
}

int main()
{
    //freopen("input.txt","r",stdin);
    //freopen("output1.txt","w",stdout);
    int n;
    while(cin>>n)
    {
        for(int i=1; i<=n; i++)
        {
            cin>>p>>q;
            memset(map,0,sizeof(map));//数组清零
            step=mark=0;
            dfs(1,1);//从（1，1）号网格开始深搜
            cout<<"Scenario #"<<i<<":"<<endl;
            if(mark)
            {
                for(int j=0; j<p*q; j++)
                    printf("%c%d",zy[j]+'A'-1,zx[j]);
                cout<<endl;
            }
            else cout<<"impossible"<<endl;
            if(i!=n)cout<<endl;
        }
    }
    return 0;
}