【数据结构与算法/图论】Prim和Kruskal最小生成树算法正确性的证明

一、最小生成树简介

一个有$n$个顶点的连通图$G=(V,E)$的生成树是包含$G$中全部顶点的一个极小连通子图，它有且仅有$n-1$条边。也就是说，如果添加一条边，则构成回路；如果删去任何一条边，则生成树不再连通。一个生成树的代价为该生成树中所有边权的总和。称代价最小的生成树为最小生成树（Minimum Spanning Tree, MST）。

最小生成树是图的一种重要应用，在城市道路交通规划、网络路由选择、城市通信网架设等实际问题中应用广泛。例如，在$n$个城市之间架设通信网路，最多可设置$\frac{n(n-1)}{2}$条线路，每条线路都有一定的成本，如何从这$\frac{n(n-1)}{2}$条线路中选择$n-1$条线路，使得总成本最小？将这一问题表示为带权连通图，用图中的顶点表示城市，边表示城市之间的通信线路，边的权值为设置该线路所需的成本，则问题就可以转化为求这个图的最小生成树。

二、最小生成树的性质

定理1 最小生成树的子树也是最小生成树。
证明：设$T=(V,E_T)$是图$G$的一棵最小生成树，$T^{\prime }=(U,E_U)\subseteq T$，下面证明$T^{\prime }$是$U$的导出子图$G^{\prime }$的最小生成树。若$T^{\prime }$不是$G^{\prime }$的最小生成树，则取$G^{\prime }$的最小生成树$T^{\ast }$，用$T^{\ast }$中的边替换$T$在$U$中的边$E_U$可以得到代价更小的生成树，这与$T$是最小生成树矛盾。因此$T^{\prime }$一定是$G^{\prime }$的最小生成树。∎

定理2（Key Property） 设$T=(V,E_T)$是图$G=(V,E)$的一棵最小生成树，$w(e)$表示边$e$的权值。假设$F\subseteq E_T$（即$F$是$T$的边集的子集），$U\subset V$是$G$的一个点集，边集$M=\{(u,v)\in E|u\in U,v\in V-U\}$是所有连接$U$和$V-U$的边的集合，且$F\cap M=\varnothing$。设$e$是$M$中权值最小的边，则 F ∪ { e } F\cup\{e\} F∪{e}是某个最小生成树$T^{\prime }$（可能不等于$T$）的边集的子集。
证明：若$e\in T$，则无需证明。所以我们假设$e\notin T$。
将$e$加入$T$的边集$E_T$中，必形成回路。取$e^{\prime }\in E_T\cap M$（即$e^{\prime }$是$T$中连接$U$和$V-U$的桥梁），则有$w(e)\le w(e^{\prime })$。令 T ′ = ( V , ( E T − { e ′ } ) ∪ { e } ) T'=(V,(E_T-\{e'\})\cup\{e\}) T′=(V,(ET​−{e′})∪{e})，则$T^{\prime }$的代价不高于$T$，所以$T^{\prime }$是一棵最小生成树。∎

三、Prim算法

设$G=(V,E)$为带权连通图，要在$G$中构造一棵最小生成树$T=(U,E_T)$。Prim算法的基本思想如下：
(1) 初始化顶点集 U = { u 0 } U=\{u_0\} U={u0​}，其中$u_0\in V$是$U$中唯一的元素；令$E_T=\varnothing$，即一开始树中没有边。
(2) 在所有满足$u\in U$、$v\in V-U$的边$(u,v)\in E$中选择一条权值最小的边$e=(u^{\ast },v^{\ast })$加入最小生成树的边集$E_T$中，同时将顶点$v^{\ast }$并入$U$中。
重复以上过程，直到$U=V$为止。此时$|E_T|=n-1$，$T$是$G$的一棵最小生成树。

因为每次操作是将一个节点并入$U$中，所以Prim算法也称扩点法。

正确性证明：

归纳假设：每一步得到的树$T_U=(U,E_U)$是都是某棵最小生成树的子树。
① 归纳基础：初始条件 T { u 0 } = ( { u 0 } , ∅ ) T_{\{u_0\}}=(\{u_0\},\emptyset) T{u0​}​=({u0​},∅)是所有最小生成树的子树（因为空集是所有集合的子集）。
② 归纳步：设我们已经得到$T_U=(U,E_U)$是最小生成树$T$的子树。按规则选取边$e=(u^{\ast },v^{\ast })$。根据定理2， E U ∪ { e } E_U\cup\{e\} EU​∪{e}是某棵最小生成树$T^{\prime }$的边集的子集。因此该步得到的树 T U ∪ { v ∗ } = ( U ∪ { v ∗ } , E U ∪ { e } ) T_{U\cup\{v^*\}}=(U\cup\{v^*\},E_U\cup\{e\}) TU∪{v∗}​=(U∪{v∗},EU​∪{e})是$T^{\prime }$的最小生成树。
③ 终止：最后$U=V$时，$T_V=(V,E_V)$是某棵最小生成树的子树，而这棵最小生成树就是$T_V$本身，因此我们求得了$G$的一棵最小生成树。∎

