最小生成树求法 Prim + Kruskal

prim算法的思路 和dijkstra是一样的

每次选取一个最近的点 然后去向新的节点扩张 注意这里的扩张 不再是 以前求最短路时候的到新的节点的最短距离

而是因为要生成一棵树 所以是要连一根最短的连枝 所以关键部分修改一下

dist[u] = min(dist[u], e.cost) --->>e是连接 v 和 u的边

同样地 普同写法O(v^2) 用队列优化后O(E*logV)

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
#define MAXV 256
#define MAXE 256
#define INF 0x3f3f3f3f

using namespace std;
typedef pair<int,int> P;
int V, E;
//和dijkstra完全一样
//书上写法 O(V^2)
int graph[MAXV][MAXV];
int prim()
{
    int dist[MAXV];
    int res = 0;
    bool use[MAXV];
    fill(dist, dist+MAXV, INF);
    fill(use, use+MAXV, 0);
    dist[1] = 0;//假定1为源点
    while (true)
    {
        int v = -1;
        for (int i = 1; i <= V; i++)
        {
            if (!use[i] && (v == -1 || dist[i] < dist[v])) v = i;//查找离原点最近的点
        }
        if (v == -1) break;
        use[v] = true;
        res += dist[v];
        cout << dist[v] << endl; //打印树枝的情况
        for (int i = 1; i <= V; i++)
        {
            dist[i] = min(dist[i], graph[v][i]);//这里是唯一的区别  --->>.但其实 这个dist中的值 最后是有问题的 这样最后dist保存的 是离它最近的一个节点的边的值
            //第33行打印的结果之所以正确是因为 按着离原点最近的顺序 向外扩张 在dist改变之前已经打印了 但是打印之后它的值是可能会发生改变的
            /*
            3).重复下列操作，直到Vnew = V：

a.在集合E中选取权值最小的边<u, v>，其中u为集合Vnew中的元素，
而v不在Vnew集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

b.将v加入集合Vnew中，将<u, v>边加入集合Enew中；
            */
        }
    }
    return res;
}

//使用堆维护 再使用prim O(E*logV)
struct Edge
{
    int to, cost, next;
    Edge() {}
    Edge(int to, int cost, int next) : to(to), cost(cost), next(next) {}
}edge[MAXE];
int num = 0;
int head[MAXV];
void Add(int from, int to, int cost)
{
    edge[num] = Edge(to, cost, head[from]);
    head[from] = num++;
}

int prim2()
{
    int dist[MAXV], res = 0;
    bool use[MAXV];
    fill(use, use+MAXV, false);
    fill(dist, dist+MAXV, INF);
    priority_queue<P, vector<P>, greater<P> > que;
    dist[1] = 0;//假定1为源点
    que.push(P(dist[1], 1));//first -->距离 second -->编号
    while(!que.empty())
    {
        P p = que.top();
        que.pop();
        if (!use[p.second])//这个也是那个问题 先前点(作为现在去扩张的点 如果被打印过 就不再去打印它了 总之算法思路就是 从原点开始 让最近的一个点去扩张)
        {
            res += dist[p.second];
            cout << dist[p.second] << endl;
        }
        use[p.second] = true;
        if (dist[p.second] < p.first)
        {
            continue;
        }
        int t = head[p.second];
        while (t != -1)
        {
            Edge e = edge[t];
            if (!use[e.to] && dist[e.to] > e.cost)
            {
                dist[e.to] = e.cost;
                que.push(P(e.cost, e.to));
            }
            t = e.next;
        }
    }
    return res;
}


int main()
{
    freopen("in.txt", "r", stdin);
    scanf("%d%d", &V, &E);
    memset(edge, -1, sizeof(edge));
    memset(head, -1, sizeof(head));
    for(int i = 1; i <= V; i++)
        for (int j = 1; j <= V; j++) graph[i][j] = INF;
    for (int i = 0; i < E; i++)
    {
        int from, to, cost;
        scanf("%d%d%d", &from, &to, &cost);
        graph[from][to] = cost;
        graph[to][from] = cost;
        Add(from, to, cost);
        Add(to, from, cost);
    }
    int ans = prim2();
    cout << ans << endl;
}

Kruskal -->> O(E*logV)  思路就更加的简单

将所有的边 排序 

贪心地从小到大取 如果连接进一个新的点 就加入树枝的集合中 最终 得到的边的集合就是最小生成树

这里判断是否是新的节点 就是判断连通性 那么就使用并查集非常容易

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#define MAXV 256
#define MAXE 256
#define INF 0x3f3f3f3f
using namespace std;

int E, V;
//Kruskal 思路: 按边的角度出发 将边从小到大排序 如果 from to 不再一个连通块中 就可以取这一条边(不会产生环)
struct Edge
{
    int from, to, cost;
    Edge(){}
    Edge(int from, int to, int cost) : from(from), to(to), cost(cost) {}
}edge[MAXE];

int par[MAXV];
int find(int x)
{
    if(x == par[x]) return x;
    else return par[x] = find(par[x]);
}
void unite(int x, int y)
{
    int px = find(x), py = find(y);
    if (px == py) return ;
    else par[py] = px;
}
bool same(int x, int y)
{
    int px = find(x), py = find(y);
    return px == py;
}

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

//O(E*logV) -->>对于并查集的操作是logN
int Kruskal()
{
    int res = 0;
    for (int i = 1; i <= V; i++) par[i] = i;
    sort(edge, edge+E, cmp);
    for (int i = 0; i < E; i++)
    {
        Edge e = edge[i];
        if (!same(e.from, e.to))
        {
            cout << e.from << " " << e.to << " : " << e.cost << endl;
            res += e.cost;
            unite(e.from, e.to);
        }
    }
    return res;
}

int main()
{
    freopen("in.txt", "r", stdin);
    scanf("%d%d", &V, &E);
    for (int i = 0; i < E; i++)
    {
        int from, to, cost;
        scanf("%d%d%d", &from, &to, &cost);
        edge[i] = Edge(from, to, cost);
    }
    int ans = Kruskal();
    cout << ans << endl;
    return 0;
}

转一篇写的很详细的博客

http://www.cnblogs.com/biyeymyhjob/archive/2012/07/30/2615542.html