hihoCoder #1098 : 最小生成树二·Kruscal算法 最短路（Kruskal标准模板）

最近，小Hi很喜欢玩的一款游戏模拟城市开放出了新Mod，在这个Mod中，玩家可以拥有不止一个城市了！

但是，问题也接踵而来——小Hi现在手上拥有N座城市，且已知这N座城市中任意两座城市之间建造道路所需要的费用，小Hi希望知道，最少花费多少就可以使得任意两座城市都可以通过所建造的道路互相到达（假设有A、B、C三座城市，只需要在AB之间和BC之间建造道路，那么AC之间也是可以通过这两条道路连通的）。

提示：不知道为什么Prim算法和Dijstra算法很像呢Σ(っ °Д °;)っ 。

输入

每个测试点（输入文件）有且仅有一组测试数据。

在一组测试数据中：

第1行为1个整数N，表示小Hi拥有的城市数量。

接下来的N行，为一个N*N的矩阵A，描述任意两座城市之间建造道路所需要的费用，其中第i行第j个数为Aij，表示第i座城市和第j座城市之间建造道路所需要的费用。

对于100%的数据，满足N<=10^3，对于任意i，满足Aii=0，对于任意i, j满足Aij=Aji, 0<Aij<10^4.

输出

对于每组测试数据，输出1个整数Ans，表示为了使任意两座城市都可以通过所建造的道路互相到达至少需要的建造费用。

样例输入

5
0 1005 6963 392 1182 
1005 0 1599 4213 1451 
6963 1599 0 9780 2789 
392 4213 9780 0 5236 
1182 1451 2789 5236 0 

样例输出

4178

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
int fa[1100000];
int ans;

struct Node{

    int u,v,w;

}road[1100000];

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

int findset(int x)
{
    return fa[x]==-1?x:fa[x]=findset(fa[x]);
}

void Union(int x)
{
    int t1=findset(road[x].u);
    int t2=findset(road[x].v);
    if(t1!=t2)
    {
        fa[t1]=t2;
        ans+=road[x].w;
    }
}

int main()
{
    int n;
    int w;
    int num=0;
    memset(fa,-1,sizeof(fa));
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            cin>>w;
            road[num].u=i;
            road[num].v=j;
            road[num++].w=w;
        }
    }
    sort(road,road+num,cmp);
    ans=0;
    for(int i=0;i<num;i++)
    {
        Union(i);
    }
    cout<<ans<<endl;
    return 0;

-----------------------------------------------------------------------------------------------------------------------------------------

#1098 : 最小生成树二·Kruscal算法

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

随着小Hi拥有城市数目的增加，在之间所使用的Prim算法已经无法继续使用了——但是幸运的是，经过计算机的分析，小Hi已经筛选出了一些比较适合建造道路的路线，这个数量并没有特别的大。

所以问题变成了——小Hi现在手上拥有N座城市，且已知其中一些城市间建造道路的费用，小Hi希望知道，最少花费多少就可以使得任意两座城市都可以通过所建造的道路互相到达（假设有A、B、C三座城市，只需要在AB之间和BC之间建造道路，那么AC之间也是可以通过这两条道路连通的）。

提示：积累的好处在于可以可以随时从自己的知识库中提取想要的！

输入

每个测试点（输入文件）有且仅有一组测试数据。

在一组测试数据中：

第1行为2个整数N、M，表示小Hi拥有的城市数量和小Hi筛选出路线的条数。

接下来的M行，每行描述一条路线，其中第i行为3个整数N1_i, N2_i, V_i，分别表示这条路线的两个端点和在这条路线上建造道路的费用。

对于100%的数据，满足N<=10^5, M<=10^6，于任意i满足1<=N1_i, N2_i<=N, N1_i≠N2_i, 1<=V_i<=10^3.

对于100%的数据，满足一定存在一种方案，使得任意两座城市都可以互相到达。

输出

对于每组测试数据，输出1个整数Ans，表示为了使任意两座城市都可以通过所建造的道路互相到达至少需要的建造费用。

样例输入

5 29
1 2 674
2 3 249
3 4 672
4 5 933
1 2 788
3 4 147
2 4 504
3 4 38
1 3 65
3 5 6
1 5 865
1 3 590
1 4 682
2 4 227
2 4 636
1 4 312
1 3 143
2 5 158
2 3 516
3 5 102
1 5 605
1 4 99
4 5 224
2 4 198
3 5 894
1 5 845
3 4 7
2 4 14
1 4 185

样例输出

92

 

思路：和上面的一样，用同一个代码即可。

代码；

#include<cstdio>
#include<algorithm>
#include<cstring>
#include <iostream>
using namespace std;

struct Node{

	int u,v,w;

}road[1100000];

int n,p;
int u,v,w;
int fa[1100000],ans;

int cmp(Node a,Node b)//C++中的sort排序
{
	return a.w < b.w ;
}

int findset(int x)//并查集
{
    return fa[x]==-1?x:fa[x]=findset(fa[x]);
}

void Union(int x)	//并查集合并两个子集函数
{
    int t1=findset(road[x].u);
    int t2=findset(road[x].v);
    if(t1!=t2)
    {
        fa[t1]=t2;
        ans+=road[x].w;
    }
}

int main()
{
    memset(fa,-1,sizeof(fa));
    cin>>n>>p;
    for(int i=0;i<p;i++)
    {
        cin>>u>>v>>w;
        road[i].u=u;
        road[i].v=v;
        road[i].w=w;
    }
    sort(road,road+p,cmp);
    ans=0;
    for(int i=0;i<p;i++)
    {
        Union(i);
    }
    cout<<ans<<endl;
	return 0;
}