代码实现：

(1) 不加优化的暴力解法

暴力选取边$e=(u^{\ast },v^{\ast })$。时间复杂度$O(nm)$。

int Prim()
{
    in[1] = true; // u0
    int ans = 0;
    for(int i = 1; i < n; ++i)
    {
        int min_val = 1e9, min_e = -1;
        for(int u = 1; u <= n; ++u)
        {
            if(!in[u]) continue;
            for(int e = first[u]; e; e = nxt[e])
            {
                int v = go[e];
                if(in[v]) continue;
                if(val[e] < min_val)
                {
                    min_val = val[e];
                    min_e = e;
                }
            }
        }
        in[go[min_e]] = true;
        ans += min_val;
    }
    return ans;
}

(2) 堆优化的Prim算法

用堆来优化选取权值最小的边$e=(u^{\ast },v^{\ast })$的过程。我们定义vis数组表示节点是否属于集合$U$，dis数组表示$V-U$中的节点到$U$的最短边。每当我们向$U$中加入一个节点，就将它的vis标记为true，并更新它所连接的节点的dis值，若dis值被更新就将这条边加入堆中。从堆中取出最小值时，有可能边的两个端点都在$U$中了，所以要检查端点的vis值。注意，堆中存储的边不是集合$M=\{(u,v)\in E|u\in U,v\in V-U\}$，有两点区别：
① 堆中可能会有两端点都属于$U$的边；
② 当dis值没有被更新时，该边不会入队，从而降低了时间复杂度。

时间复杂度：下面的代码复杂度高达$O(m\log m)$，因为同一个v可能在Q里出现多次，导致堆中元素数量在$O(m)$级别。但堆优化的Prim算法复杂度理论上是$O(m\log n)$的，在$Q$里进行的操作是Decrease Key，即改变某个节点对应的dis值，这样每个节点只会在堆中出现一次。

int dis[MAXN];
bool vis[MAXN];

int Prim()
{
    int ans = 0;
    memset(dis, 0x3f, sizeof(dis));
    priority_queue<node> Q;
    Q.push({1, 0});
    for(int cnt = 1; cnt <= n;)
    {
        node nd = Q.top();
        Q.pop();
        int u = nd.u;
        if(vis[u]) continue;
        vis[u] = true;
        ans += nd.d;
        ++cnt;
        for(int e = first[u]; e; e = nxt[e])
        {
            int v = go[e];
            if(dis[v] > val[e])
            {
                dis[v] = val[e];
                Q.push({v, val[e]});
            }
        }
    }
    return ans;
}

四、Kruskal算法

Kruskal算法的基本思想如下：
(1) 初始状态为$T=(V,\varnothing )$，即开始时最小生成树$T$中只包含了所有的顶点，而没有边，此时$T$中有$n$个连通分量。
(2) 将$E$中的边按权值递增的顺序排列，并按照这一顺序一次尝试将边加入最小生成树$T$中：如果这条边的端点分别位于$T$的不同的连通分量中，则将该边加入$T$；否则舍弃该边（为了保证不出现环）。
依此类推，直到$T$中有$n-1$条边为止，此时$T$中只有一个连通分量。

正确性证明：

考虑加入边$e=(u,v)$的操作。假设已经被算法选定的边集为$E_U$，令$E_U$中所有边关联的所有顶点的集合为$U$。显然，$U$和$V-U$是不连通的。根据定理2，我们只需证明$e$是连接集合$U$和$V-U$的权值最小的边，就能推出最后得到的树是最小生成树。

假设还有比$e$权值更小的连接集合$U$和$V-U$的边$e^{\prime }$，则根据算法的步骤，$e^{\prime }$一定会在$e$之前被算法考虑。因为此时$U$和$V-U$一定不连通（否则后面考虑$e$的时候$U$和$V-U$就连通了），所以$e^{\prime }$一定会被选择。但加入边$e^{\prime }$后会导致$U$和$V-U$连通，与已知条件矛盾。所以假设不成立，我们证明了$e$是连接集合$U$和$V-U$的权值最小的边。∎

代码实现：

边按权值排序+并查集。时间复杂度$O(m\log m)$。

struct edge
{
    int u, v, w;
    bool operator<(const edge& o) const
    {
        return w < o.w;
    }
} e[MAXM];

int fa[MAXN]; // 并查集

int getfa(int x)
{
    return x == fa[x] ? x : fa[x] = getfa(fa[x]);
}

int Kruskal()
{
    sort(e + 1, e + m + 1); // 按边权排序
    for(int i = 1; i <= n; ++i) fa[i] = i;
    int k = 0, ans = 0;
    for(int i = 1; i <= m && k < n; ++i)
    {
        int x = getfa(e[i].u);
        int y = getfa(e[i].v);
        if(x != y)
        {
            ++k;
            ans += e[i].w;
            fa[x] = y;
        }
    }
    return ans;
}

参考文献

1. https://courses.cs.duke.edu/spring19/compsci330/lecture13scribe.pdf
2. https://courses.cs.duke.edu/spring19/compsci330/lecture14scribe.pdf