2. 程式人生 > >Prim和Kruskal求最小生成樹

Prim和Kruskal求最小生成樹

阿新 • • 發佈：2019-01-05

前兩天TCP/IP協議課上,老師談到圖論中的幾個簡單演算法,發現自己不是很熟練,所以馬上掛了一套MST的題目來練練手,題目很簡單,但由於課程比較多,所以還有三個題沒來得及刷,同時在此%一波典

假設給出了一個圖G<V,E>

首先是Prim演算法,基於貪心的思想,任選一個點形成一棵樹,然後不斷的從剩下的點中挑出距離這棵樹中任意一個點距離最小的點,不斷的重複這個操作,直到n個點都加入到樹中形成最小生成樹.時間複雜度為O(|V|^2)

關於Kruskal演算法,也是基於貪心的思想,同時利用了並查積,先選出一條最小的邊,這個邊形成一個邊的集合,然後再選出一條最小的邊,如果這條邊的兩個點的祖先不是同一個的話,把這條邊加入到邊的集合中,直到找到n-1條邊為止.時間複雜度為O(ElogE).

從時間複雜度來看,Prim適用於點比較少的圖,Kruskal適合邊較少的圖.

最小生成樹基礎題:

/*Prim求最小生成樹*/
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 1e2+10;
int n,q;
int mp[maxn][maxn];
int lowcost[maxn];//表示以i為終點的邊的最小權值,當lowcost[i]=0說明以i為終點的邊的最小權值=0,也就是表示i點加入了MST
int mst[maxn];//表示對應lowcost[i]的起點,即說明邊<mst[i],i>是MST的一條邊,當mst[i]=0表示起點i加入MST

int Prim()
{
    //初始化lowcost和mst
    mst[1] = 0;
    lowcost[1] = -1;//先把第一個點加到生成樹裡面
    for( int i = 2; i<= n; i++)
    {
        lowcost[i] = mp[1][i];//初始化以i為終點的最小權值
        mst[i] = 1;//以哪個點為起點才能得到的最小權值
    }

    int mn,mnid;//當前邊的最小權值,加入的點的編號
    int sum = 0;//最小權值和
    for( int i = 2; i <= n; i++)
    {
        mn = inf;
        mnid = 0;
        for( int j = 2; j <= n; j++)
        {
            // printf("j=%d lowcost[j]=%d mn=%d\n",j,lowcost[j],mn);
            if( lowcost[j] < mn && lowcost[j] != -1)//當前權值小且沒有加入到樹中
            {
                mn = lowcost[j];
                mnid = j;
            }
        }
        sum += mn;
        // printf("sum=%d mnid=%d\n",sum,mnid);
        lowcost[mnid] = -1;
        for( int j = 2; j <= n; j++)
        {
            if( mp[mnid][j] < lowcost[j])
            {
                lowcost[j] = mp[mnid][j];
                mst[j] = mnid;
            }
        }

    }
    return sum;
}

int main()
{
    while( ~scanf("%d",&n))
    {
        for( int i = 1; i <= n; i++)
            for( int j = 1; j <= n; j++)
                scanf("%d",&mp[i][j]);
        scanf("%d",&q);
        while( q--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            mp[u][v] = mp[v][u] = 0;//這是別人已經修好了的路,要用的話就是零消費
        }

        int ans = 0;
        ans = Prim();
        printf("%d\n",ans);
    }

    return 0;
}

 


/*Prim求最小生成樹*/
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 1e3+10;
const int maxm = 1e4+10;
int n,m;
int mp[maxn][maxn];
int lowcost[maxn];
int mst[maxn];

int Prim()
{
    //初始化
    lowcost[0] = -1;
    mst[0] = 0;
    for( int i = 1; i < n; i++)
    {
        lowcost[i] = mp[0][i];
        mst[i] = 0;
    }

    int mn,id;
    int sum = 0;
    for( int i = 1; i < n; i++)
    {
        mn = inf;
        id = 0;
        for( int j = 1; j < n; j++)
        {
            if( lowcost[j] < mn && lowcost[j] != -1)
            {
                mn = lowcost[j];
                id = j;
            }
        }

        sum += lowcost[id];
        lowcost[id] = -1;
        for( int j = 1; j < n; j++)
        {
            if( mp[id][j] < lowcost[j])
            {
                lowcost[j] = mp[id][j];
                mst[j] = id;
            }
        }
    }

    return sum;
}

