POJ 3026 Borg Maze【BFS+最小生成树】

链接：



Borg Maze
Time Limit: 1000MS   Memory Limit: 65536K
Total Submissions: 6905   Accepted: 2315

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

Source

Svenskt Mästerskap i Programmering/Norgesmesterskapet 2001


题意：

从 S 出发，去抓每一个 A ，求最小的总路径长度
            空格是可以走的地方，# 不可以走,四周都是 #
            注意：只可以在 S 或 A 的地方分开走, 空格区域不可拆分

               

算法：最小生成树+BFS


思路：

建图转换成最小生成树，然后直接套用Prime或者Kruskal模板

   由于只可以在 S 和 A 部分分开走 , 那么对于 S 和 A 都是一样的，都把它们当成是最小生成树的点
           建图时先用 BFS 遍历 S 和每一个 A 找到它们与其他的点的最短距离，再套用模板就好了

PS：遇到一个点【S 或 A】就遍历一遍 BFS 其实如果它之前有点被bfs 过,那么会重复求了路径，浪费了时间，看着很不和谐
        不过对于这题也没什么好方法解决了Orz。。。

坑：

输入列和行后有很多空格不能用getchar()  WA了三次,看了讨论区才知道, 用 gets() 就过了

Kruskal：

3026 Accepted 352K 63MS C++ 2634B 2013-07-31 14:44:02 

#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;

const int maxn = 50+10;
const int maxp = 100+10;
int n, m;

int map[maxn][maxn]; //输入的图
int w[maxp][maxp]; //路径
int v[maxn][maxn]; // 标记是否访问
int p[maxp]; // 父亲节点

int dir[4][2] = {0,1, 1,0, 0,-1, -1,0}; // 四个方向

struct Edge{
    int u,v;
    int w;
}edge[maxp*maxp];

struct Point{
    int x,y;
    int step;
};

void bfs(int x, int y) // 遍历第 map[x][y] 个点
{
    Point point;
    point.x = x; point.y = y; point.step = 0; //自己到自己距离为 0

    queue<Point> q;
    q.push(point); //起点入队

    memset(v, 0, sizeof(v));
    v[x][y] = 1; //标记访问
    int num = 1; //已经找的点数

    while(!q.empty())
    {
        Point now = q.front(); //取队首
        q.pop(); // 出队
        Point next; //找下一个点

        for(int i = 0; i < 4; i++) // 遍历四个方向找下一个点
        {
            next.x = now.x+dir[i][0];
            next.y = now.y+dir[i][1];
            next.step = now.step+1; // 步数+1

            //如果可以走, 并且没有被访问过
            if(map[next.x][next.y] >= 0 && !v[next.x][next.y])
            {
                q.push(next); //入队
                v[next.x][next.y] = 1; // 标记被访问

                if(map[next.x][next.y] > 0) // 如果是要找的点
                {//建图
                    edge[m].u = map[x][y];
                    edge[m].v = map[next.x][next.y];
                    edge[m++].w = next.step;
                    num++;
                    if(num == n) return; //所有的点都找完了
                }
            }
        }
    }
    return;
}

bool cmp(Edge a, Edge b)
{
    return a.w < b.w;
}

int find(int x)
{
    return x == p[x] ? x : p[x] = find(p[x]);
}

int Kruskal()
{
    int ans = 0;
    for(int i = 1; i <= n; i++) p[i] = i;
    sort(edge, edge+m, cmp);

    for(int i = 0; i < m; i++)
    {
        int u = find(edge[i].u);
        int v = find(edge[i].v);

        if(u != v)
        {
            p[v] = u;
            ans += edge[i].w;
        }
    }

    return ans;
}

int main()
{
    int T;
    int row,col;
    char tmp[maxn];
    char c;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &col,&row);
        gets(tmp);//坑【一串空格】

        n = m = 0;

        for(int i = 1; i <= row; i++)
        {
            for(int j = 1; j <= col; j++)
            {
                scanf("%c", &c);
                if(c == '#') map[i][j] = -1;
                else if(c == ' ') map[i][j] = 0;
                else map[i][j] = ++n;
            }
            getchar();
        }

        for(int i = 0; i <= row; i++)
        {
            for(int j = 0; j <= col; j++)
                if(map[i][j] > 0)
                    bfs(i,j);
        }

        int ans = Kruskal();
        printf("%d
", ans);
    }
    return 0;
}



Prime：

3026 Accepted 264K 63MS C++ 2543B 2013-07-31 14:44:34 


#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>
using namespace std;

const int maxn = 50+10;
const int maxp = 110;
const int INF = maxn*maxn;
int n;

int map[maxn][maxn];
int w[maxp][maxp];
int d[maxp];
int vis[maxp];
int v[maxn][maxn];

struct Point{
    int x,y;
    int step;
};

int dir[4][2] = {0,1, 1,0, 0,-1, -1,0};

void bfs(int x, int y)
{
    Point point;
    point.x = x; point.y = y;
    point.step = 0;

    memset(v,0,sizeof(v));
    queue<Point> q;
    q.push(point);
    v[x][y] = 1;
    int num = 1;

    while(!q.empty())
    {
        Point now = q.front();
        q.pop();

        Point next;
        for(int i = 0; i < 4; i++)
        {
            next.x = now.x+dir[i][0];
            next.y = now.y+dir[i][1];

            if(map[next.x][next.y] >= 0 && !v[next.x][next.y])
            {
                next.step = now.step+1;
                v[next.x][next.y] = 1;
                q.push(next);
                if(map[next.x][next.y] > 0)
                {
                    int u = map[x][y];
                    int v = map[next.x][next.y];
                    w[u][v] = next.step;
                    num++;
                    if(num == n) return;
                }
            }
        }
    }
    return;
}

int Prime()
{
    int ans = 0;
    for(int i = 1; i <= n; i++) d[i] = INF;
    d[1] = 0;
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; i++)
    {
        int x, m = INF;
        for(int y = 1; y <= n; y++) if(!vis[y] && d[y] <= m) m = d[x=y];
        vis[x] = 1; ans += d[x];
        for(int y = 1; y <= n; y++) if(!vis[y])
            d[y] = min(d[y], w[x][y]);
    }
    return ans;
}

int main()
{
    int T;
    int row, col;
    scanf("%d", &T);
    while(T--)
    {
        n = 0;
        char c;
        scanf("%d%d", &col,&row);
        char tmp[51];
        gets(tmp);
        for(int i = 1; i <= row; i++)
        {
            for(int j = 1; j <= col; j++)
            {
                scanf("%c", &c);
                if(c == '#') map[i][j] = -1;
                else if(c == ' ') map[i][j] = 0;
                else map[i][j] = ++n;
            }
            getchar();
        }

        for(int i = 1; i <= row; i++)
        {
            for(int j = 1; j <= col; j++)
                if(map[i][j] > 0)
                    bfs(i,j);
        }

        int ans = Prime();
        printf("%d 
", ans);
    }
    return 0;
}















【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/freezhan/p/3238973.html