csp20170304地铁修建_Solution

ccf20170304地铁修建_Solution

这里最短路为所以从点1到点n的路径中最长的道路的长度。

因为1 ≤ n ≤ 100000，1 ≤ m ≤ 200000，属于稀疏图，所以使用Spfa(循环队列)较适合，如果使用dijkstra需要堆优化。

其实这道题用并查集最好，对所有道路长度从小到大排序，依次添加道路，直到点1和点n相连(属于同一个集合)。

1.并查集

 #include <stdio.h>
 #include <stdlib.h>
 #define maxn 100000
 #define maxm 200000

 //并查集 UnionFind
 //171s

 struct node
 {
     long x,y,len;
 };

 long father[maxn+];

 long cmp(const void *a,const void *b)
 {
     return (*(struct node *)a).len-(*(struct node *)b).len;
 }

 long getfather(long d)
 {
     if (father[d]==d)
         return d;
     father[d]=getfather(father[d]);
     return father[d];
 }

 int main()
 {
     long n,m,i,u,v;
     struct node *road=(struct node *) malloc (sizeof(struct node)*(maxm+));
     scanf("%ld%ld",&n,&m);
     for (i=;i<=m;i++)
         scanf("%ld%ld%ld",&road[i].x,&road[i].y,&road[i].len);
     qsort(&road[],m,sizeof(struct node),cmp);
     for (i=;i<=n;i++)
         father[i]=i;
     //边从小到大 加入图中，直到1到n可达
     //每次加边(x,y) father[y]=x
     for (i=;i<=m;i++)
     {
         u=getfather(road[i].x);
         v=getfather(road[i].y);
         father[v]=u;

         //每一次判断1,n的父亲是否相同，如果是，即1到n可达
         if (getfather(father[])==getfather(father[n]))
             break;
     }
     //即1到n必经过该边i，而该边长度最长
     printf("%ld\n",road[i].len);
     return ;
 }

2.Spfa(循环队列)

 #include <stdio.h>
 #include <stdlib.h>
 #include <malloc.h>
 #include <stdbool.h>
 #define maxn 100000
 #define maxm 200000
 #define maxc 1000000

 long max(long a,long b)
 {
     if (a>b)
         return a;
     else
         return b;
 }

 int main()
 {
     struct node
     {
         long d,len;
         struct node *next;
     };
     long n,m,head,tail,d,value,i,a,b,c;
     long *dis=(long *) malloc (sizeof(long)*(maxn+));
     //循环队列
     long *line=(long *) malloc (sizeof(long)*(maxn+));
     bool *vis=(bool *) malloc (sizeof(bool)*(maxn+));
     //本身已经是struct node *point，创建数组再加"*"
     struct node **point=(struct node **) malloc (sizeof(struct node *)*(maxn+));
     struct node *t;
     scanf("%ld%ld",&n,&m);

     for (i=;i<=n;i++)
     {
         point[i]=NULL;
         //1 ≤ c ≤ 1000000
         //max<=c
         dis[i]=maxc;
         vis[i]=true;
     }
     for (i=;i<=m;i++)
     {
         scanf("%ld%ld%ld",&a,&b,&c);
         //build a
         t=(struct node *) malloc (sizeof(struct node));
         t->d=b;
         t->len=c;
         if (point[a]!=NULL)
             t->next=point[a];
         else
             t->next=NULL;
         point[a]=t;
         //build b
         t=(struct node *) malloc (sizeof(struct node));
         t->d=a;
         t->len=c;
         if (point[b]!=NULL)
             t->next=point[b];
         else
             t->next=NULL;
         point[b]=t;
     }
     dis[]=;
     vis[]=false;
     line[]=;
     //head=front-1 牺牲一个位置 front为队列头位置
     head=;
     tail=;
     //这里的循环队列不用判断空或者溢出
     //因为如果那样的话，已经不能用了。
     //不存在空的情况。而数组要开的足够大，使队列不溢出。
     while (head!=tail)
     {
         //head++;
         //队列为0~n
         head++;
         if (head==n+)
             head=;
         d=line[head];
         t=point[d];
         while (t)
         {
             if (dis[d]<t->len)
                 value=t->len;
             else
                 value=dis[d];
             if (value<dis[t->d])
             {
                 dis[t->d]=value;
                 //如果该点未被放在队列里，则入队；否则不入队
                 //即在队列里的点都不重复
                 //则队列(tail-head)最多有n+1个数(n个点+空位置(head))
                 if (vis[t->d])
                 {
                     //tail++;
                     tail++;
                     if (tail==n+)
                         tail=;
                     line[tail]=t->d;
                     vis[t->d]=false;
                 }
             }
             t=t->next;
         }
         vis[d]=true;
     }
     printf("%ld\n",dis[n]);
     return ;
 }

