次小生成樹(Prim + Kruaskal)

 問題引入：

　　我們先來回想一下生成樹是如何定義的，生成樹就是用n - 1條邊將圖中的所有n個頂點都連通為一個連通分量，這樣的邊連成子樹稱為生成樹。

　　最小生成樹很明顯就是生成樹中權值最小的生成樹，那么我們即將要學的次小生成樹或者K小生成樹是怎么定義的呢，很明顯就是生成樹中權值第k小的生成樹。

　　下面給出劉老師書中對次小生成樹的定義，我是用自己的話描述的。

　　對於一個無向圖G(V, E)，其定義了邊權為W(u, v)，若T為他的一顆最小生成樹，那么我們假設存在一顆生成樹T1，不存在任意一顆G的生成樹T2滿足W(T) <= W(T2) < W(T1)，那么我們就稱T1為

G的次小生成樹。

 

非嚴格次小生成樹的求解：

　　我們知道最小生成樹我們是通過Prim和Kruskal這樣的貪心算法求得的，那么次小生成樹我們只是對這兩種算法進行我們需要的修改就可以進行次小生成樹的求解。

　　我們很容易可以想到最小生成樹和次小生成樹應該是有聯系的，那么是如何聯系的呢？次小生成樹就是圖G的所有生成樹中權值第二小的生成樹，也就是說我們只需要替換最小生成樹的一條邊(u, v)

就可以得到次小生成樹，顯然這條邊肯定不可以屬於原最小生成樹，如果我們將一條不屬於原最小生成樹的邊(u, v)加入T，那么此時T中就形成了一個環，我們在環中選一個除(u, v)權值最大的邊進行刪除

(想一下為什么是選擇權值最大的那條邊)，得到的樹依然是一顆圖G的生成樹，我們將所有邊逐個加入原最小生成樹T，得出並記錄所有的生成樹的權值T1，那么最后T1中最小的那個值即是次小生成樹的

權值。

 

 

下面只對與求解最小生成樹中不同的部分進行說明：

Prim：

　　我們知道Prim算法是以給定的任意點作為起始點運用一定的方法對所有點進行貪心處理，縮點從而生成一顆最小生成樹，那我們只需要用數組用來描述最小生成樹中每條邊的訪問情況以及最小

生成樹中每兩個頂點之間的最大邊權還需要保存最小生成樹中每個頂點的父親頂點，從而就可以方便用於計算次小生成樹。

　　具體操作：

　　　　初始化：初始化所有點( i )距離最小生成樹子樹的距離為cost[source][ i ]，所有邊初始化為未訪問，所有頂點之間的最大邊權初始化為0。

　　　　加邊：每次加入一條安全邊(這里不對安全邊進行解釋，有不了解的可以查閱博主的上一篇博客)，並將最小生成子樹中頂點之間的最大邊權進行更新，接着更新lowc即可。

　　　　求解次小生成樹：我們逐一枚舉出所有不屬於最小生成樹的邊(u, v)，並且用w(u, v)來替代最大邊權和Max(u, v)，怎么個替代法？ 

　　　　　　SecondMST = min(MST + w(u, v) - Max(u, v))    ((u, v) not belong to MST)。

　　　　　　OK?

參考代碼：

　　

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 1000 + 10, INF = 0x3f3f3f3f;
int n, m, lowc[maxn], pre[maxn], Max[maxn][maxn], cost[maxn][maxn];
bool vis[maxn], used[maxn][maxn];

int Prim() {
    int ans = 0;
    memset(vis, false, sizeof vis);
    memset(Max, 0, sizeof Max);
    memset(used, false, sizeof used);
    vis[1] = true;
    pre[1] = -1;
    for(int i = 2; i <= n; i ++) {
        lowc[i] = cost[1][i];
        pre[i] = 1;
    }
    lowc[1] = 0;
    for(int i = 2; i <= n; i ++) {
        int MIN = INF, p = -1;
        for(int j = 1; j <= n; j ++) {
            if(!vis[j] && MIN > lowc[j]) {
                MIN = lowc[j];
                p = j;
            }
        }
        if(MIN == INF)  return -1;
        ans += MIN;
        vis[p] = true;
        used[p][pre[p]] = used[pre[p]][p] = true;
        for(int j = 1; j <= n; j ++) {
            if(vis[j] && j != p) Max[j][p] = Max[p][j] = max(Max[j][pre[p]], lowc[p]);
            if(!vis[j] && lowc[j] > cost[p][j]) {
                lowc[j] = cost[p][j];
                pre[j] = p;
            }
        }
    }
    return ans;
}

