HDU 2488 A Knight's Journey(dfs)

我就是我 2022-06-10 11:26 75阅读 0赞

**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

题解：

题意：

给一个n\*m的棋盘，和马走的八个方向，问你是否能走满整个棋盘，如果可以输出字典序最小的

思路：

这题以前在搜索专题做过，就是如果可以走满就直接从(1,1)这个点开始搜索，要保证字典序最小那么搜索的方向就要注意了，越右边的方向越优先考虑，找到一种就可以了，然后输出的时候先输出y再输出x这个有点坑

代码：

#include<algorithm>
    #include<iostream>
    #include<cstring>
    #include<stdio.h>
    #include<math.h>
    #include<string>
    #include<stdio.h>
    #include<queue>
    #include<stack>
    #include<map>
    #include<vector>
    #include<deque>
    using namespace std;
    #define lson k*2
    #define rson k*2+1
    #define M (t[k].l+t[k].r)/2
    #define INF 1008611111
    #define ll long long
    #define eps 1e-15
    int p[30][30];//存是否走过
    int xx[30];//存路径的x坐标
    int yy[30];
    int dirx[8]={-1,1,-2,2,-2,2,-1,1};//方向比较重要
    int diry[8]={-2,-2,-1,-1,1,1,2,2};
    int n,m,tag;
    void dfs(int x,int y,int step)
    {
        if(step>=m*n)//如果走满了
        {
            tag=1;
        }
        if(tag)
        {
            return;
        }
        int i,j,sx,sy;
        for(i=0;i<8;i++)//八个方向dfs搜索回溯
        {
            sx=x+dirx[i];
            sy=y+diry[i];
            if(sx>=1&&sy>=1&&sx<=m&&sy<=n&&!p[sx][sy])
            {
                p[sx][sy]=1;
                xx[step]=sx;
                yy[step]=sy;//记录路径
                dfs(sx,sy,step+1);
                if(tag)
                    return;
                p[sx][sy]=0;
            }
        }
    }
    int main()
    {
        int i,j,test,q;
        scanf("%d",&test);
        for(q=1;q<=test;q++)
        {
            scanf("%d%d",&m,&n);
            memset(p,0,sizeof(p));
            tag=0;
            xx[0]=1;
            yy[0]=1;
            p[1][1]=1;
            dfs(1,1,1);//起点为1,1
            printf("Scenario #%d:\n",q);
            if(tag)
            for(i=0;i<n*m;i++)
            {
                printf("%c%d",'A'+yy[i]-1,xx[i]);//输出是先y再x
            }
            else
                printf("impossible");
            printf("\n");
            if(q!=test)//注意格式
                printf("\n");
        }
        return 0;
    }