POJ1358 Agri-Net

题目链接

就是裸的最小生成树，复习一下。

prim算法：

G=(V,E),V是点集，E是边集

假设T=（U，TE）是最小生成树。U，TE初始化为空

首先从V中任取一点 假设取V1，然后U={V1},只要U是V的真子集，就从那些一个端点在T中，一个端点在T外的边中，找一条最短边。一直下去，直到找到n-1条边

找边使用 堆优化，复杂度（ElogV） 邻接表复杂度（V²）

 #include<cstdio>
 #include<vector>
 #include<queue>
 #include<cstring>
 using namespace std;
 const int maxn=;
 const int inf=0x3f3f3f3f;
 
 struct node{
     int v,dis;
     node(){}
     node(int _v,int _dis){
         v=_v;
         dis=_dis;
     }
     bool operator<(const node &b) const {
         return dis>b.dis;
     }
 };
 
 int n,dis[maxn];
 vector<node> G[maxn];
 bool vis[maxn];
 
 void prim() {
     int ans=,num=;
     priority_queue<node> pq;
     for(int i=;i<n;i++) {
         vis[i]=false;
         dis[i]=inf;
     }
     pq.push(node(,));
     node f;
     while(num<n&&!pq.empty()) {
         do{
            f=pq.top();
            pq.pop();
         }while(vis[f.v]&&!pq.empty());
         if(!vis[f.v]) {
             ans+=f.dis;
             vis[f.v]=true;
             num++;
             for(int i=;i<G[f.v].size();i++) {
                 int v=G[f.v][i].v;
                 if(!vis[v]) {
                     if(dis[v]>G[f.v][i].dis) {
                         dis[v]=G[f.v][i].dis;
                         pq.push(node(v,dis[v]));
                     }
                 }
             }
         }
     }
     if(num<n) printf("-1\n");//因为这里记录的是点的个数。不是边
     else printf("%d\n",ans);
 }
 
 int main() {
     while(~scanf("%d",&n)) {
         memset(G,,sizeof(G));
         for(int i=;i<n;i++) {
             for(int j=;j<n;j++) {
                 int x;
                 scanf("%d",&x);
                 if(x) G[i].push_back(node(j,x));
             }
         }
         prim();
     }
 }

krusual算法：

将图G中的边按权值从小到大选取，使选取的不与生成树构成回路。直到n-1条边为止

判断回路就用并查集搞一下。

 #include<cstdio>
 #include<vector>
 #include<queue>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 const int maxn=;
 const int inf=0x3f3f3f3f;
 
 int n;
 struct Edge{
     int u,v,dis;
     Edge(){}
     Edge(int _u,int _v,int _dis) {
         u=_u;
         v=_v;
         dis=_dis;
     }
     bool operator <(const Edge &b) const {
         return dis<b.dis;
     }
 };
 
 vector<Edge> edge;
 
 int fa[maxn];
 
 int Find(int x) {
     if(fa[x]==-) return x;
     else return fa[x]=Find(fa[x]);
 }
 
 void Union(int x,int y) {
     int fx=Find(x);
     int fy=Find(y);
     if(fx!=fy) {
         fa[fx]=fy;
     }
 }
 
 int main() {
     while(~scanf("%d",&n)) {
         memset(fa,-,sizeof(fa));
         edge.clear();
         for(int i=;i<n;i++) {
             for(int j=;j<n;j++) {
                 int x;
                 scanf("%d",&x);
                 if(x&&j<i) edge.push_back(Edge(i,j,x));
             }
         }
         sort(edge.begin(),edge.end());
         int num=,ans=;
         for(int i=;i<edge.size();i++) {
             int u=edge[i].u,v=edge[i].v,dis=edge[i].dis;
             if(Find(u)!=Find(v)) {
                 num++;
                 ans+=dis;
                 Union(u,v);
             }
         }
         if(num==n-) printf("%d\n",ans);
         else printf("-1\n");
     }
 }