int Second_Prim(int MST) {
    int ans = INF;
    for(int i = 1; i <= n; i ++)
        for(int j = i + 1; j <= n; j ++)
            if(!used[i][j] && cost[i][j] != INF) ans = min(ans, MST - Max[i][j] + cost[i][j]);
    return ans;
}

int main() {
    int t, a, b, c;
    scanf("%d", &t);
    while(t --) {
        scanf("%d %d", &n, &m);
        for(int i = 0; i <= n; i ++)
            for(int j = 0; j <= n; j ++)
                cost[i][j] = INF;
        for(int i = 1; i <= m; i ++) {
            scanf("%d %d %d", &a, &b, &c);
            cost[a][b] = cost[b][a] = c;
        }
        int MST = Prim();
        int Second_MST = Second_Prim(MST);
        printf("%d\n", Second_MST);
    }
    return 0;
}

 

 

 

Kruskal：

　　Kruskal算法是將圖G的所有邊進行排序，從小到大滿足邊的兩個頂點有一個不在subMST中就將其加入MST，在求解次小生成樹問題時我們也需要記錄MST中結點的連接情況，以及MST中兩個頂點

間的最大邊權。

　　具體操作：

　　　　初始化：初始化並查集，初始化在subMST中每個結點 i 直接或者間接相連的邊為i。

　　　　加邊：每次加入一條邊時，我們更新subMST中所有與u， v相連的結點間的最大邊權，接着將所有與結點v相連的邊都與結點u也連起來就行了(前提是在合並時head[ head[ v ] ] = head[ u ])。

　　　　求解次小生成樹：

　　　　　　SecondMST = min(MST + w(u, v) - Max(u, v))    ((u, v) not belong to MST)。滑稽.jpg

參考代碼：

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;

const int maxn = 1000 + 10, maxe = 1000 * 1000 / 2 + 5, INF = 0x3f3f3f3f;
int n, m, pre[maxn], head[maxn], Max[maxn][maxn];
struct Edge {
    int u, v, w;
    bool vis;
}edge[maxe];
vector<int> G[maxn];

bool cmp(const Edge &a, const Edge &b) {
    return a.w < b.w;
}

void Init() {
    for(int i = 1; i <= n; i ++) {
        G[i].clear();
        G[i].push_back(i);
        head[i] = i;
    }
}

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

int Kruskal() {
    sort(edge + 1, edge + 1 + m, cmp);
    Init();
    int ans = 0, cnt = 0;
    for(int i = 1; i <= m; i ++) {
        if(cnt == n - 1) break;
        int fx = Find(edge[i].u), fy = Find(edge[i].v);
        if(fx != fy) {
            cnt ++;
            edge[i].vis = true;
            ans += edge[i].w;
            int len_fx = G[fx].size(), len_fy = G[fy].size();
            for(int j = 0; j < len_fx; j ++)
                for(int k = 0; k < len_fy; k ++)
                    Max[G[fx][j]][G[fy][k]] = Max[G[fy][k]][G[fx][j]] = edge[i].w;
            head[fx] = fy;
            for(int j = 0; j < len_fx; j ++)
                G[fy].push_back(G[fx][j]);
        }
    }
    return ans;
}

int Second_Kruskal(int MST) {
    int ans = INF;
    for(int i = 1; i <= m; i ++)
        if(!edge[i].vis)
            ans = min(ans, MST + edge[i].w - Max[edge[i].u][edge[i].v]);
    return ans;
}

int main() {
    int t;
    scanf("%d", &t);
    while(t --) {
        scanf("%d %d", &n, &m);
        for(int i = 1; i <= m; i ++) {
            scanf("%d %d %d", &edge[i].u, &edge[i].v, &edge[i].w);
            edge[i].vis = false;
        }
        int MST = Kruskal();
        int Second_MST = Second_Kruskal(MST);
        printf("%d\n", Second_MST );
    }
    return 0;
}