int main()
{
    int flak = false;
    while( ~scanf("%d%d",&n,&m))
    {
        mem(mp,inf);
        int u,v,x;
        for( int i = 1; i <= m; i++)
        {
            scanf("%d%d%d",&u,&v,&x);
            if( u != v)//存在重邊的情況
            {
                mp[u][v] = min(mp[u][v],x);
                mp[v][u] = min(mp[v][u],x);
            }
        }

        int ans = Prim();
        int cnt = 0;
        for( int i = 0; i < n; i++)
            if( lowcost[i] == -1)
                cnt++;
        if( cnt != n)
            puts("impossible");
        else
            printf("%d\n",ans);
        puts("");
    }

    return 0;
}

 


/*Prim*/
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 1e2+10;
int n;
int mp[maxn][maxn];
int lowcost[maxn];
int mst[maxn];

int Prim()
{
    lowcost[1] = -1, mst[1] = 0;
    for( int i = 2; i <= n; i++)
        lowcost[i] = mp[1][i], mst[i] = 1;

    int mn, id;
    int sum = 0;
    for( int i = 2; i <= n; i++)
    {
        mn = inf;
        id = 0;
        for( int j = 2; j <= n; j++)
        {
            if( lowcost[j] < mn && lowcost[j] != -1)
            {
                mn = lowcost[j];
                id = j;
            }
        }

        sum += lowcost[id];
        lowcost[id] = -1;
        for( int j = 2; j <= n; j++)
        {
            if( mp[id][j] < lowcost[j])
            {
                lowcost[j] = mp[id][j];
                mst[j] = id;
            }
        }
    }
    return sum;
}

int main()
{
    while( ~scanf("%d",&n) && n)
    {
        mem(mp,inf);
        int m = n*(n-1)/2;
        int u,v,x;
        for( int i = 1; i <= m; i++)
        {
            scanf("%d%d%d",&u,&v,&x);
            mp[u][v] = x;
            mp[v][u] = x;
        }

        int ans = Prim();
        printf("%d\n",ans);
    }

    return 0;
}


#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 1e2+10;
int n,m;
int mp[maxn][maxn];
int lowcost[maxn];
int mst[maxn];

int Prim()
{
    lowcost[1] = -1;
    mst[1] = 0;
    for( int i = 2; i <= m; i++)
    {
        lowcost[i] = mp[1][i];
        mst[i] = 1;
    }

    int mn,id;
    int sum = 0;
    for( int i = 2; i <= m; i++)
    {
        mn = inf;
        id = 0;
        for( int j = 2; j <= m; j++)
        {
            if( lowcost[j] < mn && lowcost[j] != -1)
            {
                mn = lowcost[j];
                id = j;
            }
        }

        sum += lowcost[id];
        lowcost[id] = -1;
        for( int j = 2; j <= m; j++)
        {
            if( mp[id][j] < lowcost[j])
            {
                lowcost[j] = mp[id][j];
                mst[j] = id;
            }
        }
    }
    return sum;
}

int main()
{
    while( ~scanf("%d%d",&n,&m) && n)
    {
        mem(mp,inf);
        int u,v,x;
        for( int i = 0; i < n; i++)
        {
            scanf("%d%d%d",&u,&v,&x);
            mp[u][v] = min(mp[u][v],x);
            mp[v][u] = min(mp[v][u],x);
        }

        int ans = Prim();
        int cnt = 0;
        for( int i = 1; i <= m; i++)
        {
            if( lowcost[i] == -1)
                cnt++;
        }
        if( cnt != m)
            puts("?");
        else
            printf("%d\n",ans);
    }

    return 0;
}



#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 1e20
#define eps 1e-8
const int maxn = 1e2+10;
int n;
double mp[maxn][maxn];
double lc[maxn];
int vis[maxn];
struct Point{
    int x,y;
    Point(){}
    Point( int _x, int _y)
    {
        x = _x, y = _y;
    }
};
Point p[maxn];

int sgn( double x)
{
    if( fabs(x) < eps)
        return 0;
    if( x < 0)
        return -1;
    return 1;
}

int sqr( int x)
{
    return x*x;
}

