最小生成树

生成树专题
最小生成树不要点我
1.kruskal算法
Kruskal 算法是能够在O(mlogm) 的时间内得到一个最小生成树的算 法。它主要是基于贪心的思想：

① 将边按照边权从小到大排序，并建立一个没有边的图T。

② 选出一条没有被选过的边权最小的边。

③ 如果这条边两个顶点在T 中所在的连通块不相同，那么将 它加入图T， 相 同就跳过。

④ 重复②和③直到图T 连通为止。

由于只需要维护连通性，可以不需要真正建立图T，可以用并查集 来维护。

观察一下几种不同风格的代码

#include<bits/stdc++.h>

const int maxn = 1e6 + 1;

inline int read()
{
    register int x = 0, ch = getchar(), f = 1;
    while(!isdigit(ch)){if(ch == '-') f = -1; ch = getchar();}
    while(isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
    return x * f;
}

int n, m;

struct node{
    int u;
    int v;
    int w;
}e[maxn];

int fa[maxn], cnt, sum, num;

void add(int x, int y, int w)
{
    e[++ cnt].u = x;
    e[cnt].v = y;
    e[cnt].w = w;
}

bool cmp(node x, node y)
{
    return x.w < y.w;
}

int find(int x)
{
    return fa[x] == x ? fa[x] : fa[x] = find(fa[x]);//路径压缩
}

/* 
int find(int x)
{
    if(fa[x] == x) return x;
    else 
    {
         fa[x] = find(fa[x]);//路径压缩
         return fa[x];
        }
}
*/

void kruskal()
{
    for(int i = 1; i <= cnt; i ++)
    {
        int x = find(e[i].u);
        int y = find(e[i].v);
        if(x == y) continue;
        fa[x] = y;
        sum += e[i].w;
        if(++ num == n - 1) break;//如果构成了一颗树 
    }
}

int main()
{
    n = read();
    m = read();
    for(int i = 1; i <= n; i ++) fa[i] = i;
    while(m --)
    {
        int x, y, w;
        x = read();
        y = read();
        w = read(); 
        add(x, y, w);
    }
    std:: sort(e + 1, e + 1 + cnt, cmp);
    kruskal();
    printf("%d",sum);
    return 0;
}

2.prim算法
Prim 算法和Kruskal 算法一样也是寻找最小生成树的一种方法:

① 先建立一个只有一个结点的树，这个结点可以是原图中任 意的一个结点。

② 使用一条边扩展这个树，要求这条边一个顶点在树中另一 个顶点不在树中，并且这条边的权值要求最小。

③ 重复步骤②直到所有顶点都在树中。

这里记顶点数 vv，边数 ee
邻接矩阵: O(v ^ 2)O(v
2
) 邻接表: O(elog2v)O(elog2v)
此为原始的加权连通图。每条边一侧的数字代表其权值。

顶点D被任意选为起始点。顶点A、B、E和F通过单条边与D相连。A是距离D最近的顶点，因此将A及对应边AD以高亮表示。

不可选 C, G 可选A, B, E, F 已选 D

下一个顶点为距离D或A最近的顶点。B距D为9，距A为7，E为15，F为6。因此，F距D或A最近，因此将顶点F与相应边DF以高亮表示。

不可选 C G，可选B, E, F，已选A,D

算法继续重复上面的步骤。距离A为7的顶点B被高亮表示。

可选 B,E,G 不可选 C，已选 A D F

在当前情况下，可以在C、E与G间进行选择。C距B为8，E距B为7，G距F为11。点E最近，因此将顶点E与相应边BE高亮表示

可选 C E G,不可选 无，已选 A D B F

接下来继续进行，我就不打具体步骤了

结束
现在，所有顶点均已被选取，图中绿色部分即为连通图的最小生成树。在此例中，最小生成树的权值之和为39

是不是有点像最短路算法中的迪杰斯特拉？

其实代码实现也差不多

最简单的无优化版本

• View code

#include<cstdio>
#include<cstdlib>
#include<iostream>

using namespace std;
/*最小生成树Prim未优化版*/

int book[100];//用于记录这个点有没有被访问过
int dis[100];//用于记录距离树的距离最短路程
int MAX = 99999;//边界值
int maps[100][100];//用于记录所有边的关系

int main()
{
    int i,j,k;//循环变量
    int n,m;//输入的N个点，和M条边
    int x,y,z;//输入变量
    int min,minIndex;
    int sum=0;//记录最后的答案

    cin>>n>>m;

    //初始化maps，除了自己到自己是0其他都是边界值
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
        {
            if(i!=j)
                maps[i][j] = MAX;
            else
                maps[i][j] = 0;
        }
    }

    for (i = 1; i <= m; i++)
    {
        cin>>x>>y>>z;//输入的为无向图
        maps[x][y] = z;
        maps[y][x] = z;
    }

    //初始化距离数组，默认先把离1点最近的找出来放好
    for (i = 1; i <= n; i++)
        dis[i] = maps[1][i];

    book[1]=1;//记录1已经被访问过了

    for (i = 1; i <= n-1; i++)//1已经访问过了，所以循环n-1次
    {
        min = MAX;//对于最小值赋值，其实这里也应该对minIndex进行赋值，但是我们承认这个图一定有最小生成树而且不存在两条相同的边
        //寻找离树最近的点
        for (j = 1; j <= n; j++)
        {
            if(book[j] ==0 && dis[j] < min)
            {
                min = dis[j];
                minIndex = j;
            }
        }

        //记录这个点已经被访问过了
        book[minIndex] = 1;
        sum += dis[minIndex];

        for (j = 1; j <= n; j++)
        {
            //如果这点没有被访问过，而且这个点到任意一点的距离比现在到树的距离近那么更新
            if(book[j] == 0 && maps[minIndex][j] < dis[j])
                dis[j] = maps[minIndex][j];
        }
    }

    cout<<sum<<endl;
}

