POJ2488 dfs

A Knight's Journey

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 41972		Accepted: 14286

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

Source

TUD Programming Contest 2005, Darmstadt, Germany

题意：

象棋中骑士走日，给出一个p*q棋盘，问其实能否一次走遍所有的格子，按照字典序输出路径。

代码：

 //基础dfs,用vector保存路径。
 #include<iostream>
 #include<vector>
 #include<cstdio>
 #include<cstring>
 using namespace std;
 int p,q,t;
 const int diry[]={-,,-,,-,,-,};
 const int dirx[]={-,-,-,-,,,,};
 int sum;
 bool vis[][];
 vector<int>loadx;
 vector<int>loady;
 void dfs(int x,int y)
 {
     vis[x][y]=;
     sum++;
     loadx.push_back(x);
     loady.push_back(y);
     if(sum==p*q)
     return;
     for(int i=;i<;i++)
     {

         if(x+dirx[i]<=||x+dirx[i]>q||y+diry[i]<=||y+diry[i]>p)
         continue;
         if(vis[x+dirx[i]][y+diry[i]])
         continue;
         dfs(x+dirx[i],y+diry[i]);
         if(sum==p*q)
         return;
     }
     vis[x][y]=;
     sum--;
     loadx.pop_back();
     loady.pop_back();
 }
 int main()
 {
     scanf("%d",&t);
     for(int k=;k<=t;k++)
     {
         scanf("%d%d",&p,&q);
         sum=;
         memset(vis,,sizeof(vis));
         while(!loadx.empty())
         {
             loadx.pop_back();
             loady.pop_back();
         }
         for(int i=;i<=q;i++)
         {
             if(sum==p*q)
             break;
             for(int j=;j<=p;j++)
             {
                 dfs(i,j);
                 if(sum==p*q)
                 break;
             }
         }
         printf("Scenario #%d:\n",k);
         if(sum==p*q)
         {
             for(int i=;i<loadx.size();i++)
             {
                 printf("%c%d",loadx[i]+,loady[i]);
             }
             printf("\n\n");
         }
         else printf("impossible\n\n");
     }
     return ;
 }