HDU1067 Gap

题目：

Let's play a card game called Gap. 
You have 28 cards labeled with two-digit numbers. The first digit (from 1 to 4) represents the suit of the card, and the second digit (from 1 to 7) represents the value of the card. 

First, you shu2e the cards and lay them face up on the table in four rows of seven cards, leaving a space of one card at the extreme left of each row. The following shows an example of initial layout. 

 

Next, you remove all cards of value 1, and put them in the open space at the left end of the rows: "11" to the top row, "21" to the next, and so on. 

Now you have 28 cards and four spaces, called gaps, in four rows and eight columns. You start moving cards from this layout. 

 

At each move, you choose one of the four gaps and fill it with the successor of the left neighbor of the gap. The successor of a card is the next card in the same suit, when it exists. For instance the successor of "42" is "43", and "27" has no successor. 

In the above layout, you can move "43" to the gap at the right of "42", or "36" to the gap at the right of "35". If you move "43", a new gap is generated to the right of "16". You cannot move any card to the right of a card of value 7, nor to the right of a gap. 

The goal of the game is, by choosing clever moves, to make four ascending sequences of the same suit, as follows. 

 

Your task is to find the minimum number of moves to reach the goal layout. 

输入：

The input starts with a line containing the number of initial layouts that follow. 

Each layout consists of five lines - a blank line and four lines which represent initial layouts of four rows. Each row has seven two-digit numbers which correspond to the cards. 

输出：

For each initial layout, produce a line with the minimum number of moves to reach the goal layout. Note that this number should not include the initial four moves of the cards of value 1. If there is no move sequence from the initial layout to the goal layout, produce "-1". 

样例：

分析：题意是把任一直接移到空格处为一步;

BFS加hash判重

简单来说hash就是把一个状态用一个数来标识，能一一对应最好（比方说康托展开），这样你就可以方便地知道这个状态有没有走过

  1 #include<iostream>
  2 #include<sstream>
  3 #include<cstdio>
  4 #include<cstdlib>
  5 #include<string>
  6 #include<cstring>
  7 #include<algorithm>
  8 #include<functional>
  9 #include<iomanip>
 10 #include<numeric>
 11 #include<cmath>
 12 #include<queue>
 13 #include<vector>
 14 #include<set>
 15 #include<cctype>
 16 #define PI acos(-1.0)
 17 const int INF = 0x3f3f3f3f;
 18 const int NINF = -INF - 1;
 19 typedef long long ll;
 20 #define MOD 1000007
 21 using namespace std;
 22 ll Hash[MOD];
 23 struct node
 24 {
 25     int maze[4][8];
 26     int step;//记录步数
 27     friend bool operator == (node a, node b)//重载结构体“==”
 28     {
 29         for (int i = 0; i < 4; ++i)
 30         {
 31             for (int j = 0; j < 8; ++j)
 32                 if (a.maze[i][j] != b.maze[i][j]) return false;
 33         }
 34         return true;
 35     }
 36     ll gethash()//获取hash值
 37     {
 38         ll value = 0;
 39         for (int i = 0; i < 4; ++i)
 40         {
 41             for (int j = 0; j < 8; ++j)
 42                 value += (value<<ll(1)) + (ll)maze[i][j];//随意写
 43         }
 44         return value;
 45     }
 46 }st, ed;//起始与结束状态
 47 bool verif(ll value)//hash判重函数
 48 {
 49     int num = value % MOD;//对大质数取余
 50     while (Hash[num] != 0 && Hash[num] != value)//处理可能存在的hash冲突
 51     {
 52         num += 3;//随意写
 53         num %= MOD;
 54     }
 55     if (Hash[num] == 0)
 56     {
 57         Hash[num] = value;
 58         return true;
 59     }
 60     return false;
 61 }
 62 void bfs()
 63 {
 64     queue<node> q;
 65     memset(Hash, 0, sizeof(Hash));
 66     st.step = 0;
 67     q.push(st);
 68     verif(st.gethash());
 69     while (q.size())
 70     {
 71         node tmp = q.front();
 72         q.pop();
 73         for (int i = 0; i < 4; ++i)
 74         {
 75             for (int j = 0; j < 8; ++j)
 76             {
 77                 if (!tmp.maze[i][j])//寻找空格位置
 78                 {
 79                     node cur = tmp;
 80                     cur.step++;
 81                     int aim = tmp.maze[i][j - 1] + 1;
 82                     if (aim == 1 || aim == 8) continue;//空格前为空格或7则跳过
 83                     int x, y, flag = 0;
 84                     for (int m = 0; m < 4; ++m)
 85                     {
 86                         for (int n = 0; n < 8; ++n)
 87                         {
 88                             if (tmp.maze[m][n] == aim)
 89                             {
 90                                 x = m, y = n;
 91                                 flag = 1;
 92                             }
 93                         }
 94                     }
 95                     if (flag)
 96                     {
 97                         swap(cur.maze[x][y], cur.maze[i][j]);
 98                         ll value = cur.gethash();
 99                         //cout << value << endl;
100                         if (verif(value))
101                         {
102                             if (cur == ed)
103                             {
104                                 cout << cur.step << endl;
105                                 return;
106                             }
107                             q.push(cur);
108                         }
109                     }
110                 }
111             }
112         }
113     }
114     cout << -1 << endl;
115 }
116 int main()
117 {
118     int T;
119     cin >> T;
120     for (int i = 0; i < 4; ++i)//结束时状态
121     {
122         ed.maze[i][7] = 0;
123         for (int j = 0; j < 7; ++j)
124             ed.maze[i][j] = (i + 1) * 10 + j + 1;
125     }
126     while (T--)
127     {
128         string nul;
129         getline(cin, nul);
130         for (int i = 0; i < 4; ++i)//直接输入时就解决个位数为1的移至行首操作
131         {
132             st.maze[i][0] = (i + 1) * 10 + 1;
133             for (int j = 1; j < 8; ++j)
134             {
135                 cin >> st.maze[i][j];
136                 if (st.maze[i][j] % 10 == 1) st.maze[i][j] = 0;
137             }
138         }
139         if (st == ed) cout << 0 << endl;
140         else bfs();
141     }
142     return 0;
143 }