【Hrbust】 The Smallest Oil Tank (Kruskal算法)

最新推荐文章于 2024-07-13 23:39:28 发布

zhan723284893

最新推荐文章于 2024-07-13 23:39:28 发布

阅读量558

点赞数

分类专栏：图论_Kruskal 文章标签：图论

本文链接：https://blog.csdn.net/zhan723284893/article/details/40979085

版权

图论_Kruskal 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

D.The Smallest Oil Tank

Time Limit: 10000 MS

Memory Limit: 65536 K

Total Submit: 136 (24 users)

Total Accepted: 23 (18 users)

Special Judge: No

Description

That’s great ! LPJ get married! He will take his wife on a honeymoon by driving. Now, he want to leave from home to Moscow. But his oil tank is limited and he doesn’t have enough oil to Moscow. Luckily,there are many gas stations.
There are n gas stations numbered from 0 to n-1. The 0 station is LPJ’s home and n-1 station is Moscow.  He knows the oil used from one gas station to another.  He can fill the tank at every gas station.
But the problem is coming. He want to take a car with the smallest oil tank.Please help LPJ get the smallest oil tank.

Input

There are multiple test cases.
Each test case contains two postive integers (n,m) separated by a space in one line. The n is the number of gas station.
The next m line ,each line contains three postive integers (u,v,w). It means that there is one road between u and v gas station using w Liter.
   There are at least one road from 0 to n-1 gas station.
The input will be terminated by the end of input file.
2<=n<=4,000
1<=m<=10,000,000
1<=w<=10,000,000

Output

For each test case ,output the smallest oil tank.

Sample Input

Sample Output

Author

 ACgege

纯粹的Kruskal算法。

边的数量为10^7，用struct存边时，两个顶点的类型要是用int会爆内存，如下：

struct edge
{
    int x,y;//会爆内存
    int dis;
};

之后自己也没想到什么好的方法，后来请教师兄才知道可以把int改为short，这样就不会爆内存了：

struct edge
{
    short x,y;
    int dis;
};

代码：

#include<stdio.h>
#include<limits.h>
#include<algorithm>
#include<math.h>
#define N 4010
#define M 10000010
using namespace std;

struct edge
{
    short x,y;
    int dis;
};

short fa[N];
edge c2[M];
short find(short x)
{
    if(x!=fa[x])
        fa[x]=find(fa[x]);
    return fa[x];
}
void merge(short x,short y)
{
    fa[find(x)]=find(y);
}

bool cmp(edge p1,edge p2)
{
    return (p1.dis<p2.dis);
}


int main()
{
    int n,m,i,j,u,v,w;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(i=0;i<n;++i)
            fa[i]=i;

        for(i=0;i<m;++i)
        {
            scanf("%d%d%d",&u,&v,&w);
            c2[i].dis=w;
            c2[i].x=u;
            c2[i].y=v;
        }
        sort(c2,c2+m,cmp);
        for(i=0;i<m;++i)
        {
            if(c2[i].x==c2[i].y)
                continue;

            merge(c2[i].x,c2[i].y);
            if(find(0)==find(n-1))
            {

                 printf("%d\n",c2[i].dis);
                 break;
            }
        }

    }
    return 0;
}

官方题解给的是一个O(n^2)的算法，但是我没看太明白转移过程，先把代码贴上来吧：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define N 4000
#define inf 100000000

int dis[N][N];

int d[N];
bool vis[N];

int main()
{
//    freopen("d.in","r",stdin);
//    freopen("d.out","w",stdout);
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF)
    {

        for(int i=0;i<n;i++)
        for(int j=i;j<n;j++)
            dis[i][j]=dis[j][i]=inf;

        for(int i=0;i<m;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            dis[a][b]=dis[b][a]=min(dis[a][b],c);
        }

       for(int i=0;i<n;i++) d[i]=inf,vis[i]=0;
       d[0]=0;


       for(int i=0;i<n;i++)
       {
           int minn=inf;
           int v=-1;
           for(int j=0;j<n;j++)
             if(!vis[j] && minn>d[j])
           {
               minn=d[j];
               v=j;
           }
         if(v==-1 || v== n-1) break;
         vis[v]=1;

             for(int j=0;j<n;j++)
                  if(!vis[j] && max(d[v],dis[v][j]) < d[j])
                     d[j]=max(d[v],dis[v][j]);
       }

      printf("%d\n",d[n-1]);
    }
    return 0;
}