poj 1198 || zoj 1505 || hdoj 1401 双向宽度遍历

参考了：http://blog.csdn.net/zxy_snow/article/details/6844220

题目大意:给出两个棋盘布局，问第一个棋盘布局，移动不超过8步，是否能到达第2个棋盘布局，移动棋子时，要是相邻的格子有棋子，而再过去没有棋子，则可以跳过这个棋子到达下一格

解题思路：双向宽度遍历，因为到达最终状态的布局，所以可以从最终状态反向走到达，因为最多不超过4步，那么从开始状态走4步，最终状态走4步，看是否有交集

，可以用状态压缩来保存棋盘布局

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <queue>
using namespace std;

long long st, ed;

int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

bool bfs(long long s, set<long long> &ss, set<long long> &st, bool flag);
bool bing(long long s, int step, set<long long> &ss, set<long long> &st, bool flag, queue< pair<long long, int> > &q);

int main()
{
    int x, y;
    while(scanf("%d %d", &x, &y) != EOF)
    {
        st = ed = 0;
        x--; y--;
        int p = x * 8 + y;
        st |= (1LL << p);
        for(int i = 0; i < 3; i++)
        {
            scanf("%d %d", &x, &y);
            x--; y--;
            p = x * 8 + y;
            st |= (1LL << p);
        }
        for(int i = 0; i < 4; i++)
        {
            scanf("%d %d", &x, &y);
            x--; y--;
            p = x * 8 + y;
            ed |= (1LL << p);
        }
        set<long long> ss, es;
        
        bfs(st, ss, es, false);
        bool result = bfs(ed, es, ss, true);
        puts(result ? "YES" : "NO");
    }
   
    return 0;
}

bool bfs(long long s, set<long long> &ss, set<long long> &st, bool flag)
{
    queue< pair<long long, int> > q;
    ss.insert(s);
    q.push(make_pair(s, 0));
    while(!q.empty())
    {
        pair<long long, int> tmp = q.front();
        q.pop();
        if(tmp.second < 4)
        {
            bool ans = bing(tmp.first, tmp.second + 1, ss, st, flag, q);
            if(ans)
                return true;
        }
        else
            return false;
    }
    return false;
}

bool bing(long long s, int step, set<long long> &ss, set<long long> &st, bool flag, queue<pair<long long, int> > &q)
{
    bool pan[8][8];
	int p[4][2], cnt = 0;
	memset(pan, 0, sizeof(pan));
	for(int i = 0; i < 64; i++)
	{
        if(s & (1LL << i))
        {
            int x = i / 8;
            int y = i % 8;
            pan[x][y] = true;
            p[cnt][0] = x;
            p[cnt++][1] = y;
        }
    }
    
    for(int i = 0; i < cnt; i++)
    {
        long long tmp = s;
        tmp ^= (1LL << (p[i][0] * 8 + p[i][1]));
        long long la = tmp;
        for(int j = 0; j < 4; j++)
        {
            tmp = la;
            int x = p[i][0] + dir[j][0];
            int y = p[i][1] + dir[j][1];
            if(x >= 0 && x < 8 && y >= 0 && y < 8)
            {
                if(!pan[x][y])
                {
                    tmp ^= (1LL << (x * 8 + y));
                    if(!ss.count(tmp))
                    {
                        if(flag && st.count(tmp))
                            return true;
                        q.push(make_pair(tmp, step));
                        ss.insert(tmp);
                    }
                }
                else
                {
                    x += dir[j][0];
                    y += dir[j][1];
                    if(x >= 0 && x < 8 && y >= 0 && y < 8 && !pan[x][y])
                    {
                        tmp ^= (1LL << (x * 8 + y));
                        if(!ss.count(tmp))
                        {
                            if(flag && st.count(tmp))
                                return true;
                            q.push(make_pair(tmp, step));
                            ss.insert(tmp);
                        }
                    }
                }
            }
        }
    }
    return false;
}