USACO Training 3.3.3 Camelot 亚瑟王的宫殿 题解与分析

Camelot亚瑟王的宫殿

IOI 98

描述

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

这个例子是标准的8*8棋盘

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

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

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

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

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

格式

PROGRAM NAME: camelot

INPUT FORMAT

(file camelot.in)

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

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

OUTPUT FORMAT

(file camelot.out)

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

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步

【分析】：

首先，对输入的处理。将输入的大写字母转化为数字存下国王和每个骑士的位置。<一定要注意对大批空格的处理>

然后将每个骑士从(x1,y1)点到(x2,y2)点的最短步数记录在dist[x1][y1][x2][y2]中，这里我用DFS实现，只是要限深搜层数，在该题目中，一般取25-32为宜，只是本人将最小上限用N次测评卡出是12。设定DFS深度上限是常用的剪枝。

用求出的dist求出所有骑士到达点(i,j)的路程和，存在数组sum[i][j]中，以便后面调用。

现在分两种情况：

①：国王自己走到集结点(i,j)，那么总路程为：sum[i][j]+max(abs(i-king.x),abs(j-king.y)),其中king.x和king.y分别为国王的初始位置的横纵坐标。

②：国王走少数几步<但不走到集结点，当然碰到某些数据最优集结点就在国王位置附近的，那是特殊情况，这里考虑的是一般情况>，然后由骑士接到集结点(i,j)，此时接国王的骑士k路径为：(a[k].x,a[k].y)→(king.x+way1,king.y+way2)→(i,j)，其中a[k].x,a[k].y为骑士k的初始位置，way1，way2为国王分别在水平和竖直方向走的位置改变量<有方向>，那么总路程为sum[i][j]-dist[a[k].x][a[k].y][i][j]+dist[a[k].x][a[k].y][king.x+way1][king.y+way2]+dist[king.x+way1][king.y+way2][i][j]+max(abs(way1),abs(way2)),其中dist[a[k].x][a[k].y][i][j]为骑士k从初始位置不接国王直接到集结点的步数，dist[a[k].x][a[k].y][king.x+way1][king.y+way2]+dist[king.x+way1][king.y+way2][i][j]为骑士k接国王并到达集结点的步数，max(abs(way1),abs(way2))为国王走的步数。

最后的答案在上述两种情况中取最小值即可。

时间复杂度分析：DFS：O(8^MAXFLOOR),求sum：O(R*C*N)<N为骑士数>,两种情况枚举求最小:O(R*C*5*5*N)-剪枝+O(R*C)，对于USACO的数据和DFS来说已经很好了。

【代码】：

