L2-007 家庭房产 (连通分量)（25 分)

L2-007 家庭房产 （25 分)

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

输入格式：

输入第一行给出一个正整数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

题解

用dfs求连通分量，然后统计一下每个连通分量里面的家庭人口数、人均房产套数、人均房产面积即可。
关键在于建图，在输入中，关于某条记录的父母和孩子的记录可能并没有单独给出。
所以需要再过一遍输入，将没有作为记录首位编号出现在记录中的编号添加到图中，并且添加该编号与其父母/孩子的边。

代码

#include <bits/stdc++.h>
using namespace std;
struct Node
{
    int num;
    int house;
    int area;
    vector<int> adj;
    Node(){num=0;house=0;area=0;}
    Node(int _num)
    {
        num = _num;
        house = 0;
        area = 0;
    }
};
struct FNode
{
    int num;
    int count;
    float avg_house;
    float avg_area;
    bool operator<(const FNode &a) const
    {
        if(int(avg_area*1000) == int(a.avg_area*1000))
            return num < a.num;
        return avg_area > a.avg_area;
    }
    FNode()
    {
        num = 9999;
        count = 0;
        avg_house = 0.0;
        avg_area = 0.0;
    }
};
map<int, int> M;

void print(vector<Node> &G, int n)
{
    for(int i=0;i<n;i++)
    {
        printf("%d %04d", i, G[i].num);
        for(int j=0;j<G[i].adj.size();j++)
        {
            int v = M[G[i].adj[j]];
            printf(" %d %04d", v, G[i].adj[j]);
        } 
        cout << endl;
    }
}
void dfs(vector<Node> &G, vector<int> &visit, int s, int c)
{
    for(int i=0;i<G[s].adj.size();i++)
    {
        int v = M[G[s].adj[i]];
        if(visit[v] == 0)       //还没有访问过
        {
            visit[v] = c;
            dfs(G, visit, v, c);
        }
    }
}
void connect(vector<Node> &G, int n)
{
    vector<int> visit(n, 0);
    int c = 0;
    for(int i=0;i<n;i++)
    {
        if(visit[i]==0)
        {
            visit[i] = ++c;
            dfs(G, visit, i, c);
        }
    }
    cout << c << endl;
    vector<FNode> ans;
    for(int i=1;i<=c;i++)
    {
        FNode node;
        for(int j=0;j<n;j++)
        {
            if(visit[j] == i)
            {
                if(G[j].num < node.num)
                    node.num = G[j].num;
                node.avg_area += G[j].area;
                node.avg_house += G[j].house;
                node.count++;
            }
        }
        node.avg_area = node.avg_area/node.count;
        node.avg_house = node.avg_house/node.count;
        ans.push_back(node);
    }
    sort(ans.begin(), ans.end());
    for(int i=0;i<ans.size();i++)
    {
        printf("%04d %d %.3f %.3f\n",ans[i].num, ans[i].count, ans[i].avg_house, ans[i].avg_area);
    }
}
int main()
{
    int n;
    cin >> n;
    vector<Node> G(n);
    int pf, pm;
    int k, ch;
    for(int i=0;i<n;i++)
    {
        cin >> G[i].num;
        cin >> pf >> pm;
        if(pf!=-1) G[i].adj.push_back(pf);
        if(pm!=-1) G[i].adj.push_back(pm);
        cin >> k;
        for(int j=0;j<k;j++)
        {
            cin >> ch;
            G[i].adj.push_back(ch);
        }
        cin >> G[i].house;
        cin >> G[i].area;
        M[G[i].num] = i;
    }
    int cnt=n;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<G[i].adj.size();j++)
        {
            if(M.find(G[i].adj[j]) == M.end())  //没有这个点
            {
                M.insert(make_pair(G[i].adj[j], cnt));
                G.push_back(Node(G[i].adj[j]));
                G[cnt].adj.push_back(G[i].num); //添加反向边
                cnt++;
            }
            else                                //添加反向边
            {
                int t = M[G[i].adj[j]];
                G[t].adj.push_back(G[i].num);
            }
        }
    }
    n = cnt;
    connect(G, n);
    return 0;
}