(模板)HDU - 1233 还是畅通工程（Prime + 堆优化 && Kluskal）

Problem Description

某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。

 

 

Input

测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
当N为0时，输入结束，该用例不被处理。

 

 

Output

对每个测试用例，在1行里输出最小的公路总长度。

 

 

Sample Input

3

1 2 1

1 3 2

2 3 4

4

1 2 1

1 3 4

1 4 1

2 3 3

2 4 2

3 4 5 

0

 

 

Sample Output

3

5

Hint

Hint Huge input, scanf is recommended.

---

大致题意：中文题意

解题思路：就是裸的最小生成树

---

//Kruskal
#include <cstdio>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <vector>
#define met(a, b) memset(a, b, sizeof(a))
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e5 + 10;
using namespace std;

typedef struct EdgeNode
{
    int u, v, w;
    EdgeNode(int _u, int _v, int _w) { u = _u, v = _v, w = _w; }
}edges;

bool cmp(edges x, edges y)
{
    return x.w < y.w;
}

struct Kruskal
{
    int F[MAXN];
    vector<edges> V;
    void init(int n)
    {
        for (int i = 0; i <= n; i++)
            F[i] = i;
        V.clear();
        return ;
    }
    void add(int u, int v, int w)
    {
        V.push_back(edges(u, v, w));
        return ;
    }
    int Find(int x)
    {
        if (x != F[x])
            F[x] = Find(F[x]);
        return F[x];
    }
    void Union(int x, int y)
    {
        x = Find(x);
        y = Find(y);
        F[x] = y;
        return ;
    }
    int kruskal()
    {
        sort(V.begin(), V.end(), cmp);
        int ans = 0;
        for (int i = 0; i < V.size(); i++)
        {
            if (Find(V[i].u) != Find(V[i].v))
                ans += V[i].w, Union(V[i].u, V[i].v);
        }
        return ans;
    }
}Krl;

int main()
{
    int n;
    while (cin >> n && n)
    {
        Krl.init(n);
        for (int i = 1; i < n; i++)
        {
            char u;
            int m;
            cin >> u >> m;
            while (m--)
            {
                char v;
                int w;
                cin >> v >> w;
                Krl.add(u - 'A' + 1, v - 'A' + 1, w);
            }
        }
        cout << Krl.kruskal() << endl;
    }
    return 0;
}


//Prime + 堆优化
#include <cstdio>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <queue>
#define met(a, b) memset(a, b, sizeof(a))
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e4 + 10;
using namespace std;

typedef struct EdgeNode
{
    int to, w, next;
    EdgeNode(int _to, int _w, int _next) { to = _to, w = _w, next = _next; }
}edges;

typedef struct HeapNode
{
    int now, w;
    HeapNode(int _now, int _w) { now = _now; w = _w; }
    bool operator < (const HeapNode& rhs) const
    {
        return w > rhs.w;
    }
}node;

struct Prime
{
    int idx;
    vector<edges> V;
    int dis[MAXN], head[MAXN], vis[MAXN];
    void init()
    {
        met(dis, 0x3f);
        met(vis, 0);
        met(head, -1);
        V.clear();
        idx = 0;
        return ;
    }
    void add(int u, int v, int w)
    {
        V.push_back(edges(v, w, head[u]));
        head[u] = idx++;
        return ;
    }
    int prime()
    {
        int ans = 0;
        priority_queue<node> Q;
        dis[1] = 0;
        Q.push(node(1, dis[1]));
        while (!Q.empty())
        {
            node q = Q.top(); Q.pop();
            if (vis[q.now])
                continue;
            vis[q.now] = 1;
            ans += dis[q.now];
            for (int i = head[q.now]; i != -1; i = V[i].next)
            {
                int to = V[i].to;
                if (!vis[to] && dis[to] > V[i].w)
                    dis[to] = V[i].w, Q.push(node(to, dis[to]));
            }
        }
        return ans;
    }
}Pim;


int main()
{
    int n;
    while (cin >> n && n)
    {
        Pim.init();
        n = n * (n - 1) / 2;
        for (int i = 0; i < n; i++)
        {
            int u, v, w;
            cin >> u >> v >> w;
            Pim.add(u, v, w);
            Pim.add(v, u, w);
        }
        cout << Pim.prime() << endl;
    }
    return 0;
}