hdu 1067 Gap+BFS+hash

题目大意：给一个4行8列方格，每个方格中保存一个两位数，该两位数的第十位为一个1~4的整数，个位为一个1~7的整数，经过有限步到达最终的状态如下所示：

刚开始时的第一列数位空，其中一组数据如下所示：

首先移动11,21,31,41到第一列对应的空位置，这四个值的移动不计入移动步数之内，如上图移动后的效果如下所示：

然后每次的移动就按照如下的规则进行移动：该空格左边为一个个位数不为7的非空数，这样的空格可以移入一个比左边数大1的数。

题目解法：基本的BFS，对于每种图的状态的保存使用Hash，借鉴了一个网上的Hash函数，然后就过了。- -|，借鉴地址:http://www.acmerblog.com/hdu-1067-Gap-1326.html

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <vector>
#include <string>
#include <utility>
#include <queue>
#include <algorithm>
#include <map>

using namespace std;

typedef long long LL;
#define MAXN 1000007

class GridState
{
public:
    int tmap[4][8];
    int step;
    // 判断状态是否相同
    bool operator==(const GridState&tm)const
    {
        for (int i = 0; i < 4; ++i){
            for (int j = 0; j < 8; ++j){
                if (tm.tmap[i][j] != tmap[i][j])return false;
            }
        }
        return true;
    }
    // 获取当前状态的Hash值
    LL getHashValue()
    {
        LL value = 0;
        for (int i = 0; i < 4; ++i){
            for (int j = 0; j < 8; ++j){
                value = (value<<(LL)1)+(LL)tmap[i][j];
            }
        }
        return value;
    }
    // 重装输出流
    friend ostream& operator<<(ostream &os, const GridState&tm );
};

LL Hash[MAXN];
GridState tst, tend;

ostream& operator<<(ostream &os, const GridState&tm)
{
    for (int i = 0; i < 4; ++i){
        for (int j = 0; j < 8; ++j){
            os << tm.tmap[i][j] << " ";
        }
        os << endl;
    }
    return os;
}
// 初始化最终状态
void initEndState()
{
    for (int i = 0; i < 4; ++i){
        for (int j = 0; j < 7; ++j){
            tend.tmap[i][j] = (i+1)*10+j+1;
        }
        tend.tmap[i][7] = 0;
    }
}

// 将初始状态变化到图2的状态
void freshStartState()
{
    for (int i = 0; i < 4; ++i){
        for (int j = 1; j < 8; ++j){
            if (tst.tmap[i][j]%10==1){
                swap(tst.tmap[i][j], tst.tmap[tst.tmap[i][j]/10-1][0]);
            }
        }
    }
}
// 输入数据
void initStartState()
{
    for (int i = 0; i < 4; ++i){
        for (int j = 1; j < 8; ++j){
            cin >> tst.tmap[i][j];
        }
        tst.tmap[i][0] = 0;
    }
    tst.step = 0;
    freshStartState();
}

// 将状态放入Hash函数
bool inHash(LL value)
{
    int v = value % MAXN;
    while (Hash[v]!=-1 && Hash[v]!=value){
        v += 10;
        v %= MAXN;
    }
    if (Hash[v] == -1){
        Hash[v] = value;
        return true;
    }
    return false;
}

// bfs求解
int bfs()
{
    int ans = -1;
    queue<GridState >Qu;
    Qu.push(tst);
    inHash(tst.getHashValue());
    while (!Qu.empty()){
        GridState cur = Qu.front();
        Qu.pop();
        //cout << cur << endl;
        //getchar();
        if (cur == tend){ans = cur.step;break;}
        for (int i = 0; i < 4; ++i){
            for (int j = 0; j < 7; ++j){
                if (cur.tmap[i][j] && cur.tmap[i][j]%10!=7 && !cur.tmap[i][j+1]){
                    GridState tmp = cur;
                    tmp.step++;
                    int x, y, flag = true;
                    for (int m = 0; m < 4 && flag; ++m){
                        for (int n = 1; n < 8 && flag; ++n){
                            if (tmp.tmap[m][n] == tmp.tmap[i][j]+1){
                                x = m, y = n, flag = false;
                            }
                        }
                    }
                    swap(tmp.tmap[i][j+1], tmp.tmap[x][y]);
                    if (inHash(tmp.getHashValue())){
                        Qu.push(tmp);
                        //cout << "pushed:" << tmp.getHashValue() << endl;
                    }
                }
            }
        }
    }
    return ans;
}

void solve()
{
    memset (Hash, -1, sizeof(Hash));
    int ans = bfs();
    cout << ans << endl;
}

int main()
{
    int t;
    initEndState();
    cin >> t;
    while (t--){
        initStartState();
        solve();
    }
    return 0;
}