POJ2485 Highways（最小生成树模版题，Prim+kruskal）

题目
题目输入为一个图的邻接矩阵，求图的最小生成树中最长边的权值。
直接用Prim算法解决，详细原理可以参考我的这篇博客

假设 N = { V , { E } } N=\{V,\{E\}\} N={V,{E}}是连通网，$TE$是$N$上最小生成树的边集合，Prim算法将图中所有顶点分为两类，一类为集合$U$，该集合中的点表示该点已经被选取为生成树上的一个点，另一类为集合$V-U$，表示还未被选取为生成树中的点，其中$V$为图中所有点的集合。算法可以选取集合$V$中的任意一个顶点初始化集合$U$，即 U = { u 0 } ( u 0 ∈   V ) U=\{ u_0\}(u_0\in_\ V) U={u0​}(u0​∈ ​V)。考虑集合$U$与集合$V-U$中相连的各条边，选取其中权值最小的那一条边$(u,v)\in E，u{\in }_{}U,v\in V-U$，其中$E$为图中的边集，将点$v$加入集合$U$，边$(u,v)$并入集合$TE$，重复上诉过程直至$U=V$为止。此时$TE$中必有$n-1$条边，则 T = ( V , { T E } ) T=(V,\{TE\}) T=(V,{TE})为$N$的最小生成树。

Prim

#include "iostream"
#include "vector"
#include "climits"
#include "algorithm"

using namespace std;
const int INF = INT_MAX;

int N;

int slove(vector<vector<int> > &map){
    vector<int> U;//最小生成树中的点集合
    vector<int> V;//除了U中剩余的点集合
    for (int i = 1; i < N;i++)
        V.push_back(i);

    U.push_back(0); //起始把0号点加入集合U
    int Max = -1;
    while(U.size()!=N){
        int Min = INF;
        int u, v;
        for (vector<int>::iterator i = U.begin(); i != U.end();i++)
        {
            for (vector<int>::iterator j = V.begin(); j != V.end();j++)
            {
                if(map[*i][*j]<Min){
                    Min = map[*i][*j];
                    u = *i;
                    v = *j;
                }
            }
        }
        if(map[u][v]>Max)
            Max = map[u][v];
        U.push_back(v);
        vector<int>::iterator iter = find(V.begin(), V.end(), v);
        V.erase(iter);
    }
    return Max;
}

int main(){
    int T;
    cin >> T;
    while(T--){
        cin >> N;
        vector<vector<int>> map(N, vector<int>(N, 0));
        for (int i = 0; i < N;i++){
            for (int j = 0; j < N;j++){
                cin >> map[i][j];
            }
        }
        cout << slove(map) << endl;
    }
    //system("pause");
    return 0;
}

kruskal（有点慢。。。）

#include "iostream"
#include "vector"
#include "climits"
#include "algorithm"
#include "cstring"

using namespace std;
const int INF = INT_MAX;

int N;
int parent[510];

typedef struct{
    int x, y,w;
} Edge;

bool cmp(Edge a, Edge b){
    return a.w < b.w;
}

int find_root(int x){
    if(parent[x]==x){
        return x;
    }
    else
    {
        return parent[x] = find_root(parent[x]);
    }
}

int Union(int x, int y){
    int x_root = find_root(x);
    int y_root = find_root(y);

    if(x_root==y_root)
        return 0;//在同一个集合，合并失败
    else
    {
        parent[x_root] = y_root;//简单的将y_root作为父节点
        return 1;//合并成功
    }
}

int kruscal(vector<Edge> &edges)
{
    int Max = INT_MIN;
    for (int i = 0; i < edges.size();i++){//edges已经按权值排好序
        int x = edges[i].x;
        int y = edges[i].y;

        if(Union(x, y)){//x,y不再一个连通分量中
            if(edges[i].w>Max){
                Max = edges[i].w;
            }
        }
    }
    return Max;
}


int main(){
    int T;
    cin >> T;
    while(T--){
        for (int i = 0; i < 510;i++){//初始化parent数组
            parent[i] = i;
        }
        cin >> N;
        vector<Edge> edges;
        for (int i = 0; i < N;i++){//输入数据
            for (int j = 0; j < N;j++){
                int t;
                cin >> t;
                if(t!=0){
                    Edge e;
                    e.x = i;
                    e.y = j;
                    e.w = t;
                    edges.push_back(e);
                }
            }
        }
        sort(edges.begin(), edges.end(), cmp);
        cout << kruscal(edges) << endl;
    }
    //system("pause");
    return 0;
}