最小生成樹的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;
}