L2-007 家庭房产 (25分)java解析

给定每个人的家庭成员和其自己名下的房产，请你统计出每个家庭的人口数、人均房产面积及房产套数。

输入格式：

输入第一行给出一个正整数N（≤1000），随后N行，每行按下列格式给出一个人的房产：

编号 父 母 k 孩子1 ... 孩子k 房产套数 总面积

其中编号是每个人独有的一个4位数的编号；父和母分别是该编号对应的这个人的父母的编号（如果已经过世，则显示-1）；k（0≤k≤5）是该人的子女的个数；孩子i是其子女的编号。

输出格式：

首先在第一行输出家庭个数（所有有亲属关系的人都属于同一个家庭）。随后按下列格式输出每个家庭的信息：

家庭成员的最小编号 家庭人口数 人均房产套数 人均房产面积

其中人均值要求保留小数点后3位。家庭信息首先按人均面积降序输出，若有并列，则按成员编号的升序输出。

输入样例：

10
6666 5551 5552 1 7777 1 100
1234 5678 9012 1 0002 2 300
8888 -1 -1 0 1 1000
2468 0001 0004 1 2222 1 500
7777 6666 -1 0 2 300
3721 -1 -1 1 2333 2 150
9012 -1 -1 3 1236 1235 1234 1 100
1235 5678 9012 0 1 50
2222 1236 2468 2 6661 6662 1 300
2333 -1 3721 3 6661 6662 6663 1 100

输出样例：

3
8888 1 1.000 1000.000
0001 15 0.600 100.000
5551 4 0.750 100.000

NOTE:

并查集

1.构建两个结构体数组，data用来接受数据，Node用来存储最后聚在一起的大家庭

2.定义两个布尔遍历，vis数组，用来标记输入时所有出现的编号，方便计算每个大家庭中的总人数；Node结构体中的flag变量，用来标记每个大家庭，（找Node数组下标---每个家庭最小成员编号），方便计算有几个大家庭。

3.在输入的时候，利用并查集，将大家庭中最小成员编号作为根节点，当父母编号不是-1，与自己编号合并，当孩子个数不为0，将孩子编号和自己编号合并。

4.最后输出时用sort排序。

代码：

java会超时

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
    private static int[] parent = new int[10001];
    private static boolean[] vis = new boolean[10001];
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Node[] node = new Node[10001];
        //并查集：初始化
        for(int i = 0;i<10001; i++) {
            parent[i] = i;
            node[i] = new Node();
        }
        int n = sc.nextInt();
        Data[] data = new Data[n];

        for(int i = 0; i<n; i++){
            data[i] = new Data();
            data[i].id = sc.nextInt();
            data[i].fid = sc.nextInt();
            data[i].mid = sc.nextInt();
            data[i].k = sc.nextInt();
            vis[data[i].id] = true;
            //把父母融入到一个大集合中
            if(data[i].fid != -1){
                vis[data[i].fid] = true;
                union(data[i].id,data[i].fid);
            }
            if(data[i].mid != -1){
                vis[data[i].mid] = true;
                union(data[i].id,data[i].mid);
            }
            for(int j = 0; j<data[i].k; j++){
                data[i].cid[j] = sc.nextInt();
                vis[data[i].cid[j]] = true;
                union(data[i].id,data[i].cid[j]);
            }
            data[i].num = sc.nextInt();
            data[i].area = sc.nextInt();
        }
        //所有的亲属都聚集在一个大家庭，包括房产套数 房产面积都加在一起，根节点是编号最小的成员
        for(int i = 0; i<n; i++){
            int id = find(data[i].id);
            node[id].min_id = id;
            node[id].num+=data[i].num;
            node[id].area += data[i].area;
            node[id].flag = true;
        }
        int cnt = 0;
        for(int i = 0; i<10001; i++){//遍历
            if(vis[i])node[find(i)].sum ++;//计算每个大家庭总人数
            if(node[i].flag)cnt++;//计算有几个大家庭
        }
        //算人均房产套数 人均房产面积
        for(int i = 0; i<10001; i++){
            if(node[i].flag){
                node[i].num = node[i].num*1.0/node[i].sum;
                node[i].area = node[i].area*1.0/node[i].sum;
            }
        }
        //排序
        Arrays.sort(node, new Comparator<Node>() {
            @Override
            public int compare(Node o1, Node o2) {
                if(o1.area < o2.area)return 1;
                else if(o1.area == o2.area){
                    if(o1.min_id > o2.min_id)return 1;
                }
                return -1;
            }
        });
        System.out.println(cnt);
        for(int i = 0; i<cnt; i++){
            System.out.printf("%04d %d %.3f %.3f\n",node[i].min_id,node[i].sum,
                    node[i].num,node[i].area);
        }
    }
    //查找
    private static int find(int x){
        int root = x;
        while(parent[root] != root)root = parent[root];
        while(parent[x] != root){//压缩路径，减少树的层数，防止树的退化。
            int temp = parent[x];
            parent[x] = root;
            x = temp;
        }
        return root;
    }
    //合并
    private static void union(int a,int b){
        int ra = find(a);
        int rb = find(b);

//        if(ra != rb){
//            parent[rb] = ra;
//        }
        //让最小编号作为根节点
        if(ra > rb)parent[ra] = rb;
        else if(rb > ra)parent[rb] = ra;
    }


    static class Data{
        int id,fid,mid,k,num,area;
        int[] cid = new int[10];
    }
    static class Node{
        int min_id,sum;//家庭成员的最小编号 家庭人口数
        double num,area;//人均房产套数 人均房产面积
        boolean flag = false;
    }
}