HDU 1401 Solitaire(棋盘状态BFS)

HDU 1401 Solitaire(棋盘状态BFS)

http://acm.hdu.edu.cn/showproblem.php?pid=1401

题意:

        对于一个8*8的棋牌,其中有4个棋子,每个棋子可以往上下左右各走一步,但是如果那一步不是空格而是另外一个棋子,那么就越过这个棋子再前进一步.现在给出了初始棋盘状态,和终结棋盘状态,问你在8步内(<=8)能否从初始态走到终结态.

分析:

        本题应该用双向BFS,单BFS容易超时.

        首先讲讲网上大多数的做法.网上采取双向BFS,分别从初态和终态各走4步(注意每一步的情况为:控制4个棋子中的一个向4个方向的一个走一步.所以每一步前进有16种情况.),然后看终态是否会走到初态已经走到的状态上.

        过程中棋盘的每个状态用3位二进制数表示一个0-7的数，一个棋子的坐标需要两个0-7范围的数，所以一个棋子需要6位二进制数。所以4个棋子要用24位二进制数表示一个棋盘状态。然后用hash表保存状态来判重,不能用vis[1<<24],因为内存肯定超.实际的状态数远<1<<24个.而且双向BFS需要将4个点的坐标排序才可以编码成状态st,单向BFS不排序直接set vis数组会出现重复的状态,不过不排序也行,因为重复状态并不多..

        我这里做的是BFS专题,所以暂时还是用单BFS做.以后做双向BFS专题再用双向BFS.(不过双向BFS其实也就是单向BFS,只不过用了2次BFS而已)

        单向BFS判断时候到达终点并不是每次排序比较4个点,而是4次判1即可.

        注意vis数组如果用int就会超内存.

AC代码:859ms如果用双向BFS只要40ms,注意如果把代码中的okend函数少几个空格,则超时.说明还是不要用太勉强的算法,功力不足.找超时BUG,找了好久,何必呢?以后这种题目,还是用主流算法,勉强没有幸福.

<span style="font-size:18px;">#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
int dr[] = {0, 1, 0, -1}; //上下左右
int dc[] = {1, 0, -1, 0};
int move[][2] = {0, 1, 1, 0, 0, -1, -1, 0};
struct Node
{
    int r[4], c[4], dist;
} p; //p节点用来记录初态
bool vis[8][8][8][8][8][8][8][8];//注意这里一定要bool,用int就超内存了
int map[8][8];
void set(Node s)
{
    vis[s.r[0]][s.c[0]][s.r[1]][s.c[1]][s.r[2]][s.c[2]][s.r[3]][s.c[3]] = 1;
}
bool visit(Node s)
{
    return vis[s.r[0]][s.c[0]][s.r[1]][s.c[1]][s.r[2]][s.c[2]][s.r[3]][s.c[3]];
}
bool okend(Node s)
{
    int i;
    for(i = 0; map[s.r[i]][s.c[i]] && i < 4; ++i);
    return (i == 4);
}
/*
上面的okend函数换成下面这个,则会超时.
bool okend(Node s)
{
    int i;
    for(i=0;map[s.r[i]][s.c[i]] && i<4;++i)
    return (i==4);
}
*/
bool inboard(int x, int y)
{
    if(x >= 8 || x < 0 || y >= 8 || y < 0) return 0;
    return 1;
}
bool isempty(Node s, int k)
{
    for(int i = 0; i < 4; ++i)
        if(i != k && s.r[i] == s.r[k] && s.c[i] == s.c[k]) return 0;
    return 1;
}

bool BFS()
{
    if(okend(p)) return true;
    memset(vis, 0, sizeof(vis));
    queue<Node> Q;
    p.dist = 0;
    Q.push(p);
    set(p);
    while(!Q.empty())
    {
        Node node = Q.front();
        Q.pop();
        for(int i = 0; i < 4; i++) //4个点
            for(int d = 0; d < 4; d++) //方向
            {
                Node t = node;
                t.r[i] += move[d][0], t.c[i] += move[d][1];
                t.dist++;
                if(inboard(t.r[i], t.c[i]))
                {
                    if(isempty(t, i))
                    {
                        if(visit(t)) continue;     //这句应该放这里,不能放上面.
                        if(okend(t)) return true;
                        set(t);
                        if(t.dist<8)Q.push(t);

                    }
                    else //前面的格子非空,那么就在走一步
                    {
                        t.r[i] += move[d][0], t.c[i] += move[d][1];
                        if(inboard(t.r[i], t.c[i]) && isempty(t, i) && !visit(t))
                        {
                            //要保证走一步之后还是空格子
                            if(okend(t)) return true;
                            set(t);
                            if(t.dist<8)Q.push(t);
                        }
                    }
                }
            }
    }
    return false;
}
int main()
{
    int x, y;
    while(scanf("%d%d", &x, &y) == 2)
    {
        x--, y--;
        p.r[0] = x;
        p.c[0] = y;
        for(int i = 1; i <= 3; i++)
        {
            scanf("%d%d", &x, &y);
            x--, y--;
            p.r[i] = x, p.c[i] = y;
        }
        memset(map, 0, sizeof(map));
        for(int i = 0; i < 4; i++)
        {
            scanf("%d%d", &x, &y);
            x--, y--;
            map[x][y] = 1;  //表示终态点为1
        }
        printf("%s\n", BFS() ? "YES" : "NO");
    }
    return 0;
}
</span>