CCF-CSP 201412-4 最优灌溉（prim算法版本）

问题描述

　　雷雷承包了很多片麦田，为了灌溉这些麦田，雷雷在第一个麦田挖了一口很深的水井，所有的麦田都从这口井来引水灌溉。
　　为了灌溉，雷雷需要建立一些水渠，以连接水井和麦田，雷雷也可以利用部分麦田作为“中转站”，利用水渠连接不同的麦田，这样只要一片麦田能被灌溉，则与其连接的麦田也能被灌溉。
　　现在雷雷知道哪些麦田之间可以建设水渠和建设每个水渠所需要的费用（注意不是所有麦田之间都可以建立水渠）。请问灌溉所有麦田最少需要多少费用来修建水渠。

输入格式

　　输入的第一行包含两个正整数n, m，分别表示麦田的片数和雷雷可以建立的水渠的数量。麦田使用1, 2, 3, ……依次标号。
　　接下来m行，每行包含三个整数ai, bi, ci，表示第ai片麦田与第bi片麦田之间可以建立一条水渠，所需要的费用为ci。

输出格式

　　输出一行，包含一个整数，表示灌溉所有麦田所需要的最小费用。

样例输入

4 4
1 2 1
2 3 4
2 4 2
3 4 3

样例输出

6

样例说明

　　建立以下三条水渠：麦田1与麦田2、麦田2与麦田4、麦田4与麦田3。

评测用例规模与约定

　　前20%的评测用例满足：n≤5。
　　前40%的评测用例满足：n≤20。
　　前60%的评测用例满足：n≤100。
　　所有评测用例都满足：1≤n≤1000，1≤m≤100,000，1≤ci≤10,000。

最小生成树，不过需要注意的一点是，图不是连通的，因此也许有多棵树~
以下是prim算法的版本~

#include <iostream>  
#include <algorithm>  
#include <vector>
#include <memory.h>
#include <queue>
//#include <fstream>

using namespace std;

//定义边的类型
class Edge
{
public:
    int u; // 起点
    int v; // 终点
    int w; // 权重

    Edge(int uu = 0, int vv = 0, int ww = 0) :u(uu), v(vv), w(ww){}
};

//用于构造最小堆的比较类型
class CmpEdge
{
public:
    bool operator ()(const Edge & a, const Edge & b)
    {
        return a.w > b.w;
    }
};

const int inf = 0x3f3f3f3f;
const int maxn = 1001;

vector<Edge> adj[maxn]; //边的邻接表
priority_queue<Edge, vector<Edge>, CmpEdge > he; //优先队列(最小堆)，保存需要遍历的边
bool vsd[maxn]; // 标记顶点是连通

int n;
int m;
int cost; // 最后结果
int edgeNum; 

// 更新边的操作
void Enqueue(int u)
{
    for (int i = 0; i < adj[u].size(); i++)
    {
        if (!vsd[adj[u][i].v]) // 这里判断边是否有意义，剪枝~
            he.push(adj[u][i]);
    }
}

// 算法的主要流程
void Run(int s)
{
    Enqueue(s);
    vsd[s] = true;

    Edge e;
    while (!he.empty())
    {
        e = he.top();
        he.pop();
        if (!vsd[e.v])
        {       
            vsd[e.v] = true;
            cost += e.w;
            edgeNum++;
            Enqueue(e.v);
        }
        if (edgeNum == n - 1)
            break;  
    }
}


int main()
{
    //ifstream cin("a.txt");
    int u, v, w;

    memset(vsd, 0, sizeof(vsd));

    cin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        cin >> u >> v >> w;
        adj[u].push_back(Edge(u, v, w)); 
        adj[v].push_back(Edge(v, u, w));
    }

    edgeNum = 0;
    cost = 0;
    for (int i = 1; i <= n; i++) //
    {
        if (!vsd[i])
        {
            Run(i);
        }
    }

    cout << cost << endl;
    //cin.close();
    return 0;
}