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=110;
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=0,num=0;
    priority_queue<node> pq;
    for(int i=0;i<n;i++) {
        vis[i]=false;
        dis[i]=inf;
    }
    pq.push(node(0,0));
    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=0;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,0,sizeof(G));
        for(int i=0;i<n;i++) {
            for(int j=0;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=110;
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]==-1) 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,-1,sizeof(fa));
        edge.clear();
        for(int i=0;i<n;i++) {
            for(int j=0;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=0,ans=0;
        for(int i=0;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-1) printf("%d\n",ans);
        else printf("-1\n");
    }
}