L2-007. 家庭房产 处理集合体的问题 并查集经典应用 或 联通块的方法

L2-007. 家庭房产

时间限制

400 ms

内存限制

65536 kB

代码长度限制

8000 B

判题程序

Standard

作者

陈越

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

输入格式：

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

编号 父 母 k 孩子₁ ... 孩子_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

方法一：

先将所有的状态都保存好

然后进行并查

集联通

#include<bits/stdc++.h>                  
#define INF 0x3f3f3f3f
#define LL long long
#define bug puts("********************************")
#define mem(a,b)  memset(a,b,sizeof(a))

using namespace std;


struct node
{
    int id;   /// 编号
    double area;  ///面积
    double roomNum;    ///房子套数
    int num;        /// 总人数
    friend bool operator <(node p1,node p2)
    {
        return p1.area/p1.num==p2.area/p2.num?p1.id<p2.id: p1.area/p1.num>p2.area/p2.num;
    }

} bin[10000],sp[10000];
struct guanxi
{
    int id;
    int father,mother;
    vector <int>f;
} p[1005];


bool vis[10000];

int Find(int x)
{
    return x==bin[x].id?x:bin[x].id=Find(bin[x].id);
}
void Union(int x,int y)
{
    int fx=Find(x);
    int fy=Find(y);
    if(fx==fy)
        return ;
    if(fx>fy)
    {
        bin[fx].id=fy;
        bin[fy].roomNum+=bin[fx].roomNum;
        bin[fy].area+=bin[fx].area;
        bin[fy].num+=bin[fx].num;
    }
    else
    {                                       ///更新并查集中 集合体的信息（或根信息）
        bin[fy].id=fx;
        bin[fx].roomNum+=bin[fy].roomNum;
        bin[fx].area+=bin[fy].area;
        bin[fx].num+=bin[fy].num;
    }
}

int main()
{
    int n;
    mem(vis,0);
    for(int i=0; i<10000; i++)
    {
        bin[i].area=bin[i].roomNum=0;
        bin[i].num=1;
        bin[i].id=i;
    }

    scanf("%d",&n);
     int a,b,c,d;
    for(int i=0; i<n; i++) ///要先将所有的信息录入再进行合并,这样才可以保证录入的信息更新不会被漏掉
    {
        scanf("%d%d%d%d",&a,&b,&c,&d);
        p[i].id=a,p[i].father=b,p[i].mother=c;
        for(int j=0; j<d; j++)
        {
            int t;
            scanf("%d",&t);
            p[i].f.push_back(t);
            ///cout<<p[i].f[j]<<endl;
        }
        scanf("%lf%lf",&bin[a].roomNum,&bin[a].area);
    }


    ///将录好信息的进行并查集合并
    for(int i=0; i<n; i++)
    {
         a=p[i].id,b=p[i].father,c=p[i].mother,d=p[i].f.size();
         vis[a]=true;
        if(b!=-1)
        {
            vis[b]=true;
            Union(a,b);
        }
        if(c!=-1)
        {
            vis[c]=true;
            Union(a,c);
        }
        for(int j=0; j<d; j++)
        {
            int t=p[i].f[j];
            if(t!=-1)
            {
                vis[t]=true;
                Union(a,t);
            }
        }
    }

    int znum=0;
    for(int i=0;i<10000;i++)   ///枚举所有的情况，因为可能存在不存在房产的人
    {
        if(vis[i]&&bin[i].id==i)
        {
           sp[znum++]=bin[i];
        }
    }

    sort(sp,sp+znum);

    printf("%d\n",znum);
    for(int i=0;i<znum;i++)
    {
        printf("%04d %d %.3lf %.3lf\n",sp[i].id,(int)sp[i].num,sp[i].roomNum/sp[i].num,sp[i].area/sp[i].num);
    }
    return 0;
}
联通块的方法
处理成无向图，DFS遍历查找相关的点集
///联通块
#include<bits/stdc++.h>
#define INF 0x3f3f3f3f
#define bug puts("------------------------")
#define LL long long
using namespace std;

struct node
{
    int id;
    int num;
    double avenum;
    double avearea;
    node(){}
    node(int a,int b,double c,double d)
    {
        id=a,num=b,avenum=c,avearea=d;
    }
    friend bool operator < (node p1,node p2)
    {
        if(p1.avearea!=p2.avearea)
            return p1.avearea>p2.avearea;
        return p1.id<p2.id;
    }
}p[10000];

int A,B;
double C,D;

vector <int>vec[10000];
bool vis[10000];
int area[10000],roomNum[10000];

void DFS(int x)
{
    vis[x]=0;
    A=min(A,x);
    B++;
    C+=roomNum[x];
    D+=area[x];
    for(int i=0;i<vec[x].size();i++)
    {
        if(vis[vec[x][i]])
            DFS(vec[x][i]);
    }
}
int main()
{
    memset(vis,0,sizeof(vis));
    int n,a,b,c,d;
    scanf("%d",&n);

    for(int i=0;i<n;i++)
    {
        scanf("%d%d%d%d",&a,&b,&c,&d);
        vis[a]=true;
        if(b!=-1)
        {
            vis[b]=true;
            vec[a].push_back(b);
            vec[b].push_back(a);
        }
        if(c!=-1)
        {
            vis[c]=true;
            vec[a].push_back(c);
            vec[c].push_back(a);
        }
        for(int j=0;j<d;j++)
        {
            int t;
            scanf("%d",&t);
            if(t!=-1)
            {
                vis[t]=true;
                vec[a].push_back(t);
                vec[t].push_back(a);
            }
        }
        scanf("%d%d",&roomNum[a],&area[a]);
    }
//bug;
    int znum=0;
    for(int i=0;i<10000;i++)
    {
        if(vis[i])
        {
            ///最小号 家庭人数  房产数 面积
            A=10000,   B=0,      C=0,    D=0;
            DFS(i);
           /// cout<<A<<"    "<<B<<"   "<<C<<"   "<<D<<endl;
            p[znum++]=node(A,B,C/B,D/B);
        }
    }
    sort(p,p+znum);
    printf("%d\n",znum);
    for(int i=0;i<znum;i++)
    {
        printf("%04d %d %.3lf %.3lf\n",p[i].id,p[i].num,p[i].avenum,p[i].avearea);
    }
    return 0;
}