最小生成树二·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

EmacsNormalVim

 

 代码：

import java.util.Scanner;


public class Main {

    public static void main(String argv []){
        Scanner in = new Scanner(System.in);
        String[] fir = in.nextLine().split(" ");
        int m = Integer.parseInt(fir[0]);
        int n = Integer.parseInt(fir[1]);
        int [] k =new int [m];
        int [] length = new int [n]; 
        int [] [] id = new int [n][2];
        int min = 0; int sum = 0;
        for(int i=0; i<n; i++){
            String[] s = in.nextLine().split(" ");
            id[i][0]=Integer.parseInt(s[0]);
            id[i][0]=id[i][0]-1;
            id[i][1]=Integer.parseInt(s[1]);
            id[i][1]=id[i][1]-1;
            length[i]=Integer.parseInt(s[2]);    
        }
        in.close();
        for(int j=0; j<m-1;j++){
            min = minInt(length,id,k,m+j);        
            //System.out.println(min);
            sum=sum+min;
        }
        System.out.println(sum);
    }
    
    public static int minInt(int[] k,int[][] id, int[] l, int n){
        
        
        int min=0;
        int num=0;
        for(int i=0; i<k.length; i++){
            if((l[id[i][0]]!=l[id[i][1]])||(l[id[i][0]]==0&&l[id[i][1]]==0))
            {
                if(min==0)
                      {min=k[i];num=i;}
                if(min!=0&&k[i]<min)
                    {min=k[i];num=i;}            
            }            
        }
        int x = id [num][0];
        int y = id [num][1];
        if(l[x]==0&&l[y]==0)
           {l[x]=n; l[y]=n;     }
        else{
            if(l[x]*l[y]==0)
            {
                if(l[x]==0)
                    l[x]=l[y];
                else
                    l[y]=l[x];
            }
            else
            {
                int r1=l[x]; int r2=l[y];
                for(int i=0; i<l.length; i++){
                    if(l[i]==r1||l[i]==r2)
                        { l[i]=n;}
                }
            }
        }
    
        return min;
    }
}

效果：