POJ3026-Borg Maze

转载请注明出处：優YoU   http://user.qzone.qq.com/289065406/blog/1299324104

 

提示：BFS+Prim

大致题意：

在一个y行 x列的迷宫中，有可行走的通路空格’ ‘，不可行走的墙’#’，还有两种英文字母A和S，现在从S出发，要求用最短的路径L连接所有字母，输出这条路径L的总长度。

 

一格的长度为1，而且移动的方法只有上、下、左、右，

所以在无任何墙的情况下（但“墙#”是必须考虑的，这里只是为了说明）

任意两个字母之间的距离就是直接把 横坐标之差 加上 纵坐标之差

注意的是，可行的路为 字母 和 空格

          不可行的路为 # 和 矩阵范围之外

 

根据题意的“分离”规则，重复走过的路不再计算

因此当使用prim算法求L的长度时，根据算法的特征恰好不用考虑这个问题（源点合并很好地解决了这个问题），L就是最少生成树的总权值W

 

由于使用prim算法求在最小生成树，因此无论哪个点做起点都是一样的，（通常选取第一个点），因此起点不是S也没有关系

所以所有的A和S都可以一视同仁，看成一模一样的顶点就可以了

 

最后要注意的就是 字符的输入

cin不读入空字符（包括 空格，换行等）

gets读入空格，但不读入换行符）

 

剩下的问题关键就是处理 任意两字母间的最短距离，由于存在了“墙#” ，这个距离不可能单纯地利用坐标加减去计算，必须额外考虑，推荐用BFS（广搜、宽搜），这是本题的唯一难点，因为prim根本直接套用就可以了

 

求 任意两字母间的最短距离 时不能直接用BFS求，

1、必须先把矩阵中每一个允许通行的格看做一个结点（就是在矩阵内所有非#的格都作为图M的一个顶点），对每一个结点i，分别用BFS求出它到其他所有结点的权值（包括其本身，为0），构造结点图M；

2、然后再加一个判断条件，从图M中抽取以字母为顶点的图，进而构造字母图N

这个判定条件就是当结点图M中的某点j为字母时，把i到j的权值再复制（不是抽离）出来，记录到字母图N的邻接矩阵中

3、剩下的就是对字母图N求最小生成树了

 

 

  1 /*BFS+Prim*/
  2 
  3 //Memory Time 
  4 //368K   0MS 
  5 
  6 #include<iostream>
  7 #include<string>
  8 using namespace std;
  9 
 10 const int inf=2501;      //无限大,最大迷宫的总长也就2500
 11 
 12 char map[51][51];  //迷宫原图
 13 int node[51][51];   //记录当前格是否为字母，是第几个字母
 14 int col,row;      //当前迷宫的行列数
 15 int num;         //字母顶点数数目
 16 int dist[102][102];      //构造结点图的两结点间权值，理论结点数最多为2500个（每一个允许通行的格为一个结点）
 17                          //但是POJ的数据库允许压缩到101个，哈哈，这样时间和空间复杂度都减少很多
 18 int edge[102][102];      //构造字母图的两个字母间的边权，字母数最多为101
 19 
 20 class move
 21 {
 22  public:
 23     int row,col;
 24 }mov[4]={{0,-1},{0,1},{-1,0},{1,0}}; //分别对应 上 下 左 右
 25 
 26 void bfs(int i,int j)
 27 {
 28     bool vist[51][51];  //标记当前迷宫某一格是否已被访问
 29     int que_x[2500],que_y[2500];  //坐标队列
 30     int head=0,tail=0;  //队列指针
 31 
 32     /*Initial*/
 33 
 34     memset(dist,0,sizeof(dist));
 35     memset(vist,false,sizeof(vist));
 36     vist[i][j]=true;
 37     que_x[tail]=i;
 38     que_y[tail++]=j;
 39 
 40     while(head<tail)
 41     {
 42         int x=que_x[head];
 43         int y=que_y[head++];
 44         if(node[x][y])
 45             edge[ node[i][j] ][ node[x][y] ] = dist[x][y];   //抽取字母到字母的边权
 46         for(int k=0;k<4;k++)
 47         {
 48             int mx=x+mov[k].row;
 49             int my=y+mov[k].col;
 50             if(mx>=1 && mx<= row && my>=1 && my<=col)
 51                 if(!vist[mx][my] && map[mx][my]!='#')
 52                 {
 53                     que_x[tail]=mx;
 54                     que_y[tail++]=my;
 55                     vist[mx][my]=true;
 56                     dist[mx][my]=dist[x][y]+1;
 57                 }
 58         }
 59     }
 60     return;
 61 }
 62 
 63 int prim(void)
 64 {
 65     int s=1;
 66     int m=1;
 67     bool u[102];
 68     u[s]=true;
 69 
 70     int min_w;
 71     int prim_w=0;
 72     int point;
 73     int low_dis[102];
 74 
 75     for(int i=1;i<=num;i++)
 76     {
 77         low_dis[i]=inf;
 78         u[i]=false;
 79     }
 80 
 81     while(true)
 82     {
 83         if(m==num)
 84             break;
 85 
 86         min_w=inf;
 87         for(int i=2;i<=num;i++)
 88         {
 89             if(!u[i] && low_dis[i]>edge[s][i])
 90                 low_dis[i] = edge[s][i];
 91             if(!u[i] && min_w>low_dis[i])
 92             {
 93                 min_w=low_dis[i];
 94                 point=i;
 95             }
 96         }
 97         s=point;
 98         u[s]=true;
 99         prim_w+=min_w;
100         m++;
101     }
102     return prim_w;
103 }
104 
105 int main(int i,int j)
106 {
107     int test;
108     cin>>test;
109     while(test--)
110     {
111         /*Initial*/
112 
113         memset(node,0,sizeof(node));
114         num=0;
115 
116         /*Input*/
117 
118         cin>>col>>row;
119         char temp[51];
120         gets(temp);  //吃掉cin遗留下来的换行符,我不知道为什么getchar()会AW
121         for(i=1;i<=row;i++)
122         {
123             gets(map[i]);
124             for(j=1;j<=col;j++)
125                 if(map[i][j]=='A'||map[i][j]=='S')
126                     node[i][j]=++num;
127         }
128 
129         /*BFS-> Structure Maps*/
130 
131         for(i=1;i<=row;i++)
132             for(j=1;j<=col;j++)
133                 if(node[i][j])
134                     bfs(i,j);   //构造结点i,j到其他所有结点的边权（非#的格子就是一个结点）
135 
136         /*Prim Algorithm & Output*/
137 
138         cout<<prim()<<endl;
139     }
140     return 0;
141 }