最小生成树

注：我在修炼当中，博客完全是为了自己复习方便看得，如果你不慎点入了我的博客，看看就好，不要相信，误人子弟就不好了- -

最小生成树有Prim 和 Kruskal 两种经典算法 ，这两个呢都是利用MST性质来构造最小生成树的算法的，如果忘记了MST，去翻我的博客。

先说说prim算法，有个V点集，从中先选出一个点u0放入U点集中，然后找到一条与u0相连代价最小的边，且该边另一个点v0在V - U点集中。此时将该边加入最小生成树的边的集合中，然后将v0加入到U点集中，之后不断重复该操作，直到所有点都加入到了U点集中。

Prim + 优先队列

不会算时间复杂度，GG，T_T，大概是O（nloge）的，注意优先队列时间复杂度为O（logn）的

#include <iostream>#include <queue>#include<cstring>#include<cstdio>using namespace std;typedef struct{    long v;    long next;    long cost;}Edge;typedef struct{    long v;    long cost;}node;bool operator <(const node &a,const node &b){    return a.cost>b.cost;}priority_queue<node> q;const long MAXN=10000;Edge e[MAXN];long p[MAXN];bool vist[MAXN];long m,n;long from,to,cost;void init(){    memset(p,-1,sizeof(p));    memset(vist,0,sizeof(vist));    while (!q.empty())        q.pop();    long i;    long eid=0;    for (i=0;i<n;++i)    {        scanf("%ld %ld %ld",&from,&to,&cost);        e[eid].next=p[from];        e[eid].v=to;        e[eid].cost=cost;        p[from]=eid++;        //以下适用于无向图        swap(from,to);        e[eid].next=p[from];        e[eid].v=to;        e[eid].cost=cost;        p[from]=eid++;    }}void Prim(){    long cost=0;    init();    node t;    t.v=from;//选择起点    t.cost=0;    q.push(t);    long tt=0;    while (!q.empty()&&tt<m)    {        t=q.top();        q.pop();        if (vist[t.v])        {            continue;        }        cost+=t.cost;        ++tt;        vist[t.v]=true;        long j;        for (j=p[t.v];j!=-1;j=e[j].next)        {            if (!vist[e[j].v])            {                node temp;                temp.v=e[j].v;                temp.cost=e[j].cost;                q.push(temp);            }        }    }    printf("%ld\n",cost);}int main(){    while (scanf("%ld %ld",&m,&n)!=EOF) //m 代表点  n代表边数    {        Prim();    }    return 0;}

Prim

时间复杂度是O（n2），与边数无关，适合求边稠密的网。

int minTree(int n){    int i,j;    memset(v,0,sizeof(v));    v[0]=1;    sum=0;    for(i=1;i<n;i++)    {        min=max;        for(j=0;j<n;j++)        {            if(!v[j]&&map[0][j]<min)            {                min=map[0][j];                flag=j;            }        }        sum+=min;        v[flag]=1;        for(j=0;j<n;j++)        {            if(!v[j]&&map[0][j]>map[flag][j])            {                map[0][j]=map[flag][j];            }        }    }    return sum;}

判断次小生成树

#include <iostream>using namespace std;#define MAX 101#define INF 999999999#define max(a,b) (a>b?a:b)int dis[MAX], pre[MAX];int edge[MAX][MAX];int maxVal[MAX][MAX];bool inTree[MAX][MAX];bool vis[MAX];int Prime ( int n ){    int i, j, k, minc, mst;    for ( i = 1; i <= n; i++ )    {        dis[i] = edge[1][i];        vis[i] = false;        pre[i] = 1;    }    dis[1] = mst = 0;     vis[1] = true;    for ( i = 2; i <= n; i++ )     {        minc = INF; k = -1;        for ( j = 1; j <= n; j++ )        {            if ( ! vis[j] && dis[j] < minc )            {                minc = dis[j];                k = j;            }        }        if ( minc == INF ) return -1;  // 图不连通，没有找到最小生成树        mst += minc;        vis[k] = true;        inTree[pre[k]][k] = inTree[k][pre[k]] = true;  // 记录加入的树中的边        for ( j = 1; j <= n; j++ )            if ( vis[j] == true )                maxVal[j][k] = max ( maxVal[j][pre[k]], edge[pre[k]][k] ); // 找j-k的路径上权值最大的那条边，并记录在maxVal[j][k]中        for ( j = 1; j <= n; j++ )        {            if ( ! vis[j] && dis[j] > edge[k][j] )            {                dis[j] = edge[k][j];                pre[j] = k;   // 修正前驱            }        }    }    return mst;}void initial ( int n ){    for ( int i = 1; i < n; i++ )    {        for ( int j = i + 1; j <= n; j++ )        {            edge[i][j] = edge[j][i] = INF;            inTree[i][j] = inTree[j][i] = 0;            maxVal[i][j] = maxVal[j][i] = 0;        }    }}   int main(){    int t, n, m, u, v, w;    scanf("%d",&t);     while ( t-- )    {        scanf("%d%d",&n,&m);        initial ( n );        while ( m-- )        {            scanf("%d%d%d",&u,&v,&w);            edge[u][v] = edge[v][u] = w;        }        int mst = Prime ( n );        if ( mst < 0 ) { printf("0\n"); continue; }        int res;        bool flag = false;        for ( int i = 1; i < n; i++ )        {            for ( int j = i + 1; j <= n; j++ )            {                if ( inTree[i][j] || edge[i][j] == INF ) continue; // 边edge[i][j]在树中或者i,j之间无边                res = mst + edge[i][j] - maxVal[i][j]; // 用边edge[i][j]， 替换i-j路径上权值最大的那条边，得到一棵新的生成树                if ( res == mst ) { flag = true; break; }            }            if ( flag ) break;        }        if ( flag )            printf("Not Unique!\n");        else            printf("%d\n",mst);    }    return 0;}

Kruskal

该算法是初始时所有点自成一个连通分量，然后在所有边中选择一条权重最小的边放入边集中，然后再寻找下一条最小的边，并且将该边加入边集的条件是该边
时间复杂度为O（eloge），适合边稀疏的网

#include<iostream>//这里的n代表节点数，给节点初始化，m代表边数，需要给边数排序，#include<stdio.h>#include<string.h>//kruskal算法主要用的是并查集#include<algorithm>using namespace std;int inf=999999;int fa[110000];int n,m;struct node{    int u,v,w;}q[110000];void make_set(){    for(int i=1;i<=n;i++)    {        fa[i]=i;    }}int Find(int x){    if(x!=fa[x])        fa[x]=Find(fa[x]);        return fa[x];}bool cmp(node x,node y){    return x.w<y.w;}int kru(){  int ans=0,cnt=0;    make_set();    sort(q+1,q+m+1,cmp);//排序要从起始地址，到终止地址此题中i是从1开始的，    for(int i=1;i<=m;i++)    {        int fx=Find(q[i].u);        int fy=Find(q[i].v);        if(fx!=fy)          {           fa[fx]=fy;           ans+=q[i].w;            cnt++;          }    }    return ans;}int main(){    while(scanf("%d%d",&n,&m)!=EOF)    {        for(int i=1;i<=m;i++)        {            scanf("%d%d%d",&q[i].u,&q[i].v,&q[i].w);        }        printf("%d\n",kru());    }    return 0;}