搜索解炸弹人

 玩过炸弹人的游戏吗？

 是用放置炸弹的方法来消灭敌人，要把画面上的敌人全部消灭，然后找到暗门才能通关。

【题目描述】

有一个关卡是这样的，你只有一枚炸弹，但是这枚炸弹的很大（可以消灭掉横竖方向上所有的敌人）。请问走到哪个空地，把炸弹放在这，可以消灭最多的敌人呢？

现在将地图上的墙用‘#’表示（炸弹是不能穿墙的），敌人用‘G’表示，空地用‘ . ’表示，当然，炸弹只能放在空地上。

【输入】

第一行输入四个整数，分别为n（迷宫的列），m（迷宫的行），startx（纵），starty（横）（起始位置坐标）。

接下来的n行m列是由‘#’，‘G’，‘  . ’组成的地图。

【输出】

炸弹放在哪个点可以消灭最多的敌人，消灭的敌人数量是多少。

样例输入

13 13 3 3
#############
#GG.GGG#GGG.#
###.#G#G#G#G#
#.......#..G#
#G#.###.#G#G#
#GG.GGG.#.GG#
#G#.#G#.#.#.#
##G...G.....#
#G#.#G###.#G#
#...G#GGG.GG#
#G#.#G#G#.#G#
#GG.GGG#G.GG#
#############

样例输出

(7,11)

10

对于这个题，我们可以先尝试下枚举，把所有空地的情况都统计一遍，找出可以消灭敌人最多的那块空地，理论上是可以的，当然到后面我们会发现不对劲，接下来先试试枚举炸弹人。

枚举

代码如下：

#include<stdio.h>
int main()
{
	int i,j,startx,starty,n,m,q,p,sum,max=0;
	char a[30][30];
	scanf("%d %d %d %d",&n,&m,&startx,&starty);
	//读入n行字符串 
	for(i=0;i<n;i++)
	{
		scanf("%s",a[i]);
	}
	for(i=0;i<n;i++)
	{
		for(j=0;j<m;j++)
		{
			sum=0;
			//sum用来计数（记消灭敌人的数目）
			//每一轮循环都要初始化为0 
			if(a[i][j]=='.')
			{
				int x=i,y=j;
				while(a[x][y]!='#')
				{
					if(a[x][y]=='G')
					    sum++;
					x++;
					//一步步向下遍历 
				}
				x=i,y=j;
				while(a[x][y]!='#')
				{
					if(a[x][y]=='G')
					    sum++;
					y++;
					//一步步向左遍历 
				}
				x=i,y=j;
				while(a[x][y]!='#')
				{
					if(a[x][y]=='G')
					    sum++;
					x--;
					//一步步向上遍历 
				}
				x=i,y=j;
				while(a[x][y]!='#')
				{
					if(a[x][y]=='G')
					    sum++;
					y--;
					//一步步向右遍历 
				}
				if(sum>max)
				//当(i,j)点可以消灭的敌人大于先前点消灭的最大敌人数时
				//将消灭敌人数，纵坐标(i)，横坐标(j)记录下来 
				{
					max=sum;
					q=i;
					p=j;
				}
			}
		}
	}
	printf("(%d,%d)\n%d",q,p,max);
	return 0;
} 

这个方法用样例输出的结果为：

（1,11）

11

这个似乎没有错误，可以数一数（1,11）处可以消灭的敌人数，的确也是11个，但是样例输出却是：

（7,11）

10

点（1,11）处甚至比样例输出的点（7,11）消灭敌人数还多，这是因为小人从（3,3）出发，是走不到（1,11）这点的。

                            

---

 那么我们可以尝试搜索的方法！

深度搜索

解题思路：

搜索的这种方法跟枚举不同，枚举是把所有空地（' . '）上消灭的敌人进行比较，没有考虑是否可以由起点出发，然后到达该点。

先计算出起点处可以消灭的敌人数，在从该点尝试其他的可以到达的点，如果该点消灭的敌人数，比先前可以消灭的最大消灭敌人数还要多，就把该点和消灭敌人数记录下来。

代码如下：

