POJ 3026 Borg Maze (最小生成树+bfs)

最新推荐文章于 2019-10-06 08:16:52 发布

原创最新推荐文章于 2019-10-06 08:16:52 发布 · 200 阅读

0 ·

CC 4.0 BY-SA版权

BFS 同时被 2 个专栏收录

14 篇文章

订阅专栏

最小生成树

5 篇文章

订阅专栏

本文探讨了在特定条件下寻找最短路径的问题，通过将起点视为目标点之一，并利用广度优先搜索（BFS）预处理任意两点间的最短距离。文章介绍了如何通过构建最小生成树来解决路径分割问题，实现总路径长度的最小化。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意：

从S点有一伙人出发去消灭A点的敌人，在S点或者A点可以分裂成几个小队然后分别走，

这样路径=总队路径+各个小队路径问你怎样路径最短

思路：

S点可以看成是A点，用bfs预处理每两个A（包含S）的最短距离，题目中的分裂就可以看成树的分叉，把所有A点构成最小生成树，其权值和即为最短的路径。

注意：这里题目有坑，输入行和列后会有一大堆空格，要先用gets吃掉，不然会WA。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#include<iomanip>
using namespace std;
#define inf 0x3f3f3f3f
#define ll long long
const int maxn=105;
const double eps=1e-8;
const double PI = acos(-1.0);
ll gcd(ll a,ll b)
{
    return b==0?a:gcd(b,a%b);
}

struct node
{
    int x,y,step;
    node(){}
    node(int x,int y,int s):x(x),y(y),step(s){}
};
int used[maxn][maxn],n,m,b[maxn][maxn];
char g[maxn][maxn];
int gg[maxn][maxn];
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};
void bfs(int s,int xx,int yy)
{
    memset(used,0,sizeof(used));
    queue<node> q;
    q.push(node(xx,yy,0));
    used[xx][yy]=1;
    while(!q.empty())
    {
        node t=q.front();
        q.pop();
        if(g[t.x][t.y]=='A'||g[t.x][t.y]=='S')
        {
            gg[s][b[t.x][t.y]]=t.step;
        }
        for(int i=0;i<4;i++)
        {
            int x=t.x+dx[i];
            int y=t.y+dy[i];
            if(x>=0&&x<m&&y>=0&&y<n&&!used[x][y]&&g[x][y]!='#')
            {
                q.push(node(x,y,t.step+1));
                used[x][y]=1;
            }
        }
    }
}
bool vis[maxn];
int lowc[maxn];
int prim(int cost[][maxn],int n)
{
    int ans=0;
    memset(vis,false,sizeof(vis));
    memset(lowc,inf,sizeof(lowc));
    vis[0]=true;
    for(int i=1; i<n; i++)
    {
        lowc[i]=cost[0][i];
    }
    for(int i=1; i<n; i++)
    {
        int minc=inf;
        int p=-1;
        for(int j=0; j<n; j++)
        {
            if(!vis[j]&&minc>lowc[j])
            {
                minc=lowc[j];
                p=j;
            }
        }
        if(minc==inf)   return -1;
        ans+=minc;
        vis[p]=true;
        for(int j=0; j<n; j++)
        {
            if(!vis[j]&&lowc[j]>cost[p][j])
                lowc[j]=cost[p][j];
        }
    }
    return ans;
}
int main()
{
  //  std::ios::sync_with_stdio(false);
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(b,0,sizeof(b));
        memset(g,0,sizeof(g));
        for(int i=0;i<maxn;i++)
        {
            for(int j=0;j<maxn;j++)
            {
                if(i==j)    gg[i][j]=0;
                else gg[i][j]=inf;
            }
        }
        int cnt=0;
        char tmp[50];
        scanf("%d%d",&n,&m);
        gets(tmp);
        for(int i=0;i<m;i++)
        {
            gets(g[i]);
            for(int j=0;j<n;j++)
            {
                if(g[i][j]=='A'||g[i][j]=='S')
                    b[i][j]=cnt++;
            }
        }
    /*    for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                cout<<g[i][j]<<" ";
            }
            cout<<endl;
        }*/
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(g[i][j]=='A'||g[i][j]=='S')
                {
                    bfs(b[i][j],i,j);
                }
            }
        }
        cout<<prim(gg,cnt)<<endl;
    }
    return 0;
}