链式前项星存图

#include<bits/stdc++.h>
using namespace std;
#define re register
#define il inline
il int read()
{
    re int x=0,f=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-') f=-1;c=getchar();}
    while(c>='0'&&c<='9') x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x*f;
}//快读，不理解的同学用cin代替即可
#define inf 123456789
#define maxn 5005
#define maxm 200005
struct edge
{
    int v,w,next;
}e[maxm<<1];
//注意是无向图，开两倍数组
int head[maxn],dis[maxn],cnt,n,m,tot,now=1,ans;
//已经加入最小生成树的的点到没有加入的点的最短距离，比如说1和2号节点已经加入了最小生成树，那么dis[3]就等于min(1->3,2->3)
bool vis[maxn];
//链式前向星加边
il void add(int u,int v,int w)
{
    e[++cnt].v=v;
    e[cnt].w=w;
    e[cnt].next=head[u];
    head[u]=cnt;
}
//读入数据
il void init()
{
    n=read(),m=read();
    for(re int i=1,u,v,w;i<=m;++i)
    {
        u=read(),v=read(),w=read();
        add(u,v,w),add(v,u,w);
    }
}
il int prim()
{
    //先把dis数组附为极大值
    for(re int i=2;i<=n;++i)
    {
        dis[i]=inf;
    }
    //这里要注意重边，所以要用到min
    for(re int i=head[1];i;i=e[i].next)
    {
        dis[e[i].v]=min(dis[e[i].v],e[i].w);
    }
    while(++tot<n)//最小生成树边数等于点数-1
    {
        re int minn=inf;//把minn置为极大值
        vis[now]=1;//标记点已经走过
        //枚举每一个没有使用的点
        //找出最小值作为新边
        //注意这里不是枚举now点的所有连边，而是1~n
        for(re int i=1;i<=n;++i)
        {
            if(!vis[i]&&minn>dis[i])
            {
                minn=dis[i];
                now=i;
            }
        }
        ans+=minn;
        //枚举now的所有连边，更新dis数组
        for(re int i=head[now];i;i=e[i].next)
        {
            re int v=e[i].v;
            if(dis[v]>e[i].w&&!vis[v])
            {
                dis[v]=e[i].w;
            }
        }
    }
    return ans;
}
int main()
{
    init();
    printf("%d",prim());
    return 0;
}

优先队列+堆优化

#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#define R register int
using namespace std;

int k,n,m,cnt,sum,ai,bi,ci,head[5005],dis[5005],vis[5005];

struct Edge
{
    int v,w,next;
}e[400005];

void add(int u,int v,int w)
{
    e[++k].v=v;
    e[k].w=w;
    e[k].next=head[u];
    head[u]=k;
}

typedef pair <int,int> pii;
priority_queue <pii,vector<pii>,greater<pii> > q;

void prim()
{
    dis[1]=0;
    q.push(make_pair(0,1));
    while(!q.empty()&&cnt<n)
    {
        int d=q.top().first,u=q.top().second;
        q.pop();
        if(vis[u]) continue;
        cnt++;
        sum+=d;
        vis[u]=1;
        for(R i=head[u];i!=-1;i=e[i].next)
            if(e[i].w<dis[e[i].v])
                dis[e[i].v]=e[i].w,q.push(make_pair(dis[e[i].v],e[i].v));
    }
}

