USACO-Section3.3 Camelot【宽度优先搜索】

题目描述：

很久以前，亚瑟王和他的骑士习惯每年元旦去庆祝他们的友谊。为了纪念上述事件，我们把这些是看作是一个有一人玩的棋盘游戏。有一个国王和若干个骑士被放置在一个由许多方格组成的棋盘上，没有两个骑士在同一个方格内。

国王可以移动到任何一个相邻的方格，从下图中黑子位置到下图中白子位置前提是他不掉出棋盘之外。

一个骑士可以从下图中黑子位置移动到下图中白子位置(走“日”字形） 但前提是他不掉出棋盘之外。

在游戏中，玩家可在每个方格上放不止一个棋子，假定方格足够大，任何棋子都不会阻碍到其他棋子正常行动。

玩家的任务就是把所有的棋子移动到同一个方格里——用最小的步数。为了完成这个任务，他必须按照上面所说的规则去移动棋子。另外，玩家可以选择一个骑士跟国王从他们两个相遇的那个点开始一起行动，这时他们按照骑士的行动规则行动，其他的单独骑士则自己一直走到集中点。骑士和国王一起走的时候，只算一个人走的步数。

写一个程序去计算他们集中在一起的最小步数，而且玩家必须自己找出这个集中点。当然，这些棋子可以在棋盘的任何地方集合。

INPUT FORMAT

第一行： 两个用空格隔开的整数：R,C 分别为棋盘行和列的长。不超过26列，30行。

第二行..结尾： 输入文件包含了一些有空格隔开的字母/数字对，一行有一个或以上。第一对为国王的位置，接下来是骑士的位置。可能没有骑士，也可能整个棋盘都是骑士。行从1开始，列从大写字母A开始。

OUTPUT FORMAT

单独一行表示棋子集中在一个方格的最小步数。

SAMPLE INPUT

8 8

D 4

A 3 A 8

H 1 H 8

国王位置在D4。一共有四个骑士，位置分别是A3,A8,H1和H8。

SAMPLE OUTPUT

10

SAMPLE OUTPUT ELABORATION

他们集中在B5。

骑士1: A3 - B5 (1步)

骑士2: A8 - C7 - B5 (2步)

骑士3: H1 - G3 - F5 - D4 (此时国王开始与这个骑士一起走) - B5 (4步)

骑士4: H8 - F7 - D6 - B5 (3步)

1 + 2 + 4 + 3 = 10步

解题思路：

这道题还是枚举解决，不过需要进行剪枝。先通过bfs计算骑士(i,j)到(m,n)的步数，然后枚举每个点作为集合点，计算总步数，每个骑士判断是否接王（在NOCOW上看到的优化，是计算王周围2格），取最小值即可。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<algorithm>
#include<queue>
#define INF 99999999
using namespace std;
FILE *fin,*fout;
int M,N;
int king[2];//国王位置
int ans=INF;
int knight[780][2],Tcount=0;//骑士位置和数量
int Range[31][27][31][27];//骑士一点到另一点的步数
typedef pair<int,int>P;
queue<P> q;
int a[8][2]={{2,1},{2,-1},{-2,1},{-2,-1},{1,2},{1,-2},{-1,2},{-1,-2}};

int bfs(int m,int n){//宽搜
Range[m]
[m]
=0;
q.push(P(m,n));
while(q.size()){
P p=q.front();q.pop();
int x=p.first,y=p.second;
for(int i=0;i<8;i++)
if(x+a[i][0]>=1&&x+a[i][0]<=M&&y+a[i][1]>=1&&y+a[i][1]<=N){
if(Range[m]
[x+a[i][0]][y+a[i][1]]>Range[m]
[x][y]+1){
Range[m]
[x+a[i][0]][y+a[i][1]]=Range[m]
[x][y]+1;
q.push(P(x+a[i][0],y+a[i][1]));
}
}
}
}
int judge(int m,int n){//判断已此点为集合点的最少步数
int king_own=max(abs(king[0]-m),abs(king[1]-n));
int sum=king_own;
for(int i=0;i<Tcount;i++){
sum+=Range[knight[i][0]][knight[i][1]][m]
;
}
int temp=sum;
for(int i=0;i<Tcount;i++)
for(int j=-2;j<=2;j++)
for(int k=-2;k<=2;k++){
if(king[0]+j>=1&&king[0]+j<=M&&king[1]+k>=1&&king[1]+k<=N){
int king_union=max(abs(j),abs(k))+Range
4000
[knight[i][0]][knight[i][1]][king[0]+j][king[1]+k]
+Range[king[0]+j][king[1]+k][m]
;
temp=min(temp,sum-king_own-Range[knight[i][0]][knight[i][1]][m]
+king_union);
}
}
return temp;
}
int main(){
fin  = fopen ("camelot.in", "r");
fout = fopen ("camelot.out", "w");
fscanf(fin,"%d%d\n",&M,&N);
fscanf(fin,"%c%d",&king[1],&king[0]);
king[1]-='A'-1;
for(int i=1;i<=M;i++)
for(int j=1;j<=N;j++)
for(int k=1;k<=M;k++)
for(int l=1;l<=N;l++)
Range[i][j][k][l]=INF;
while(fscanf(fin,"\n%c%d",&knight[Tcount][1],&knight[Tcount][0])!=EOF){
knight[Tcount][1]-='A'-1;
Tcount++;
}
for(int i=1;i<=M;i++){
for(int j=1;j<=N;j++){
bfs(i,j);
}
}
for(int i=1;i<=M;i++){
for(int j=1;j<=N;j++){
ans=min(ans,judge(i,j));
}
}
fprintf(fout,"%d\n",ans);
exit(0);
}