最小生成樹

 

 

給定一個無向圖，每條邊有一個非負權值。求這個圖中最小生成樹的所有邊的權值之和。生成樹是指包含圖中所有節點的一棵樹，而最小生成樹則指一棵所有邊的權值之和最小的生成樹。

輸入

第一行包含兩個數，n和m，其中n為節點數，m為邊數。下面m行，每行三個非負整數a、b和c，a, b<n，表示a和b之間有一條權值為c的邊。

輸出

輸出一個數，表示一棵最小生成樹所有邊的權值之和。

樣例輸入 Copy

5 8
0 1 1
0 2 2
0 3 5
0 4 7
1 2 0
2 3 15
2 4 25
1 4 100

樣例輸出 Copy

13

提示

對於30%的數據，m≤10；
對於50%的數據，m≤1000；
對於100%的數據，m≤100000，c≤2000。

 

算法：

Kruskal（克魯斯卡爾）算法開始時，認為每一個點都是孤立的，分屬於n個獨立的集合。

 

 

5個集合{ {1}，{2}，{3}，{4}，{5} }

 

生成樹中沒有邊

 

 

 

Kruskal每次都選擇一條最小的邊，而且這條邊的兩個頂點分屬於兩個不同的集合。將選取的這條邊加入最小生成樹，並且合並集合。

 

第一次選擇的是<1,2>這條邊，將這條邊加入到生成樹中，並且將它的兩個頂點1、2合並成一個集合。

4個集合{ {1，2}，{3}，{4}，{5} }

生成樹中有一條邊{ <1,2> }

第二次選擇的是<4,5>這條邊，將這條邊加入到生成樹中，並且將它的兩個頂點4、5合並成一個集合。

3個集合{ {1，2}，{3}，{4，5} }

生成樹中有2條邊{ <1,2> ，<4,5>}

第三次選擇的是<3,5>這條邊，將這條邊加入到生成樹中，並且將它的兩個頂點3、5所在的兩個集合合並成一個集合　　

2個集合{ {1，2}，{3，4，5} }

生成樹中有3條邊{ <1,2> ，<4,5>，<3，5>}

第四次選擇的是<2,5>這條邊，將這條邊加入到生成樹中，並且將它的兩個頂點2、5所在的兩個集合合並成一個集合。　　

 

 

1個集合{ {1，2，3，4，5} }

生成樹中有4條邊{ <1,2> ，<4,5>，<3，5>，<2,5>}

  算法結束，最小生成樹權值為19。

　　通過上面的模擬能夠看到，Kruskal算法每次都選擇一條最小的，且能合並兩個不同集合的邊，一張n個點的圖總共選取n-1次邊。因為每次我們選的都是最小的邊，所以最后的生成樹一定是最小生成樹。每次我們選的邊都能夠合並兩個集合，最后n個點一定會合並成一個集合。通過這樣的貪心策略，Kruskal算法就能得到一棵有n-1條邊，連接着n個點的最小生成樹。

　　Kruskal算法的時間復雜度為O(E*logE)，E為邊數。

int Find(int x) 並差集 壓縮路徑

{if(fa[x]==x) return x;fa[x]=Find(fa[x]);}

 

FORa(i,1,n) fa[i]=i; 初始化，將父親指向自己

sort(edge+1,edge+1+n,cmp);排序

FORa(i,1,m)

