poj 1251

题意：就是求最小生成树的边权值和

prim算法求最小生成树

import java.util.Scanner;
import java.util.Arrays;
/*
prim
*/
public class Main{
    static int map[][];               //存储邻接矩阵
    static boolean visit[];           //标记加入的结点
    static int n;
    static int INF = 0x3f3f3f3f;
    
    public static int prim(){
        int sum=0;
        visit = new boolean[n];
        visit[0] = true;
        
        for(int i=0;i<n-1;i++){         //n个结点需要n-1条边，循环n-1次
            int min = INF;
            int u = 0;                  //保存下一个要加入树的结点下标
            for(int j=1;j<n;j++){
                if(visit[j]==false&&map[0][j]<min){
                    min = map[0][j];
                    u = j;
                }
            }
            visit[u] = true;            //将结点加入，标记置为true
            sum+=min;
            for(int j=1;j<n;j++){       //更新数据
                if(visit[j]==false&&map[u][j]<map[0][j])
                    map[0][j] = map[u][j];
            }
        }
        return sum;
    }
    
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            n = in.nextInt();
            if(n==0)
                break;
            map = new int[n][n];
            for(int i=0;i<n;i++)
                Arrays.fill(map[i],INF);
            for(int i=0;i<n-1;i++){
                char chx = in.next().charAt(0);
                int j = in.nextInt();
                while(j!=0){
                    j--;
                    char chy = in.next().charAt(0);
                    int y = chy - 'A';
                    int cost = in.nextInt();
                    map[i][y] = map[y][i] = cost;
                }
            }
            System.out.println(prim());
        }
    }
}

Kruskal算法求最小生成树

 

import java.util.Scanner;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
/*
kruskal
*/
public class Main{
    static int n;
    static int parent[];
    
    public static int find(int x){                               //查找父节点
        return parent[x]==x?x:(parent[x] = find(parent[x]));
    }
    
    public static void join(int x,int y){                        //将两个并查集并在一起
        parent[x] = y;
    }
    
    public static int kruskal(List<Edge> list){
        int sum = 0;
        Iterator<Edge> it = list.iterator();
        while(it.hasNext()){
            Edge edge = it.next();
            if(find(edge.s)==find(edge.e))                       //如果父节点相同说明在同一个并查集中，若取这条边则会形成环
                continue;
            sum+=edge.length;
            join(find(edge.s),find(edge.e));                     //如果父节点不相同，则取这条边，并将两个结点所在并查集合并
        }
        return sum;
    }
    
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            n = in.nextInt();
            if(n==0)
                break;
            parent = new int[n];
            for(int i=0;i<n;i++)
                parent[i] = i;
            List<Edge> list = new LinkedList<Edge>();
            for(int i=0;i<n-1;i++){
                char chx = in.next().charAt(0);
                int j = in.nextInt();
                while(j!=0){
                    j--;
                    char chy = in.next().charAt(0);
                    int y = chy - 'A';
                    int cost = in.nextInt();
                    list.add(new Edge(i,y,cost));             //将边加入list中
                }
            }
            Collections.sort(list);                           //按边权值大小进行排序
            System.out.println(kruskal(list));
        }
    }
}

class Edge implements Comparable<Edge>{                       //继承Comparable接口
    public int length;
    public int s;
    public int e;
    
    public Edge(int s,int e,int length){
        this.s = s;
        this.e = e;
        this.length = length;
    }
    
    public int compareTo(Edge o){                            //重写compareTo函数，使边按权值大小升序排序
        return this.length-o.length;
    }
}