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;
}