usaco3.3Camelot

最新推荐文章于 2022-08-16 12:12:43 发布

ahero_happy

最新推荐文章于 2022-08-16 12:12:43 发布

阅读量466

点赞数

CC 4.0 BY-SA版权

分类专栏： usaco 文章标签： struct 编程 im c

本文链接：https://blog.youkuaiyun.com/ahero_happy/article/details/6588700

usaco 专栏收录该内容

6 篇文章

订阅专栏

本文详细阐述了解决马和国王在棋盘上汇合问题的算法，通过广度优先搜索（BFS）和动态规划，考虑国王骑马的额外步骤，寻找最短路径使得所有马和国王汇聚于同一格子。该算法巧妙地结合了多个步骤，确保了解决方案的高效性和准确性。

题意：现在有一些马和一个国王，马走“日”字，国王可以走向邻近的八个位置，如果国王和马在同一个格子里，国王可以选择骑上马，跟马一起走。现求总的最少步数（国王骑在马上时，走一步只算做一步）使的所有马和国王汇合在一个格子中。

分析：如果没有国王的话，那么就枚举汇合的格子，所有的马跳到那格子的步数和最小的即为所求。现在有国王，就要分析国王是怎么走了，直接走方便求算，广搜一下就可以了，但那样一般不是最优解，因为它如果中途或一开始骑到马上则它的步数就会变小。所以对于国王，广搜的同时，假设这个位置是国王骑上一匹马的位置时，国王另外加的步数会不会变少。实际编程时，先将任意两个位置马需要走的步数求出来，然后枚举汇合的格子，所有马的步数和加上国王外加的步数的最小值即为最终值。

/*
ID:kgdpgfy1
LANG:C++
PROG:camelot
*/
#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;

struct point 
{
	int x,y;
}p[800];
int n,m,num,g[800][800],x,y;
bool flag[800];
int next[8][2]={{-2,-1},{-2,1},{-1,-2},{-1,2},{1,-2},{1,2},{2,-1},{2,1}};
int nx[8][2]={{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};

struct p
{
	int x,y,step;
}q[810];
bool IN(int x,int y)//判断是否仍在格中
{
	if(x>=0&&x<m&&y>=0&&y<n) return true;
	return false;
}
void BFS(int xx,int yy)
{
	int x0=xx,y0=yy,x1,y1,i,s,head=0,tail=0;
	s=x0*n+y0;
	g[s][s]=0;
	q[tail].x=x0;
	q[tail].y=y0;
	q[tail++].step=0;

	while(head!=tail)
	{
		x0=q[head].x;
		y0=q[head].y;
		for(i=0;i<8;i++)
		{
			x1=x0+next[i][0];
			y1=y0+next[i][1];
			if(IN(x1,y1)&&g[s][x1*n+y1]==-1)
			{
				g[x1*n+y1][s]=g[s][x1*n+y1]=q[head].step+1;
				q[tail].x=x1,q[tail].y=y1;
				q[tail].step=q[head].step+1;
				tail++;
			}
		}
		head++;
	}
}
int main()
{
	freopen("camelot.in","r",stdin);
	freopen("camelot.out","w+",stdout);
	int i,j,k,sum,king,r,head,tail,mins;
	char ch;
	while(scanf("%d%d",&m,&n)!=EOF)
	{
		getchar();
		scanf("%c %d",&ch,&x);
		x--;
		y=ch-'A';
		king=x*n+y;
		num=0;
		ch=getchar();
		while(ch=getchar())
		{
			if(ch==EOF) break;
			while(!(ch>='A'&&ch<='Z'))
				ch=getchar();
			p[num].y=ch-'A';
			scanf("%d",&p[num].x);
			p[num].x--;
			getchar();
			num++;
		}

		memset(g,-1,sizeof(g));
		for(i=0;i<m;i++)//求任意两格马所需的最少步数
			for(j=0;j<n;j++)
				BFS(i,j);

		sum=1110000;
		for(i=0;i<m*n;i++)//枚举集合的格子
		{
			memset(flag,false,sizeof(flag));
			mins=1100,head=tail=0;
			if(king==i) mins=0;//开始少了这。只有一个结点时，就错了
			q[tail].x=x,q[tail].y=y,q[tail++].step=0;
			while(head!=tail)//广搜的同时算国王骑在马上另加的步数
			{
				if(q[head].step>=mins) break;

				r=q[head].x*n+q[head].y;
				for(k=0;k<num;k++)
				{
					j=p[k].x*n+p[k].y;
					if(g[i][r]!=-1&&g[r][j]!=-1&&g[i][j]!=-1&&g[i][r]+g[r][j]+q[head].step-g[i][j]<mins)
						mins=g[i][r]+g[r][j]+q[head].step-g[i][j];
				}
				for(j=0;j<8;j++)
				{
					q[tail].x=q[head].x+nx[j][0];
					q[tail].y=q[head].y+nx[j][1];
					if(IN(q[tail].x,q[tail].y)&&!flag[q[tail].x*n+q[tail].y])
					{
						flag[q[tail].x*n+q[tail].y]=true;
						q[tail].step=q[head].step+1;
						tail++;
					}
				}
				head++;
			}

			for(k=0;k<num;k++)//算所有马步数
			{
				j=p[k].x*n+p[k].y;
				if(g[i][j]==-1)
					break;
				else
				    mins+=g[i][j];
			}
			if(k>=num&&mins<sum) sum=mins;
		}
		printf("%d\n",sum);
	}
	return 0;
}