/*
ID:csyzcyj1
PROG:camelot
LANG:C++
*/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define MAXR 32
#define MAXC 30
#define MAX 801
#define MAXKINGSTEP 2
#define MAXFLOOR 12//卡出来的,深搜的最深限制,调整该数可以大量减少时间<若为35→0.40s 12→0.12s>
#define IMAX 2147483//卡出来的,若是用2147483647就用long long
struct CHESS{int x,y;};
CHESS a[MAX],king;
int R,C,N=0,dist[MAXR][MAXC][MAXR][MAXC],sum[MAXR][MAXC];
int ans=IMAX;
void input()
{
int use3;
char use1,use2;
scanf("%d%d\n",&C,&R);
scanf("%c%d",&use1,&use3);
king.x=(int)use1-'A'+1;
king.y=use3;
while(cin>>use1>>use3)
{
a[++N].x=use1-'A'+1;
a
.y=use3;
}
}
void pre()
{
for(int i=0;i<MAXR;i++)
for(int j=0;j<MAXC;j++)
for(int k=0;k<MAXR;k++)
for(int l=0;l<MAXC;l++)
dist[i][j][k][l]=IMAX;
}
bool check(int x,int y)
{
if(x<1)   return false;
if(x>R)   return false;
if(y<1)   return false;
if(y>C)   return false;
return true;
}
void dfs(int X,int Y,int x,int y,int floor)
{
if(floor>MAXFLOOR)   return;
dist[X][Y][x][y]=floor;
dist[x][y][X][Y]=floor;

if(check(x+2,y+1) && floor+1<dist[X][Y][x+2][y+1])
dfs(X,Y,x+2,y+1,floor+1);
if(check(x+1,y+2) && floor+1<dist[X][Y][x+1][y+2])
dfs(X,Y,x+1,y+2,floor+1);
if(check(x-2,y+1) && floor+1<dist[X][Y][x-2][y+1])
dfs(X,Y,x-2,y+1,floor+1);
if(check(x-1,y+2) && floor+1<dist[X][Y][x-1][y+2])
dfs(X,Y,x-1,y+2,floor+1);
if(check(x+2,y-1) && floor+1<dist[X][Y][x+2][y-1])
dfs(X,Y,x+2,y-1,floor+1);
if(check(x+1,y-2) && floor+1<dist[X][Y][x+1][y-2])
dfs(X,Y,x+1,y-2,floor+1);
if(check(x-2,y-1) && floor+1<dist[X][Y][x-2][y-1])
dfs(X,Y,x-2,y-1,floor+1);
if(check(x-1,y-2) && floor+1<dist[X][Y][x-1][y-2])
dfs(X,Y,x-1,y-2,floor+1);
}
void work()
{
int tmp=0;
memset(sum,0,sizeof(sum));
for(int i=1;i<=R;i++)//每个骑士的枚举
for(int j=1;j<=C;j++)
dfs(i,j,i,j,0);

for(int i=1;i<=R;i++)
for(int j=1;j<=C;j++)
for(int k=1;k<=N;k++)
sum[i][j]+=dist[a[k].x][a[k].y][i][j];//sum[i][j]:集合点为(i,j)时骑士移动的总距离

/*骑士接国王。骑士位移:(a[k].x,a[k].y)→(king.x+way1,king.y+way2)→(i,j) */
for(int i=1;i<=R;i++)//枚举集合点位置
for(int j=1;j<=C;j++)
if(sum[i][j]-MAXKINGSTEP<ans)//弱弱的剪枝,因为王最多走两格
for(int way1=-MAXKINGSTEP;way1<=MAXKINGSTEP;way1++)//国王的水平移动
for(int way2=-MAXKINGSTEP;way2<=MAXKINGSTEP;way2++)//国王的竖直移动
for(int k=1;k<=N;k++)
if(check(king.x+way1,king.y+way2))
{
tmp=sum[i][j]-dist[a[k].x][a[k].y][i][j]+dist[a[k].x][a[k].y][king.x+way1][king.y+way2]+dist[king.x+way1][king.y+way2][i][j]+max(abs(way1),abs(way2));
ans=min(tmp,ans);
}
/*国王自己走到集合点(i,j)*/
for(int i=1;i<=R;i++)
for(int j=1;j<=C;j++)
{
tmp=sum[i][j]+max(abs(i-king.x),abs(j-king.y));
ans=min(tmp,ans);
}
}
int main()
{
freopen("camelot.in","r",stdin);
freopen("camelot.out","w",stdout);
input();
pre();
work();
printf("%d\n",ans);
//system("pause");
return 0;
}

 

 

【测评结果】：

用cena测评的结果，没加任何优化开关

USACO测评

Compiling...

Compile: OK

Executing...

Test 1: TEST OK [0.011 secs, 6984 KB]

Test 2: TEST OK [0.022 secs, 6984 KB]

Test 3: TEST OK [0.022 secs, 6984 KB]

Test 4: TEST OK [0.043 secs, 6984 KB]

Test 5: TEST OK [0.065 secs, 6984 KB]

Test 6: TEST OK [0.086 secs, 6984 KB]

Test 7: TEST OK [0.011 secs, 6984 KB]

Test 8: TEST OK [0.022 secs, 6984 KB]

Test 9: TEST OK [0.054 secs, 6984 KB]

Test 10: TEST OK [0.097 secs, 6984 KB]

Test 11: TEST OK [0.022 secs, 6984 KB]

Test 12: TEST OK [0.022 secs, 6984 KB]

Test 13: TEST OK [0.022 secs, 6984 KB]

Test 14: TEST OK [0.022 secs, 6984 KB]

Test 15: TEST OK [0.022 secs, 6984 KB]

Test 16: TEST OK [0.022 secs, 6984 KB]

Test 17: TEST OK [0.022 secs, 6984 KB]

Test 18: TEST OK [0.011 secs, 6984 KB]

Test 19: TEST OK [0.022 secs, 6984 KB]

Test 20: TEST OK [0.022 secs, 6984 KB]

All tests OK.

转载注明出处：http://blog.csdn.net/u011400953