基于堆优化的Prim，另附kruskal解法

最小生成树的Prim算法也是贪心算法的一大经典应用。Prim算法的特点是时刻维护一棵树，算法不断加边，加的过程始终是一棵树。

Prim算法过程：

一条边一条边地加， 维护一棵树。

初始 E ＝ ｛｝空集合， V = ｛任意节点｝

循环（n – 1）次，每次选择一条边（v1,v2）， 满足：v1属于V , v2不属于V。且（v1,v2）权值最小。

E = E + （v1,v2）
V = V + v2

最终E中的边是一棵最小生成树， V包含了全部节点。
最后，我们来提供输入输出数据，由你来写一段程序，实现这个算法，只有写出了正确的程序，才能继续后面的课程。

输入

第1行：2个数N,M中间用空格分隔，N为点的数量，M为边的数量。（2 <= N <= 1000, 1 <= M <= 50000)
第2 - M + 1行：每行3个数S E W，分别表示M条边的2个顶点及权值。(1 <= S, E <= N，1 <= W <= 10000)

输出

输出最小生成树的所有边的权值之和。

输入示例

9 14
1 2 4
2 3 8
3 4 7
4 5 9
5 6 10
6 7 2
7 8 1
8 9 7
2 8 11
3 9 2
7 9 6
3 6 4
4 6 14
1 8 8

输出示例

37

对于prim， 如果每次都遍历包含在已构造生成树的点集的minCost[v]，需要O(V2)时间。
但是如果用堆来维护minCost[v]，则可以把时间降为O(ElogV)

Prim实现：

#include <cstdio>
#include <set>
#include <queue>
#include <vector>
#include <utility>
#include <cstring>
using namespace std; 

typedef long long ll;
typedef pair<int, int> pii;
const int EMAX = 5000 + 10;
const int VMAX = 1000 + 10;

struct Node {
  int a, b;
  ll w;
  Node(int x, int y, ll z) {
    a = x, b = y, w = z;
  }
  bool operator < (const Node &n) const {
    return w > n.w;
  }
};

int vNum, eNum;
bool look[VMAX];
vector<pii> e[EMAX];
set<int> v;

void Init() {
  memset(look, 0, sizeof(look));
  for (int i = 0; i < EMAX; ++i) {
    e[i].clear();
  }
  v.clear();
}

ll Prim(int s) {
  priority_queue<Node> que;
  que.push(Node(s, s, 0));
  ll ans = 0;
  while (!que.empty()) {
    Node head = que.top(); que.pop();
    if (look[head.b]) continue;
    look[head.b] = true;
    ans += head.w;
    for (int i = 0; i < e[head.b].size(); ++i) {
      pii &edge = e[head.b][i];
      if (!look[edge.first]) {
        que.push(Node(head.b, edge.first, edge.second));
      }
    }
  }
  return ans;
}

int main() {
#ifndef ONLINE_JUDGE
  freopen("in.txt", "r", stdin);
#endif
  while (scanf("%d%d", &vNum, &eNum) != EOF) {
    Init();
    int a, b, w;
    for (int i = 0; i < eNum; ++i) {
      scanf("%d%d%d", &a, &b, &w);
      e[a].push_back(pii(b, w));
      e[b].push_back(pii(a, w));
      v.insert(a);
      v.insert(b);
    }
    printf("%lld\n", Prim(a));
  }
  return 0;
}

Kruskal实现：

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

typedef long long ll;
const int EMAX = 5000 + 10;
const int VMAX = 1000 + 10;

struct Edge {
  int a, b, w;
  Edge(int x, int y, int z) {
    a = x, b = y, w = z;
  }
  bool operator < (const Edge &arg) const {
    return w < arg.w;
  }
};

int vNum, eNum, father[VMAX];
vector<Edge> e;

void Init() {
  e.clear();
  for (int i = 0; i < VMAX; ++i) {
    father[i] = i;
  }
}

int Find(int x) {
  return father[x] == x ? x : father[x] = Find(father[x]);
}

void Unite(int a, int b) {
  a = Find(a), b = Find(b);
  if (a != b) {
    father[b] = a;
  }
}

ll Kruskal() {
  sort(e.begin(), e.end());
  ll ans = 0;
  for (int i = 0; i < eNum; ++i) {
    if (Find(e[i].a) != Find(e[i].b)) {
      ans += e[i].w;
      Unite(e[i].a, e[i].b);
    }
  }
  return ans;
}

int main() {
#ifndef ONLINE_JUDGE
  //freopen("in.txt", "r", stdin);
#endif
  while (scanf("%d%d", &vNum, &eNum) != EOF) {
    Init();
    int a, b, w;
    for (int i = 0; i < eNum; ++i) {
      scanf("%d%d%d", &a, &b, &w);
      e.push_back(Edge(a, b, w));
    }
    printf("%lld\n", Kruskal());
  }
  return 0;
}