double dist( Point a, Point b)
{
    return sqrt(1.0*(sqr(a.x-b.x)+sqr(a.y-b.y)));
}

double Prim()
{
    mem(vis,0);
    vis[1] = 1;
    for( int i = 2; i <= n; i++)
        lc[i] = mp[1][i];

    double mn;
    int id;
    double sum = 0;
    for( int i = 2; i <= n; i++)
    {
        mn = inf;
        id = 0;
        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] && lc[j] < mn)
            {
                mn = lc[j];
                id = j;
            }
        }
        sum += mn;
        vis[id] = 1;
        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] && mp[id][j] < lc[j])
                lc[j] = mp[id][j];
        }
    }
    return sum;
}

int main()
{
    int T;
    scanf("%d",&T);
    while( T--)
    {
        scanf("%d",&n);
        for( int i = 1; i <= n; i++)
            scanf("%d%d",&p[i].x,&p[i].y);

        for( int i = 1; i <= n; i++)
        {
            for( int j = 1; j <= n; j++)
            {
                mp[i][j] = inf;
                double dis = dist(p[i],p[j]);
                if( sgn(dis-10.0) >= 0 && sgn(dis-1000.0) <= 0)
                    mp[i][j] = dis;
            }
        }
        double ans = Prim();
        if( ans >= inf)
            puts("oh!");
        else
            printf("%.1f\n",ans*100);
    }

    return 0;
}



#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 5e2+10;
int n,m,k;
int mp[maxn][maxn];
int con[maxn];
int lc[maxn];
bool vis[maxn];
int ans;

void Prim()
{
    mem(vis,0);
    vis[1] = 1;
    for( int i = 2; i <= n; i++)
        lc[i] = mp[1][i];

    int pos = 1;
    ans = 0;
    for( int i = 2; i <= n; i++)
    {
        int mn = inf;
        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] &&  lc[j] < mn)
            {
                mn = lc[j];
                pos = j;
            }
        }

        ans += mn;
        if( mn == inf)
            return;
        vis[pos] = 1;

        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] && mp[pos][j] < lc[j])
                lc[j] = mp[pos][j];
        }
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    while( T--)
    {
        mem(mp,inf);
        scanf("%d%d%d",&n,&m,&k);
        int u,v,x;
        for( int i = 0; i < m; i++)
        {
            scanf("%d%d%d",&u,&v,&x);
            mp[u][v] = min(mp[u][v],x);
            mp[v][u] = min(mp[v][u],x);
        }

        while( k--)
        {
            int t;
            scanf("%d",&t);
            for( int i = 0; i < t; i++)
                scanf("%d",&con[i]);
            for( int i = 0; i < t; i++)
                for( int j = i+1; j < t; j++)
                    mp[con[i]][con[j]] = mp[con[j]][con[i]] = 0;
        }

        Prim();
        if( ans > inf)
            puts("-1");
        else
            printf("%d\n",ans);
    }


    return 0;
}



#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 0x3f3f3f3f
const int maxn = 1e2+10;
int n;
int mp[maxn][maxn];
int lc[maxn];
bool vis[maxn];
int ans;

void Prim()
{
    mem(vis,0);
    vis[1] = 1;
    for( int i = 2; i <= n; i++)
        lc[i] = mp[1][i];

    int pos = 1;
    ans = 0;
    for( int i = 2; i <= n; i++)
    {
        int mn = inf;
        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] &&  lc[j] < mn)
            {
                mn = lc[j];
                pos = j;
            }
        }

        ans += mn;
        if( mn == inf)
            return;
        vis[pos] = 1;

        for( int j = 2; j <= n; j++)
        {
            if( !vis[j] && mp[pos][j] < lc[j])
                lc[j] = mp[pos][j];
        }
    }
}

int main()
{
    while( ~scanf("%d",&n) && n)
    {
        mem(mp,inf);
        for( int i = 1; i < n; i++)
        {
            getchar();
            char ch;
            int u,v,x;
            scanf("%c",&ch);
            u = ch-'A'+1;
            int t;
            scanf("%d",&t);
            for( int i = 0; i < t; i++)
            {
                getchar();
                scanf("%c%d",&ch,&x);
                v = ch-'A'+1;
                mp[u][v] = min(mp[u][v],x);
                mp[v][u] = min(mp[v][u],x);
            }
        }
        // for( int i = 1; i <= n; i++)
        // {
        //     for( int j = 1; j <= n; j++)
        //     {
        //         if( mp[i][j] == inf)
        //             printf(" -1");
        //         else
        //             printf("%3d",mp[i][j]);
        //     }
        //     puts("");
        // }
        Prim();
        printf("%d\n",ans);
    }

    return 0;
}



