贪心法——最小生成树问题——prime算法和kruskal算法

贪心法——最小生成树问题——prime算法和kruskal算法

最小生成树

图的最小生成树是一棵包含图的所有顶点的树，其具有MST性质：最小生成树一定包含最小的连接两个顶点的边（反证法可证）。

由此可以得出两个结论：

1. 与某个节点相关的权值最小的边，一定在某个最小生成树中。
2. 权值最小的边，一定在某个最小生成树中。

根据这两个结论，分别产生了prime算法和kruskal算法。

prime算法

思路：

每次选取距离已选点集最近的那个未被选择的点，加入已选点集中，直到所有顶点都被选了为止。

从源点开始，每次从所有可选边（起点在当前生成树中但是终点不在）中选取权值最小加入当前的生成树中，直到边数为n-1为止。如边数不足n-1但是已经无法选取权值最小边，那么不存在最小生成树。（执行n-1次选取操作，中途选取不了就不存在最小生成树）

用一个数组记录每个点是否在当前最小生成树中，一个数组来记录当前最小生成树距离所有点的最短边长度（初始化为根距离其他所有点的最短边长度，用每次新加入的点距离所有点的短边长度来更新这个最短边数组），用邻接表或邻接矩阵存储图均可，这里使用邻接矩阵。

代码：

#include <bits/stdc++.h>

using namespace std;

#define MAXN 105
#define INF 0x3f3f3f

// vis记录每个顶点是否被选了，lowc记录每个顶点距离m已选顶点集合的最小距离
int vis[MAXN],lowc[MAXN];

// 邻接矩阵记录图
int m[MAXN][MAXN];

// prime算法计算图的最小生成树大小
int prime(int n){
    int res = 0;
    // 初始化操作
    memset(vis, 0, sizeof(vis));
    memset(lowc, INF, sizeof(lowc));
    // 选取第一个顶点
    vis[0] = 1;
    for(int i = 0;i < n;i++)
        lowc[i] = m[i][0];
    // 重复n-1次选取操作
    for(int i = 1;i < n;i++){
        // 找到当前距离已选顶点集合最近的未选择顶点
        int min = INF,p = -1;
        for(int j = 0;j < n;j++){
            if(vis[j]) continue;
            if(min > lowc[j]){
                min = lowc[j];
                p = j;
            }
        }
        res += min;
        // 假如找不到可选的点了
        if(p == -1) return -1;
        // 更新lowc，看其它未被选择的点距离已被选择的顶点集合的最短距离是否因为该点的加入而变小了
        // 假如是的话，那只能是该点到其它某个未被选择的点的距离
        // 小于那个未被选择的点的原来的到已被选择的集合的最短距离
        vis[p] = 1;
        lowc[p] = 0;
        for(int j = 0;j < n;j++){
            if(vis[j]) continue;
            if(m[j][p] < lowc[j]){
                lowc[j] = m[j][p];
            }
        }
    }
    return res;
}

int main(){
    int n = 6;
    
    memset(m, INF, sizeof(m));
    
    m[0][1] = 6;
    m[0][2] = 1;
    m[0][3] = 5;
    m[1][2] = 5;
    m[1][4] = 3;
    m[2][3] = 5;
    m[2][4] = 6;
    m[2][5] = 4;
    m[3][5] = 2;
    m[4][5] = 6;
    
    m[1][0] = 6;
    m[2][0] = 1;
    m[3][0] = 5;
    m[2][1] = 5;
    m[4][1] = 3;
    m[3][2] = 5;
    m[4][2] = 6;
    m[5][2] = 4;
    m[5][3] = 2;
    m[5][4] = 6;
    
    for(int i = 0;i < n;i++)
        m[i][i] = 0;
    
    cout<<prime(n);
}

复杂度：

时间复杂度：O(n²)

空间复杂度：O(n²)

kruskal算法

**思路：**每次选取不在同一个连通分量里的最小长度的边，将两个连通分量合并，直到n-1条边为止。

对所有的边按权值进行排序操作，从小到大遍历每一条边，假如该边连接的两个点不在同一个连通分量中，就这条边加入最小生成树。假如所有边遍历完成后，所有的点不在同一个连通分量中，那么不存在最小生成树；假如所有点在一个连通分量中，则找到了最小生成树。

kruskal算法用到一个并查集。

代码：

#include <bits/stdc++.h>

using namespace std;

#define MAXN 105
#define INF 0x3f3f3f

// 并查集
int f[MAXN];
// 不同的连通分量数量
int fcnt = 0;

// 并查集初始化，n个元素，每个元素分属不同的集合
void init(int n){
    for(int i = 0;i < n;i++)
        f[i] = i;
    fcnt = n;
}

// 查找某个元素a所在集合的代表元素
int find(int a){
    return f[a]==a?f[a]:find(f[a]);
}

// 将两个元素a，b所在的集合合并
bool unit(int a,int b){
    if(find(a)!=find(b)){
        f[find(a)] = find(b);
        fcnt--;
        return true;
    }
    return false;
}

struct Edge{
    int start;
    int end;
    int cost;
    Edge(int _start,int _end,int _cost){
        start = _start;
        end = _end;
        cost = _cost;
    }
};

vector<Edge> e;

bool cmp(Edge e1,Edge e2){
    return e1.cost<e2.cost;
}

// kruskal算法求最小生成树的大小
int kruskal(int n){
    init(n);
    int res = 0;
    // 找权值最小的边
    sort(e.begin(),e.end(),cmp);
    for(int i = 0;i < e.size();i++){
        // 假如属于两个不同的连通分量，合并这两个分量
        if(find(e[i].start) != find(e[i].end)){
            res += e[i].cost;
            unit(e[i].start, e[i].end);
        }
    }
    if(fcnt == 1) return res;
    
    return -1;
}

int main(){
    int n = 6;
    e.push_back(Edge(1,2,6));
    e.push_back(Edge(1,3,1));
    e.push_back(Edge(1,4,5));
    e.push_back(Edge(2,3,5));
    e.push_back(Edge(2,5,3));
    e.push_back(Edge(3,4,5));
    e.push_back(Edge(3,5,6));
    e.push_back(Edge(3,6,4));
    e.push_back(Edge(4,6,2));
    e.push_back(Edge(5,6,6));
    
    cout<<kruskal(n);
}

复杂度：
e条边，组成优先队列，每次取出一条边O(loge)，另外，find与union需要O(loge)，故算法所需的计算时间为 O(eloge)。
复杂度分析有些难搞，此处略。