3.dijkstra(80 Points)

 #include <stdio.h>
 #include <stdlib.h>
 #include <malloc.h>
 #include <stdbool.h>
 #define maxn 100000
 #define maxm 200000
 #define maxc 1000000
 #define maxdist 1000000000

 //裸dijkstra 80分 超时

 long max(long a,long b)
 {
     if (a>b)
         return a;
     else
         return b;
 }

 int main()
 {
     struct node
     {
         long d,len;
         struct node *next;
     };
     struct node **point=(struct node **) malloc (sizeof(struct node *)*(maxn+));
     struct node *p;
     bool *vis=(bool *) malloc (sizeof(bool)*(maxn+));
     long *dist=(long *) malloc (sizeof(long)*(maxn+));
     long n,m,i,j,a,b,c,d,value,mindist;
     scanf("%ld%ld",&n,&m);
     for (i=;i<=n;i++)
     {
         point[i]=NULL;
         dist[i]=maxc;
         vis[i]=true;
     }
     for (i=;i<=m;i++)
     {
         scanf("%ld%ld%ld",&a,&b,&c);
         //build a
         p=(struct node *) malloc (sizeof(struct node));
         p->d=b;
         p->len=c;
         if (point[a]!=NULL)
             p->next=point[a];
         else
             p->next=NULL;
         point[a]=p;
         //build b
         p=(struct node *) malloc (sizeof(struct node));
         p->d=a;
         p->len=c;
         if (point[b]!=NULL)
             p->next=point[b];
         else
             p->next=NULL;
         point[b]=p;
     }
     for (i=;i<=n;i++)
     {
         vis[i]=true;
         dist[i]=maxdist;
     }
     //从点1开始
     dist[]=;
     d=;
     vis[]=false;
     for (i=;i<n;i++)
     {
         p=point[d];
         while (p)
         {
             if (dist[d]<p->len)
                 value=p->len;
             else
                 value=dist[d];
             if (value<dist[p->d])
                 dist[p->d]=value;
             p=p->next;
         }
         mindist=maxdist;
         for (j=;j<=n;j++)
             if (vis[j] && dist[j]<mindist)
             {
                 mindist=dist[j];
                 d=j;
             }
         //从点n结束
         if (d==n)
             break;
         vis[d]=false;
     }
     printf("%ld\n",dist[n]);
     //最小堆优化
     return ;
 }

4.dijkstra堆优化

 #include <stdio.h>
 #include <stdlib.h>
 #include <malloc.h>
 #include <stdbool.h>
 #define maxn 100000
 #define maxm 200000
 #define maxc 1000000
 #define maxdist 1000000000

 //裸dijkstra 80分 超时

 long max(long a,long b)
 {
     if (a>b)
         return a;
     else
         return b;
 }

 int main()
 {
     struct node
     {
         long d,len;
         struct node *next;
     };
     struct node **point=(struct node **) malloc (sizeof(struct node *)*(maxn+));
     struct node *p;
     bool *vis=(bool *) malloc (sizeof(bool)*(maxn+));
     long *dist=(long *) malloc (sizeof(long)*(maxn+));
     long n,m,i,j,a,b,c,d,value,mindist;
     scanf("%ld%ld",&n,&m);
     for (i=;i<=n;i++)
     {
         point[i]=NULL;
         dist[i]=maxc;
         vis[i]=true;
     }
     for (i=;i<=m;i++)
     {
         scanf("%ld%ld%ld",&a,&b,&c);
         //build a
         p=(struct node *) malloc (sizeof(struct node));
         p->d=b;
         p->len=c;
         if (point[a]!=NULL)
             p->next=point[a];
         else
             p->next=NULL;
         point[a]=p;
         //build b
         p=(struct node *) malloc (sizeof(struct node));
         p->d=a;
         p->len=c;
         if (point[b]!=NULL)
             p->next=point[b];
         else
             p->next=NULL;
         point[b]=p;
     }
     for (i=;i<=n;i++)
     {
         vis[i]=true;
         dist[i]=maxdist;
     }
     //从点1开始
     dist[]=;
     d=;
     vis[]=false;
     for (i=;i<n;i++)
     {
         p=point[d];
         while (p)
         {
             if (dist[d]<p->len)
                 value=p->len;
             else
                 value=dist[d];
             if (value<dist[p->d])
                 dist[p->d]=value;
             p=p->next;
         }
         mindist=maxdist;
         for (j=;j<=n;j++)
             if (vis[j] && dist[j]<mindist)
             {
                 mindist=dist[j];
                 d=j;
             }
         //从点n结束
         if (d==n)
             break;
         vis[d]=false;
     }
     printf("%ld\n",dist[n]);
     //最小堆优化
     return ;
 }