{

t1=Find(edge[i].from);t2=Find(edge[i].to);

if(t1!=t2) 並差集合並

cnt++,fa[t1]=t2,ans+=edge[i].dis;

if(cnt==n-1)

cout<<ans;return;

本題代碼：

#include<bits/stdc++.h> 
using namespace std;
typedef long long ll;
inline int read()
{
    int x=0;char ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x;
}
const int maxn=1e6+100;
int pre[maxn],n,m;
struct node{
    ll u,v,w;
}a[maxn];
bool cmp(node x,node y){
    return x.w<y.w;
} 
void inint(){
    for(int i=0;i<=n;i++){
        pre[i]=i;
    }
}
int find(int h)//找根？ 
{    
    return pre[h]==h?h:pre[h]=find(pre[h]); 
}
int merge(node n){
    int x=find(n.u);
    int y=find(n.v);
    if(x!=y){
        pre[x]=y;
        return 1;
    }
    return 0;
} 
int main(){
    cin>>n>>m;
    inint();
    for(int i=1;i<=m;i++){
        a[i].u=read();
        a[i].v=read();
        a[i].w=read();
    }
    sort(a+1,a+m+1,cmp);
    ll num=0,ans=0; 
    for(int i=1;i<=m&&num<=n-1;i++)
    {
        if(merge(a[i])==1)
        {
            num++;
            ans+=a[i].w;
        }
    }
    printf("%lld\n",ans);
}

 

克魯斯卡爾

1. 並查集加排序
2. 預處理，現將所有的節點的父親指向自己
3. 輸入m條邊，切記，只需要m條邊
4. 按每一條邊的權值排序
5. 最后並查集來查詢，看是否加入到生成樹中，注意並查集模板是這樣寫的

int Find(int x){if(fa[x]==x) return fa[x];  return fa[x]=Find(fa[x]);

1. 最后查看是否是構造了一顆n個點，n-1條邊的最小生成樹

普里姆

1. 對於構造邊，就使用鏈式前向星，但是對於邊的話就需要開兩倍
2. 初始化，將dis[]（這個點到最小生成樹的最近的距離）賦值為一個極大的值，但是不能超過INF的二分之一，即為memset(dis,63,sizeof (dis))為一個較大的值，memset賦值的時候需要賦值為2的x次方-1
3. 再用一個pair來儲存隊列節點的信息，宏定義 #define pair<int,int> pp
4. 放入優先隊列priority_queue<pp,vector<pp>,greater<pp> >  q; 小根堆，默認為大根堆
5. 兩個連着的尖括號之間需要打空格
6. Pair的比較，先比較first，在比較second，所以將dis存入first，u存入second
7. 最外層循環為隊列不為空且最小生成樹還沒有構建好while(!q.empty()&&cnt<n)
8. 接着，退出隊列中的對頭，查看是否出現過，沒有出現過就將此點打標記，cnt++，答案加上這條邊的權值，擴散連接它的邊，放入隊列

普里姆的算法就是最短路的貪心思想

#include<cstdio>
#include<queue>
#include<cstring>
#include<utility>
#include<algorithm>
#define FORa(i,s,e) for(i=s;i<=e;i++)
#define R register int
using namespace std;

int n,m,cnt,ans,head[5005],dis[5005],bz[5005];
struct Edge
{
    int next,to,dis;
}edge[400005];
int num_edge;
void Add_edge(int from,int to,int dis)
{
    edge[++num_edge]=(Edge){head[from],to,dis};
    head[from]=num_edge;
}
typedef pair <int,int> pp;
priority_queue <pp,vector<pp>,greater<pp>> q;//first dis     second u
void Prim()
{
    pp ft;
    dis[1]=0;
    q.push(make_pair(0,1));
    while(!q.empty()&&cnt<n)
    {
    ft=q.top(),q.pop();
        if(bz[ft.second]) continue;
        cnt++,ans+=ft.first,bz[ft.second]=1;
        for(R i=head[ft.second];i;i=edge[i].next)
            if(dis[edge[i].to]>edge[i].dis)
                dis[edge[i].to]=edge[i].dis,q.push(make_pair(dis[edge[i].to],edge[i].to));
    }
}
int main()
{
    memset(dis,127,sizeof(dis));
    R from,to,fdis;
    scanf("%d%d",&n,&m);
    for(R i=1;i<=m;i++)
    {
        scanf("%d%d%d",&from,&to,&fdis);
        Add_edge(to,from,fdis),Add_edge(from,to,fdis);
    }
    Prim();
    if (cnt==n)printf("%d",ans);
    else printf("orz");
}