/*Kruskal*/
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define inf 1e20;
const int maxn = 1e2+10;
const int maxm = 1e4+10;
int n;
struct Point{
    double x,y;
};
Point p[maxn];
struct Edge{
    int a,b;
    double dis;
    Edge(){}
    Edge( int _a, int _b, double _dis)
    {
        a = _a, b = _b, dis = _dis;
    }
};
Edge e[maxm];
int sz;//邊的條數
double ans;
int pre[maxn];

void Init()
{
    for( int i = 0; i < n; i++)
        pre[i] = i;
}

double sqr( double x)
{
    return x*x;
}

double dist( Point p0, Point p1)
{
    return sqrt(sqr(p0.x-p1.x)+sqr(p0.y-p1.y));
}

bool cmp( Edge e0, Edge e1)
{
    return e0.dis < e1.dis;
}

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

void Union( int x, int y)
{
    int px = Find(x);
    int py = Find(y);
    if( px != py)
        pre[px] = py;
}

void Kruskal()
{
    sort(e,e+sz,cmp);
    int edge = 0;
    for( int i = 0; i < sz && edge != n-1; i++)
    {
        if( Find(e[i].a) != Find(e[i].b))
        {
            Union(e[i].a,e[i].b);
            ans += e[i].dis;
            edge++;
        }
    }
}

int main()
{
    while( ~scanf("%d",&n))
    {
        for( int i = 0; i < n; i++)
            scanf("%lf%lf",&p[i].x,&p[i].y);
        sz = 0;
        for( int i = 0; i < n; i++)
        {
            for( int j = i+1; j < n; j++)
            {
                double dis = dist(p[i],p[j]);
                e[sz++] = Edge(i,j,dis);
            }
        }

        Init();
        ans = 0;
        Kruskal();
        printf("%.2f\n",ans);
    }

    return 0;
}


相關推薦

Prim和Kruskal求最小生成樹

前兩天TCP/IP協議課上,老師談到圖論中的幾個簡單演算法,發現自己不是很熟練,所以馬上掛了一套MST的題目來練練手,題目很簡單,但由於課程比較多,所以還有三個題沒來得及刷,同時在此%一波典 假設給出了一個圖G<V,E> 首先是Prim演算法,基於貪心的思想,任

Kruskal求最小生成樹

con sort ret += ace print int i++ clu 1 #include<bits/stdc++.h> 2 using namespace std; 3 const int maxn= 5e4+10; 4 const doubl

hdu4126_hdu4756_求最小生成樹的最佳替換邊_Kruskal and Prim

pac () this case dig bili tdi some roc 目錄 Catalog Solution： （有任何問題歡迎留言或私聊 && 歡迎交流討論哦 Catalog Problem： ?Portal: hdu4126 hdu4756

prim求最小生成樹

digi etc rhs kruskal getc truct dijk size nod 一直以來只會Kruskal prim和dijkstra很像 只不過prim維護的是最短的邊，而dijkstra維護的是最短的從起點到一個點的路徑 同時prim要註意當前拓展的邊

POJ 2485 - Highways（求最小生成樹的最大權值-Kruskal演算法）

題目 Language:Default Highways Time Limit: 1000MS

（Java資料結構和演算法）最小生成樹---Kruskal演算法（並查集）

該文章利用prime演算法求得連通圖的最小生成樹對應的邊權最小和，prime演算法是從頂點的角度思考和解決問題。本文介紹的Kruskal演算法將從邊的角度考慮並解決問題，利用了並查集方便地解決了最小生成樹的問題。 本文參考博文 //並查集 class UnionSameSet{

克魯斯卡爾（Kruskal）演算法求最小生成樹

                1、基本思想：設無向連通網為G＝(V, E)，令G的最小生成樹為T＝(U, TE)，其初態為U＝V，TE＝{ }，然後，按照邊的權值由小到大的順序，考察G的邊集E中的各條邊。若被考察的邊的兩個頂點屬於T的兩個不同的連通分量，則將此邊作為最小生成樹的邊加入到T中，同時把兩個連通分