#include<stdio.h>
int book[30][30];
char a[30][30];
int q,p,n,m,max;
int fun(int x,int y)
//该函数是计算一个点消灭的敌人数
{
	int i,j,sum=0;
	//记得要在计算每个点可以消灭的敌人数之前，把sum初始化为0 
	i=x,j=y;
	//计算一个点向下，向上，向左，向右可以消灭的敌人数 
	while(a[i][j]!='#')
	{
		if(a[i][j]=='G')
		sum++;
		i++;
	}
	i=x,j=y;
	//换方向遍历时，要把i，j重新赋值 
	while(a[i][j]!='#')
	{
		if(a[i][j]=='G')
		sum++;
		i--;
	}
	i=x,j=y;
	while(a[i][j]!='#')
	{
		if(a[i][j]=='G')
		sum++;
		j++;
	}
	i=x,j=y;
	while(a[i][j]!='#')
	{
		if(a[i][j]=='G')
		sum++;
		j--;
	}
	return sum;
}
void dfs(int x,int y)
//深度搜索遍历起点可以走过的每一块空地
//防止出现枚举出现的情况 
{
	int i,tx,ty,sum;
	sum=fun(x,y);
	int next[4][2]={0,1,0,-1,1,0,-1,0};
	if(sum>max)
	{
		max=sum;
		q=x;
		p=y;
	}
	for(i=0;i<4;i++)
	{
		tx=x+next[i][0];
		ty=y+next[i][1];
		if(tx>n-1||tx<0||ty>m-1||ty<0)
		continue;
		if(book[tx][ty]==0&&a[tx][ty]=='.')
		{
			book[tx][ty]=1;
			dfs(tx,ty);
			//此处book[tx][ty]不需要归零
			//因为计算过这个空地消灭的敌人数之后，就不用继续计算了 
		}
	}
	return ;
}
int main()
{
	int i,startx,starty;
	scanf("%d %d %d %d",&n,&m,&startx,&starty);
	for(i=0;i<n;i++)
	{
		scanf("%s",a[i]);
	}
	book[startx][starty]=0;
	max=fun(startx,starty); 
	q=startx;
	p=starty;
	//先将起点处的坐标和消灭敌人数记录下来
	//考虑起点处就是要求的消灭最大敌人数那个点 
	dfs(startx,starty);
	printf("(%d,%d)\n%d\n",q,p,max);
	return 0;
}

---

也可以尝试广度搜索。

广度搜索

解题思路：

首先队列初始化，起点向上下左右，最多可以扩展出四个点，然后将扩展出的点入队，然后分别计算出每个点消灭敌人的个数，然后对头指针自加，接着对下一个点扩展……直至扩展到每一个从起点出发可以到达的点，同时记录该点和消灭敌人数。

#include<stdio.h>
char a[30][30];
struct node//定义一个结构体 
{
	int x;
	int y;
};
int fun(int x,int y)
//计算一个点可以消灭的敌人数 
{
	int sum=0,i,j;
	//记得要在计算每个点可以消灭的敌人数之前，把sum初始化为0  
	i=x,j=y;
	//计算一个点向下，向上，向左，向右可以消灭的敌人数 
	while(a[i][j]!='#')
	{
		if(a[i][j]=='G')
		sum++;
		i++;
	}
	i=x,j=y;
	while(a[i][j]!='#')
	{
		if(a[i][j]=='G')
		sum++;
		i--;
	}
	i=x,j=y;
	while(a[i][j]!='#')
	{
		if(a[i][j]=='G')
		sum++;
		j++;
	}
	i=x,j=y;
	while(a[i][j]!='#')
	{
		if(a[i][j]=='G')
		sum++;
		j--;
	}
	return sum;
}
int main()
{
	struct node k[901];
	int book[30][30]={0};
	int next[4][2]={0,1,0,-1,1,0,-1,0};
	int tx,ty,n,m,i,j,q,p,startx,starty,sum,max;
	scanf("%d %d %d %d",&n,&m,&startx,&starty); 
	for(i=0;i<n;i++)
	{
		scanf("%s",a[i]);
	}
	int head=1,tail=1;
	//队列初始化 
	book[startx][starty]=1;
	max=fun(startx,starty);
	k[tail].x=startx;
	k[tail].y=starty;
	tail++;
	max=0;
	while(head<tail)
	{
		for(i=0;i<4;i++)
		{
			tx=k[head].x+next[i][0];
			ty=k[head].y+next[i][1];
			if(tx<0||tx>n||ty>m||ty<0)//判断是否越界 
			continue;
			if(a[tx][ty]=='.'&&book[tx][ty]==0)
			{
				book[tx][ty]=1;
				//每个点只需要入队一次，后面不必再归零 
				sum=fun(tx,ty);
				if(sum>max)
				{
					max=sum;
					q=tx;
					p=ty;
				}
				k[tail].x=tx;
				k[tail].y=ty;
				tail++;
			}
		}
		head++;
		//当一个点判断完后，要head++才能对后面的点继续判断，否则循环不会结束 
    }
    printf("(%d,%d)\n%d\n",q,p,max);
	return 0;
}