Prim算法

多么痛的领悟！

不要认为Prim不常见就用不到！

和Kruskal一样，Prim算法也是用来求MST的，也是体现了贪心的思想。

不同的是，Kruskal是针对边而言的，Prim是针对点而言的。Kruskal适用于稀疏图，Prim适用于稠密图，更值得一提的是，Prim可以不必保存每条边。

算法思想是，设定两个集合V_new和E_new，先选中一个起点加入到V_new中，再从V-V_new（在V中且不在Vnew中）中选择一个点，使得该点到V_new中某个点的边权最小，将这条边加入E_new中，将这个点加入V_new中，不断重复该过程，直到V_new=V。

因为每次是通过某个点到已建好的树的最小边权将该点加入到生成树中的，所以最终构造出来的一定是最小生成树。

vis[1] = 1; //开始先将起点加入到Vnew
for (int i = 2; i <= n; ++i) minw[i] = G[i][1];
int index, mmin;
for (int i = 1; i < n; ++i) {
    mmin = 1e5 + 5;
    for (int j = 1; j <= n; ++j) //取出到Vnew中某个点边权最小的点
        if (!vis[j] && minw[j] < mmin) index = j, mmin = minw[j];
    vis[index] = 1;
    ans += mmin;
    for (int j = 1; j <= n; ++j) //用每次新加入的点更新其他点到Vnew中点的最小边权
        if(!vis[j] && G[j][index] < minw[j]) minw[j] = G[j][index];
}

对于Prim的初始化，还有一种写法。开始时并没有标记起点，而是将起点到V_new中某个点的最小边权置为0，这样就需要循环n次（相当于需要将n个点放入V_new中）。

另外，Prim还可以使用堆进行优化。自己尝试写了一个，因为是对于完全图，存图是用邻接矩阵，所以效率并没有明显提高（甚至下降）。另外，不得不说，Prim和Dijkstra太像了！

#include <cstring>
#include <queue>

using namespace std;

int dist[maxn], vis[maxn], ans = 0;

struct node {
    int id, dist;
    node(int i, int d) : id(i), dist(d) {}
    bool operator < (const node& rhs) const {
        return dist > rhs.dist;
    }
};

priority_queue<node> q;

memset(dist, 0x3f3f3f3f, sizeof(dist));
dist[1] = 0;
q.push(node(1, 0));
while (!q.empty()) {
    int u = q.top().id;
    q.pop();
    if (vis[u]) continue;
    vis[u] = 1;
    ans += dist[u];
    for (int v = 1; v <= n; ++v) { //这里是针对完全图，用的邻接矩阵
        if (v == u) continue; //改成邻接链表也可以
        if (dist[v] > dis(u, v)) {
            dist[v] = dis(u, v);
            q.push(node(v, dist[v]));
        }
    }
}