【HDU 4463 Outlets】最小生成树（prim,kruscal都可）

以（x,y）坐标的形式给出n个点，修建若干条路使得所有点连通（其中有两个给出的特殊点必须相邻），求所有路的总长度的最小值。

因对所修的路的形状没有限制，所以可看成带权无向完全图，边权值为两点间距离。因是稠密图，故用邻接矩阵存储更好（完全图，边数e达到n(n-1)/2）。

至此，可将问题抽象为求最小生成树的边权和。

用了prim+邻接矩阵，prim+邻接表+堆，kruscal各写了一遍，只是内存稍有差别

对于所给的特殊的两个相邻点，只需在开始循环前把这两个点加入子树集合并更新它们所到达的点的mincost即可。

 #include <cstdio>
 #include <algorithm>
 #include <cmath>
 using namespace std;

 const int MAX_N=;
 const double INF=;

 struct Point
 {
     int x,y;
 }a[MAX_N];

 double dis(Point& p1, Point& p2)
 {
     return sqrt((double)(p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
 }

 int n;
 int nike,apple;
 double cost[MAX_N][MAX_N];//邻接矩阵（更适于稠密图）
 double mincost[MAX_N];//集合到点i的最短距离
 int used[MAX_N];

 double prim()
 {
     double res;
     for(int i=;i<n;i++)
     {
         mincost[i]=INF;
         used[i]=;
     }//将nike,apple两个点加入集合，并更新它们所到达的点的mincost
     mincost[nike]=mincost[apple]=;
     used[nike]=used[apple]=;
     res=cost[nike][apple];
     for(int i=;i<n;i++)
     {
         mincost[i]=min(mincost[i],cost[nike][i]);
     }
     for(int i=;i<n;i++)
     {
         mincost[i]=min(mincost[i],cost[i][apple]);
     }
     while()
     {
         int v=-;
         for(int i=;i<n;i++)//找到集合以外的mincost最小的点
         {
             if(!used[i]&&(v==-||mincost[i]<mincost[v]))
                 v=i;
         }
         if(v==-) break;//不存在负权边
         used[v]=;
         res+=mincost[v];//加入集合，更新它所到达的点
         for(int i=;i<n;i++)
         {
             mincost[i]=min(mincost[i],cost[i][v]);
         }
     }
     return res;
 }

 int main()
 {
     //freopen("1011.txt","r",stdin);
     while(scanf("%d",&n)!=EOF)
     {
         if(n==) break;
         scanf("%d%d",&nike,&apple);
         nike--;
         apple--;
         for(int i=;i<n;i++)
         {
             scanf("%d%d",&a[i].x,&a[i].y);
         }
         for(int i=;i<n;i++)//求两点间距离，得到邻接矩阵
         {
             cost[i][i]=;
             for(int j=i+;j<n;j++)
                 cost[i][j]=cost[j][i]=dis(a[i],a[j]);
         }
         printf("%.2lf\n",prim());
     }
     return ;
 }

prim_邻接矩阵

 #include <cstdio>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <cmath>
 using namespace std;

 const int MAX_N=;
 const double INF=;

 struct Point
 {
     int x,y;
 }a[MAX_N];

 double dis(Point& p1, Point& p2)
 {
     return sqrt((double)(p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
 }

 struct Edge
 {
     int to;
     double cost;
     Edge(){}
     Edge(int tt,double cc):to(tt),cost(cc){}
 };
 typedef pair<double,int> P;//cost,to
 int n;
 int nike,apple;
 double dis_na;
 vector<Edge> G[MAX_N];
 double mincost[MAX_N];//集合到点i的最短距离
 int used[MAX_N];

 double prim()
 {
     double res=;
     for(int i=;i<n;i++)
     {
         mincost[i]=INF;
         used[i]=;
     }//将nike,apple两个点加入集合，并将与它们相邻的边推入队列
     mincost[nike]=mincost[apple]=;
     used[nike]=used[apple]=;
     res=dis_na;
     priority_queue<P,vector<P>,greater<P> >que;
     for(int i=;i<G[nike].size();i++)
     {
         int u=G[nike][i].to;
         if(used[u]||mincost[u]<G[nike][i].cost) continue;
         mincost[u]=G[nike][i].cost;
         que.push(P(mincost[u],u));
     }
     for(int i=;i<G[apple].size();i++)
     {
         int u=G[apple][i].to;
         if(used[u]||mincost[u]<G[apple][i].cost) continue;
         mincost[u]=G[apple][i].cost;
         que.push(P(mincost[u],u));
     }
     while(!que.empty())
     {
         P p=que.top();
         que.pop();
         int v=p.second;
         if(used[v]||mincost[v]<p.first) continue;
         mincost[v]=p.first;
         used[v]=;
         res+=mincost[v];//加入集合，更新它所到达的点
         for(int i=;i<G[v].size();i++)
         {
             int u=G[v][i].to;
             if(!used[u]&&mincost[u]>G[v][i].cost)
             {
                 mincost[u]=G[v][i].cost;
                 que.push(P(mincost[u],u));
             }
         }
     }
     return res;
 }

 int main()
 {
     //freopen("4463.txt","r",stdin);
     while(scanf("%d",&n)!=EOF)
     {
         if(n==) break;
         scanf("%d%d",&nike,&apple);
         nike--;
         apple--;
         for(int i=;i<n;i++)
         {
             scanf("%d%d",&a[i].x,&a[i].y);
         }
         for(int i=;i<n;i++) G[i].clear();
         for(int i=;i<n;i++)//求两点间距离，得到表
         {
             for(int j=i+;j<n;j++)
             {
                 double temp=dis(a[i],a[j]);
                 G[i].push_back(Edge(j,temp));
                 G[j].push_back(Edge(i,temp));
                 if(i==nike&&j==apple) dis_na=temp;
             }
         }
         printf("%.2lf\n",prim());
     }
     return ;
 }

prim_邻接表_堆

 #include <cstdio>
 #include <algorithm>
 #include <cmath>
 using namespace std;

 const int MAX_N=;

 int parent[MAX_N];
 int rankk[MAX_N];
 void init(int N)
 {
     for(int i=;i<=N;i++)
     {
         parent[i]=i;
         rankk[i]=;
     }
 }
 int find(int x)
 {
     if(x==parent[x]) return x;
     return parent[x]=find(parent[x]);
 }
 void unite(int x,int y)
 {
     x=find(x);
     y=find(y);
     if(x==y) return ;
     if(rankk[x]<rankk[y]) parent[x]=y;
     else
     {
         parent[y]=x;
         if(rankk[x]==rankk[y]) rankk[x]++;
     }
 }
 bool same(int x,int y)
 {
     return find(x)==find(y);
 }

 struct Point
 {
     int x,y;
 }a[MAX_N];

 double dis(Point& p1, Point& p2)
 {
     return sqrt((double)(p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
 }

 struct Edge
 {
     int from,to;
     double cost;
 }edges[MAX_N*MAX_N];

 bool cmp(Edge e1,Edge e2)
 {
     return e1.cost<e2.cost;
 }

 int n,m;
 int nike,apple;
 double dis_na;

 double kruscal()
 {
     double ans=;
     init(n);
     unite(nike,apple);
     ans+=dis_na;
     for(int i=;i<m;i++)
     {
         if(!same(edges[i].from,edges[i].to))
         {
             ans+=edges[i].cost;
             unite(edges[i].from,edges[i].to);
         }
     }
     return ans;
 }

 int main()
 {
     //freopen("4463.txt","r",stdin);
     while(scanf("%d",&n)!=EOF)
     {
         if(n==) break;
         scanf("%d%d",&nike,&apple);
         nike--;
         apple--;
         for(int i=;i<n;i++)
         {
             scanf("%d%d",&a[i].x,&a[i].y);
         }
         m=;
         for(int i=;i<n;i++)//求两点间距离，得到所有边
         {
             for(int j=i+;j<n;j++)
             {
                 double temp=dis(a[i],a[j]);
                 edges[m].from=i;
                 edges[m].to=j;
                 edges[m].cost=temp;
                 m++;
                 if((i==nike&&j==apple)||(i==apple&&j==nike)) dis_na=temp;
             }
         }
         sort(edges,edges+m,cmp);
         printf("%.2lf\n",kruscal());
     }
     return ;
 }

kruscal_边数组

邻接矩阵版Prim算法求最小生成树，时间复杂度为O(n*n)。邻接表版prim用堆优化后理论上可达O(elogn)，边数组版kruscal理论也为O(elogn)，但此题是完全图，e=n(n-1)/2，故实为O(n*nlogn)>O(n*n)。--这段分析有待考证。。。