POJ1178 Camlot

题目大意：

有一种棋盘游戏，棋盘有8x8共64个方格，有两种棋子：国王和骑士，国王只有一个，骑士可以有多个。国王每移动一步可以从当前位置移动到八个方向的相邻方格（共有8种走法），移动的时候不能越界。骑士也是8种走法，但走的是“日”字，移动的时候也不能越界。当国王遇到骑士时，骑士可以带上国王，该骑士和国王看作一个骑士，按骑士走法走，每走一步只算一步（即国王从此可以忽略）。现在要求出将棋盘上所有骑士以及国王移动到相同方格需要的最少移动步数。初始时各个骑士和国王均在不同的方格。

解题思路：

使用枚举法

如果确定了最终的位置、国王和骑士相遇的位置、国王与哪个骑士相遇三个要素，则最少移动步数就确定了。

最终的位置共有64种，国王和骑士相遇的位置也有64种，设有N个骑士，则国王与哪个骑士相遇有N种，则枚举O(64*64*N)

对某个最终位置dst，相遇位置m，遇到国王的骑士k：

 1 计算所有骑士到dst的最少移动步数。

  2 加上国王移动到m的最少移动步数。

  3 加上骑士k经过m到dst的最少移动步数。

  4 减去骑士k到dst的最少移动步数。（骑士k在第1步中也算了一遍，所以要减去）

  5 如果总的最少步数比当前已经求出的最少步数少，则更新最少步数。

枚举完后输出最后结果。

对于国王和骑士从某一点到另外一点的最少移动步数，采用floyd算法可以求出。

对棋盘的位置从0到63编号，A1为0，H8为63

king_map[i][j]表示国王从位置i到位置j最少的移动步数。

knight_map[i][j]表示骑士从位置i到位置j最少的移动步数。

为了在使用floyd算法前对king_map和knight_map进行初始化，使用两个二维数组表示国王和骑士从当前位置移动到8个位置的偏移量。

int king_move[8][2]={{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};
int>

[plain] view plaincopy

1. #include<iostream>  
2.   
3. using namespace std;  
4. const int INF=1000000000;  
5. int king_move[8][2]={{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};  
6. int knight_move[8][2]={{-2,-1},{-2,1},{-1,-2},{-1,2},{1,-2},{1,2},{2,-1},{2,1}};  
7. int king_map[64][64];  
8. int knight_map[64][64];  
9.   
10. //判定位置i是否合法0<=i<=63   
11. bool ok(int x, int y)   
12. {  
13.     if(x>=0 && x<8 && y>=0 && y<8) return true;  
14.     else return false;  
15. }  
16.   
17. //根据数字表示的位置获得坐标   
18. void getXY(int p, int &x, int &y)    
19. {  
20.     x=p%8;  
21.     y=p/8;  
22. }  
23.   
24. //根据坐标获得数字表示的位置   
25. int getPosition(int x, int y)   
26. {  
27.     return x+y*8;  
28. }  
29.   
30. //初始化 king_map和 knight_map  
31. void init()   
32. {  
33.     for(int i=0; i<64; ++i)  
34.     {  
35.       for(int j=0; j<64; ++j)  
36.       {  
37.             king_map[i][j]=INF;  
38.             knight_map[i][j]=INF;  
39.         }  
40.           
41.         king_map[i][i]=0;  
42.         knight_map[i][i]=0;  
43.         int x, tx, y, ty;  
44.         int next;  
45.         getXY(i, x, y);  
46.         for(int j=0; j<8; ++j)  
47.         {  
48.          tx = x+king_move[j][0];  
49.          ty = y+king_move[j][1];  
50.          if(ok(tx,ty))  
51.          {  
52.             next=getPosition(tx,ty);  
53.             king_map[i][next]=1;  
54.           }  
55.             
56.           tx = x+knight_move[j][0];  
57.           ty = y+knight_move[j][1];  
58.           if(ok(tx, ty))  
59.           {  
60.                 next=getPosition(tx,ty);  
61.                 knight_map[i][next]=1;  
62.           }  
63.         }  
64.   }  
65. }  
66.   
67. //利用floyd算法计算任意两点间的最短距离   
68. void floyd()  
69. {  
70.     for(int k=0; k<64; ++k)  
71.       for(int i=0; i<64; ++i)  
72.         for(int j=0; j<64; ++j)  
73.         {  
74.         if(king_map[i][k] + king_map[k][j] < king_map[i][j])  
75.               king_map[i][j] = king_map[i][k] + king_map[k][j];  
76.         if(knight_map[i][k] + knight_map[k][j] < knight_map[i][j])  
77.               knight_map[i][j] = knight_map[i][k] + knight_map[k][j];  
78.         }  
79.   
80. }  
81.   
82. int main()  
83. {  
84.     string s;  
85.     int p_num, s_size, min_move, sum;  
86.     int position[64];  
87.   
88.         init();  
89.         floyd();  
90.   
91.     cin>>s;  
92.     s_size = s.size();  
93.     p_num = 0;  
94.     //将字符串表示的位置转换为 0-63表示的位置   
95.     for(int i=0; i<s_size; i += 2)  
96.     {  
97.        position[p_num++] = s[i]-'A' + (s[i+1]-'1')*8;  
98.     }  
99.   
100.       
101.     min_move = INF;  
102.     for(int dst=0; dst<64; ++dst) //dst代表最终的位置  
103.       for(int m=0; m<64; ++m)  //m代表国王与骑士相遇的位置  
104.          for(int k=1; k<p_num; ++k)  //k代表与国王相遇的骑士  
105.          {  
106.                 sum=0;  
107.                 //计算所有骑士到dst需要的移动步数  
108.                 for(int i=1; i<p_num; ++i) sum += knight_map[position[i]][dst];  
109.                 //计算国王到m的步数  
110.                 sum += king_map[position[0]][m];  
111.                 //计算骑士k在m处遇到国王后再到dst的步数  
112.                 sum +=  knight_map[position[k]][m] + knight_map[m][dst];  
113.                 //减去骑士k多算的一次值  
114.                 sum -=  knight_map[position[k]][dst];  
115.                   
116.                 if(sum < min_move) min_move=sum;  
117.          }  
118.            
119.     //输出结果  
120.     cout<<min_move<<endl;   
121.       
122.     return 0;  
123. }