int main()
{
    memset(dis,127,sizeof(dis));
    memset(head,-1,sizeof(head));
    scanf("%d%d",&n,&m);
    for(R i=1;i<=m;i++)
    {
        scanf("%d%d%d",&ai,&bi,&ci);
        add(ai,bi,ci);
        add(bi,ai,ci);
    }
    prim();
    if (cnt==n)printf("%d",sum);
    else printf("orz");
}

这是啥。。。

#include<cstring>
#include<cstdio>
#include<vector>
#include<queue>
using namespace std;
int n,m,x,y,z,tot,ans,k,ds[1001],next[2001],st[1001],to[2001],cost[2001];
bool vis[1001];
void addedge(int x,int y,int z)
{
    next[++tot]=st[x];st[x]=tot;to[tot]=y;cost[tot]=z;
}
struct node
{
    int x,d;
    node(int a,int b):x(a),d(b) {}
    bool operator<(const node&t) const {return d>t.d;}
}; priority_queue<node>q;
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        addedge(x,y,z);addedge(y,x,z); 
    }
    memset(ds,0x7f,sizeof(ds));
    ds[1]=0;q.push(node(1,0));vis[0]=1;
    for(int i=1;i<=n;i++)
    {
        node a(0,0);
        while(vis[a.x]&&!q.empty())
          a=q.top(),q.pop();
        if(vis[a.x]) break;
        ans+=a.d;vis[a.x]=1;k++;
        for(int j=st[a.x];j;j=next[j])
        {
            y=to[j];z=cost[j];
            if(!vis[y]&&z<ds[y])
              ds[y]=z,q.push(node(y,z));
        }  
    }
    if(k!=n) printf("-1");
    else printf("%d",ans);
}

kruskal和prim的比较
从策略上来说，Prim算法是直接查找，多次寻找邻边的权重最小值，而Kruskal是需要先对权重排序后查找的～

所以说，Kruskal在算法效率上是比Prim快的，因为Kruskal只需一次对权重的排序就能找到最小生成树，而Prim算法需要多次对邻边排序才能找到～

prim:该算法的时间复杂度为O(n2)。与图中边数无关，该算法适合于稠密图。

kruskal:需要对图的边进行访问，所以克鲁斯卡尔算法的时间复杂度只和边又关系，可以证明其时间复杂度为O（eloge）。适合稀疏图

接下来讲几道例题
[UVALive 6437]Power Plant
T组数据，给定一幅带权图(n, m), 然后给定k个点, 与图中存在有若 干条边。每个点都要至少要和这k个点的一个点直接或间接相连, 问最少 的距离是多少。 1 ≤ T ≤ 100,

k个点，至少一个，明显的缩点。

[UVA 1151]Buy or Build
平面上有n个点，你的任务是让所有n个点连通，为此，你可以新建 一些边，费用等于两个端点的欧几里得距离的平方。另外还有q个套餐， 可以购买，如果你购买了第i个套餐，该套餐中的所有结点将变得相互 连通，第i个套餐的花费为ci。求最小花费。

1 ≤ n ≤ 1000, 0 ≤ q ≤ 8。

枚举选择哪个套餐后再求最小生成树即可。

[UVA 10369]Arctic Network
南极有n个科研站，要用卫星或无线电把他们连起来，无线电的费 用随着距离增加而增加，并且长传播距离为d，现在有s个卫星，任意两 个安装了卫星的设备无论距离多远都可以直接通信，求一个方案使 得d最小。

s ≤ 1时求最小生成树即可

s ≥ 2时，等于孤立了s − 1个区域，即s − 1条边置为0，当然是最小 生成树中最大的s − 1条。 kruskal的过程中直接计算即可。

[BZOJ 1601][Usaco2008 Oct]灌水
Farmer John已经决定把水灌到他的n(1¡=n¡=300)块农田，农田被数 字1到n标记。把一块土地进行灌水有两种方法，从其他农田饮水，或者 这块土地建造水库。建造一个水库需要花费wi ,连接两块土地需要花 费pij。计算Farmer John所需的最少代价。

1 ≤ N ≤ 300, 1 ≤ wi ≤ 105 , 1 ≤ pij ≤ 105。

每个水库要么选择自己这里建造水库，要么选择连一条边到已建成 的水库。 假设所有的水库最终都选择好了一个决策的话，那么整个图就是， 分成m块，每一块有一个点是自己建造水库的。其他都是顺着边连到这 个点的。也就是在这个子图当中做最小生成树。

加一个超级源，每个点向源连花费wi边。然后在整个图中做最小生 成树。超级源的连通保证了至少有一个点建造了水库

还有一些比较难的题，等我自己搞懂了再补吧~
完结撒花