Description
Severe
acute respiratory syndrome (SARS), an atypical pneumonia of unknown
aetiology, was recognized as a global threat in mid-March 2003. To
minimize transmission to others, the best strategy is to separate the
suspects from others.
In the Not-Spreading-Your-Sickness University (NSYSU), there are many student groups. Students in the same group intercommunicate with each other frequently, and a student may join several groups. To prevent the possible transmissions of SARS, the NSYSU collects the member lists of all student groups, and makes the following rule in their standard operation procedure (SOP).
Once a member in a group is a suspect, all members in the group are suspects.
However, they find that it is not easy to identify all the suspects when a student is recognized as a suspect. Your job is to write a program which finds all the suspects.
In the Not-Spreading-Your-Sickness University (NSYSU), there are many student groups. Students in the same group intercommunicate with each other frequently, and a student may join several groups. To prevent the possible transmissions of SARS, the NSYSU collects the member lists of all student groups, and makes the following rule in their standard operation procedure (SOP).
Once a member in a group is a suspect, all members in the group are suspects.
However, they find that it is not easy to identify all the suspects when a student is recognized as a suspect. Your job is to write a program which finds all the suspects.
Input
The
input file contains several cases. Each test case begins with two
integers n and m in a line, where n is the number of students, and m is
the number of groups. You may assume that 0 < n <= 30000 and 0
<= m <= 500. Every student is numbered by a unique integer
between 0 and n鈭?, and initially student 0 is recognized as a suspect
in all the cases. This line is followed by m member lists of the
groups, one line per group. Each line begins with an integer k by
itself representing the number of members in the group. Following the
number of members, there are k integers representing the students in
this group. All the integers in a line are separated by at least one
space.
A case with n = 0 and m = 0 indicates the end of the input, and need not be processed.
A case with n = 0 and m = 0 indicates the end of the input, and need not be processed.
Output
For each case, output the number of suspects in one line.
Sample Input
100 4
2 1 2
5 10 13 11 12 14
2 0 1
2 99 2
200 2
1 5
5 1 2 3 4 5
1 0
0 0
Sample Output
4棰樻剰錛?/span>
1
1
緇欏嚭浜烘暟n鍜屼漢鏁伴噷鐨勪漢緹ゆ暟m錛屽悓涓兢鐨勪漢灞炰簬涓涓泦鍚堛傛眰涓庣紪鍙?鐨勪漢鍚屼釜闆嗗悎鐨勪漢鏁幫紙鍖呮嫭0鏈韓)
浠ｇ爜鍏ヤ笅錛?br />
#include<stdio.h>
#define聽maxn聽30000
int聽father[maxn];
void聽setFather(int聽n)
{
聽聽聽聽for聽(int聽i聽=聽0;聽i聽<聽n;聽i++)
聽聽聽聽{
聽聽聽聽聽聽聽聽father[i]聽=聽-1;
聽聽聽聽}
}
int聽find(int聽a)
{
聽聽聽聽if聽(father[a]聽<聽0)
聽聽聽聽{
聽聽聽聽聽聽聽聽return聽a;
聽聽聽聽}
聽聽聽聽return聽father[a]聽=聽find(father[a]);
}
void聽Union(int聽a,聽int聽b)
{
聽聽聽聽a聽=聽find(a),聽b聽=聽find(b);
聽聽聽聽if聽(a聽!=聽b)
聽聽聽聽{
聽聽聽聽聽聽聽聽if聽(father[a]聽<聽father[b])
聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽father[a]聽+=聽father[b];
聽聽聽聽聽聽聽聽聽聽聽聽father[b]聽=聽a;
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽else
聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽father[b]聽+=聽father[a];
聽聽聽聽聽聽聽聽聽聽聽聽father[a]聽=聽b;
聽聽聽聽聽聽聽聽}
聽聽聽聽}
}
int聽main()
{
聽聽聽聽int聽i,聽j,聽n,聽m,聽a,聽b,聽v,聽t;
聽聽聽聽while聽(1)
聽聽聽聽{
聽聽聽聽聽聽聽聽scanf("%d%d",聽&n,聽&m);
聽聽聽聽聽聽聽聽if聽(n聽==聽0聽&&聽m聽==聽0)
聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽break;
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽setFather(n);
聽聽聽聽聽聽聽聽for聽(i聽=聽0;聽i聽<聽m;聽i++)
聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽scanf("%d%d",聽&v,聽&a);
聽聽聽聽聽聽聽聽聽聽聽聽for聽(j聽=聽1;聽j聽<聽v;聽j++)
聽聽聽聽聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf("%d",聽&b);
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽Union(a,聽b);
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽printf("%d\n",聽father[find(0)]聽*聽(-1));
聽聽聽聽}
聽聽聽聽return聽0;
}
#define聽maxn聽30000
int聽father[maxn];
void聽setFather(int聽n)
{
聽聽聽聽for聽(int聽i聽=聽0;聽i聽<聽n;聽i++)
聽聽聽聽{
聽聽聽聽聽聽聽聽father[i]聽=聽-1;
聽聽聽聽}
}
int聽find(int聽a)
{
聽聽聽聽if聽(father[a]聽<聽0)
聽聽聽聽{
聽聽聽聽聽聽聽聽return聽a;
聽聽聽聽}
聽聽聽聽return聽father[a]聽=聽find(father[a]);
}
void聽Union(int聽a,聽int聽b)
{
聽聽聽聽a聽=聽find(a),聽b聽=聽find(b);
聽聽聽聽if聽(a聽!=聽b)
聽聽聽聽{
聽聽聽聽聽聽聽聽if聽(father[a]聽<聽father[b])
聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽father[a]聽+=聽father[b];
聽聽聽聽聽聽聽聽聽聽聽聽father[b]聽=聽a;
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽else
聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽father[b]聽+=聽father[a];
聽聽聽聽聽聽聽聽聽聽聽聽father[a]聽=聽b;
聽聽聽聽聽聽聽聽}
聽聽聽聽}
}
int聽main()
{
聽聽聽聽int聽i,聽j,聽n,聽m,聽a,聽b,聽v,聽t;
聽聽聽聽while聽(1)
聽聽聽聽{
聽聽聽聽聽聽聽聽scanf("%d%d",聽&n,聽&m);
聽聽聽聽聽聽聽聽if聽(n聽==聽0聽&&聽m聽==聽0)
聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽break;
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽setFather(n);
聽聽聽聽聽聽聽聽for聽(i聽=聽0;聽i聽<聽m;聽i++)
聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽scanf("%d%d",聽&v,聽&a);
聽聽聽聽聽聽聽聽聽聽聽聽for聽(j聽=聽1;聽j聽<聽v;聽j++)
聽聽聽聽聽聽聽聽聽聽聽聽{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf("%d",聽&b);
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽Union(a,聽b);
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽printf("%d\n",聽father[find(0)]聽*聽(-1));
聽聽聽聽}
聽聽聽聽return聽0;
}
]]>