Prim法求最小生成樹

     最小生成樹：對於一個帶權的無向連通圖，其每個生成樹所有邊上的權值之和可能不同，我們把所有邊上權值之和最小的生成樹稱為圖的最小生成樹。 普利姆法演算法：對於一個圖來說，要設立二個數組，一個數組用來記錄權值，陣列值來自開始頂點的權值，另一個數組 記錄每次加入的頂點，找

Prim演算法求最小生成樹的c++程式碼實現

Prim演算法是求解最小生成樹的常用方法，它的思想非常簡單，講所有的點集合V分為 已經放入最小生成樹集合的S和未放入的V-S，每次在V-S中選擇一個距離S最近的點放入到S中，直到所有的點都放入S。就是很簡單的貪心策略，不過可以證明是全域性最優，prim演算法對於稠密圖效果比

求最小生成樹和最短路徑的總結

1.求最小生成樹有兩種方法： ①克魯斯卡爾演算法：這個演算法是以邊為單位（包括邊的所有的資訊：兩個端點+權值）進行儲存的，然後將邊按照權值的從小到大的順序進行排序，然後將第一條邊連線起來，第二條邊連線起來，就這樣一直迴圈，直到所有的邊都被連線起來為止，在這期間，你需要判斷

Highways（求最小生成樹的最大權值-Kruskal演算法）

The island nation of Flatopia is perfectly flat. Unfortunately, Flatopia has no public highways. So the traffic is difficult in Flatopia. The Flatopian gov

prim 求最小生成樹（鄰接表）

#include <iostream> #include <cstring> #include <vector> using namespace std; const

【演算法——Python實現】有權圖求最小生成樹Prim演算法

class Edge(object): """邊""" def __init__(self, a, b, weight): self.a = a # 第一個頂點 self.b = b # 第二個頂點

Kruskal演算法求最小生成樹-演算法設計與分析實驗3

題目： 求如圖所示，用kruskal演算法求下面圖的最小生成樹： 話不多說，程式如下： #include<iostream> #include<stdlib.h> #define N 7 using namespace std; typedef

利用Kruskal演算法求最小生成樹解決聰明的猴子問題 -- 資料結構

題目：聰明的猴子 連結：https://ac.nowcoder.com/acm/problem/19964 在一個熱帶雨林中生存著一群猴子，它們以樹上的果子為生。昨天下了一場大雨，現在雨過天晴，但整個雨林的地 表還是被大水淹沒著，部分植物的樹冠露在水面上。猴子不會游泳，但跳躍能力比

Prim算法：最小生成樹－－－貪心算法的實現

http lin eai article log jre details otn 最小生成樹 算法圖解： http://baike.baidu.com/link?url=hGNkWIOLRJ_LDWMJRECxCPKUw7pI3s8AH5kj-944RwgeBSa9hGpT

BZOJ 1626 [Usaco2007 Dec]Building Roads 修建道路：kruskal（最小生成樹）

push_back spa pri family sca iostream 長度 con end 題目鏈接：http://www.lydsy.com/JudgeOnline/problem.php?id=1626 題意： 　　有n個農場，坐標為(x[i],y[i])。 　　

Prim算法解決最小生成樹

tor 一個 play spl 連通圖 輸入 rim 網絡 amp 一、最小生成樹問題 什麽是最小生成樹問題？給你一個帶權連通圖，需要你刪去一些邊，使它成為一顆權值最小的樹。 二、Prim算法 1）輸入：輸入一個帶權連通圖，頂點集合V，邊集合E 2）初始化：Vnew={x}

prim算法（最小生成樹）

operator const top scan node names name prim算法 最短路 其實prim算法和dijkstra算法差不多，不過迪傑斯特拉是算從 s->t 的最短路徑，而prim是算連接全圖的最短路徑 兩者都是從一個起點開始進行廣搜 但克魯斯卡

克魯斯卡爾求最小生成樹

角度 ems 不理解 += 重復 highlight 賦值 truct bool 處理何種問題：求解最小生成樹，適合點多邊少的無向圖。（以證明，放心用） 性能：時間復雜度為O(e*loge)，e為邊的個數。 原理：貪心策略 實現步驟： <1>設一個有