POJ-3026 BFS+Prim

Borg Maze

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 17004		Accepted: 5490

Description

The Borg is an immensely powerful race of enhanced humanoids from the delta quadrant of the galaxy. The Borg collective is the term used to describe the group consciousness of the Borg civilization. Each Borg individual is linked to the collective by a sophisticated subspace network that insures each member is given constant supervision and guidance. 

Your task is to help the Borg (yes, really) by developing a program which helps the Borg to estimate the minimal cost of scanning a maze for the assimilation of aliens hiding in the maze, by moving in north, west, east, and south steps. The tricky thing is that the beginning of the search is conducted by a large group of over 100 individuals. Whenever an alien is assimilated, or at the beginning of the search, the group may split in two or more groups (but their consciousness is still collective.). The cost of searching a maze is definied as the total distance covered by all the groups involved in the search together. That is, if the original group walks five steps, then splits into two groups each walking three steps, the total distance is 11=5+3+3.

Input

On the first line of input there is one integer, N <= 50, giving the number of test cases in the input. Each test case starts with a line containg two integers x, y such that 1 <= x,y <= 50. After this, y lines follow, each which x characters. For each character, a space `` '' stands for an open space, a hash mark ``#'' stands for an obstructing wall, the capital letter ``A'' stand for an alien, and the capital letter ``S'' stands for the start of the search. The perimeter of the maze is always closed, i.e., there is no way to get out from the coordinate of the ``S''. At most 100 aliens are present in the maze, and everyone is reachable.

Output

For every test case, output one line containing the minimal cost of a succesful search of the maze leaving no aliens alive.

Sample Input

2
6 5
##### 
#A#A##
# # A#
#S  ##
##### 
7 7
#####  
#AAA###
#    A#
# S ###
#     #
#AAA###
#####  

Sample Output

8
11

题意：说是什么外星人来侵略，S表示母体，A表示要侵略的生命体， # 表示墙，外星人在母体或者侵略到生命体的时候可以选择分裂，可以向周围四个方向走，其他时候都不能分裂的（这是一个坑），问：要侵略完所有生命体最短距离是多少

思路：先用BFS暴力，就是假如A（包括S）全是母体，这样扩散出去到其他A点的最短距离，这样就构建好了一棵树，然后用Prim算法一波就可以了。可以把这个图转换成 int 型的，把A和S点换成数字，这样好多了

比方说样例第二个，母体先向上走，遇到了（1,3）那个A点，然后扩散左右两个，右边那个向下走再向右走，又是一个生命体，S点下面的也差不多，这样算一下向上2+1+1+3+2+1+1（因为侵略到了生命体可以分裂，所有到了中间那个的时候再侵略两边各需要 1 的值就可以了）=11

坑点：这题坑点很多的，首先是题意的那个坑，然后是样例表面的坑（第一个样例第一行后面还有一空格记得吸收），最后的坑就是，样例可以这样输入

6 5             //这里可以有很多空格，记得吸收掉，这里wa了一发，看了discuss才知道的
##### 
#A#A##
# # A#
#S  ##
##### 

AC代码：

#include <cstdio> #include <iostream> #include <cstring> #include <algorithm> #include <queue> using namespace std; const int maxn=550; const int INF=0x7f7f7f7f; char map[maxn][maxn]; int Map[maxn][maxn]; int num[maxn][maxn],n,m,node,dir[4][2]={0,1,0,-1,1,0,-1,0}; int dis[maxn]; bool vis_p[maxn],vis_b[maxn][maxn]; struct Node { int x,y; int t; int last; }; bool judge(int x,int y) { if (x<=0||x>m||y<=0||y>n||Map[x][y]==-1||vis_b[x][y]==true) return true; return false; } void bfs(int x,int y) { int i,j; Node now,end; memset(vis_b,false,sizeof(vis_b)); now.x=x;now.y=y;now.t=0;now.last=Map[x][y]; vis_b[x][y]=true; queue<Node> q; while (!q.empty()) q.pop(); q.push(now); while (q.size()) { now=q.front(); q.pop(); for (i=0;i<4;i++) { end.x=now.x+dir[i][0]; end.y=now.y+dir[i][1]; if (judge(end.x,end.y)==true) continue; end.t=now.t+1; end.last=now.last; // cout<<end.t<<" "<<end.last<<endl; if (Map[end.x][end.y]>=1) { num[end.last][Map[end.x][end.y]]=min(num[end.last][Map[end.x][end.y]],end.t); //因为可能之前存在这两个点就有值，选最小，而且还是双向的 num[map[end.x][end.y]][end.last]=num[end.last][Map[end.x][end.y]]; end.t=0; end.last=Map[end.x][end.y]; } q.push(end); vis_b[end.x][end.y]=true; } } return ; } int prim(int x,int q) { memset(vis_p,false,sizeof(vis_p)); int i,j,ans,Min,flag; for (i=1;i<=q;i++) dis[i]=num[x][i]; dis[x]=0;vis_p[x]=true; for (i=1;i<=q;i++) { Min=INF;flag=0; for (j=1;j<=q;j++) if (vis_p[j]==true) continue; else if (Min>dis[j]) { Min=dis[j]; flag=j; } // cout<<Min<<" "<<flag<<endl; if (Min==INF) break; vis_p[flag]=true; for (j=1;j<=q;j++) if (vis_p[j]==true) continue; else dis[j]=min(dis[j],num[flag][j]); } ans=0; for (i=1;i<=q;i++) ans=ans+dis[i]; return ans; } int main() { int t,i,j; char ch; int nx,ny,ans; cin>>t; while (t--) { cin>>n>>m; node=2; //母体是1,其他生命体从2开始 while (1) //最大的坑点 { scanf("%c",&ch); if (ch=='\n') break; } for (i=1;i<=m;i++) //把图换成数字 { for (j=1;j<=n;j++) { scanf("%c",&ch); if (ch=='S') Map[i][j]=1; else if (ch=='A') Map[i][j]=node++; //这里记录多少个生命体 else if (ch=='#') Map[i][j]=-1; else Map[i][j]=0; } getchar(); } for (i=1;i<node;i++) for (j=1;j<node;j++) if (i==j) num[i][j]=0; else num[i][j]=INF; for (i=1;i<=m;i++) for (j=1;j<=n;j++) if (Map[i][j]>0) //遍历所有，找出 A 点与 A 点之间的最短距离 bfs(i,j); // output(); ans=prim(1,node-1); //Prim一波 cout<<ans<<endl; } return 0; }