luis — Fri, 03 Jul 2009 08:51:00 GMT

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.

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−1, 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.

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
1
1

启示1�Q�一定注意初始化带来的媄(ji��ng)响，1�Q�是什么地方初始化�Q?�Q�前一个case不应当对下一个造成影响
        2�Q�有层次性的问题一定要处理好，不要
        3�Q�例如重复数据不能重复初始化�?br>                          cin>>t;
                           if(father[t]<0)//必不可少
                            father[t]=t;

#include
#include
using namespace std;
int rank[30001];
int father[30001];
void UNION(int a,int b)
{
  if(a==b)return;
  else
  {
   if(rank[a]   {
    father[b]=father[a];
      }
   else
   {
    father[a]=father[b];
   }
  }

}
int Find(int t)
{
  int tmp=t,x;
  while(father[tmp]!=tmp)
  {
   tmp=father[tmp];
  }

  while(t!=father[t])
  {
      x=t;
      t=father[x];
   father[x]=tmp;
     }

     return t;
}
int main()
{
freopen("s.txt","r",stdin);
freopen("key.txt","w",stdout);
int i,j,nt,t1,t,result;
while(cin>>i>>j,i||j)
{
  result=0;
  memset(rank,1,sizeof(rank));
  memset(father,-1,sizeof(father));
  rank[0]=0;
  father[0]=0;
for(int k=0;k {
  cin>>nt;
  cin>>t1;
  rank[t1]=t1;
  if(father[t1]<0)
    father[t1]=t1;
  for(int m=1;m  {
   cin>>t;
   rank[t]=t;
   if(father[t]<0)
    father[t]=t;
   UNION(Find(t1),Find(t));
  }
}
for(int l=0;l {
  if(father[l]>=0)
  {
   if(!Find(l))
  result++;
     }
}
cout<
}

//system("PAUSE");
return 0;
}

luis 2009-07-03 16:51 发表评论

哈希�?poj 3320 Jessica's Reading Problem

luis — Wed, 01 Jul 2009 05:00:00 GMT

poj 3320 Jessica's Reading Problem http://acm.pku.edu.cn/JudgeOnline/problem?id=3320
�q�道题目可以用哈希表法也可以用二分查找法�Q�现在用哈希�Q�二分查扑ְ�在后面的博客中推出�?br>�q�道题目用到的是数的哈希�Q�对于不需要删除的字典�Q�哈希表是一�U�理想的实现方式�?br>1.哈希表的插入和查扄��?br>(1)计算函数值h(k)
(2)从槽h(k)开始，使用冲突解决�{�略定位包含关键码k的纪�?br>(3)如果需要插入，再槽内插入即�?br>两种操作的复杂度在忽略冲�H�时是O(1)
2.哈希函数的选取
本题使用最��单的直接取余法，除数为PRIME�Q�最好是质数�Q�可减小冲突�?br>3.冲突解决�Ҏ(gu��)��
开散列法（�q�也是大多数情况下��用的�Q?br>开散列法也叫拉链法�Q�通俗地说��是“既然元素a和b都该攑֜�里面�Q�只好挤一挤了(ji��n)”。即在每个槽里存放所有该攑֜�里面的元素。那么怎么把很多的元素攑֜�槽里呢？只在槽里放一个链表表头就行了(ji��n)�Q�该链表中包含所有该攑֜�槽里的元素。但在实际中�q�不是这样做的，而是自己�l�护一个大数组�Q�给链表元素分配数组下标�Q�这��h��方便又节省时间和�I�间。那么链表中的元素的排列��序怎样呢？如果按照查找成功时的效率�Q�显然可以按照访问的频率�Q�而如果按照查扑֤�败的效率�Q�则可以按照关键值排序，即��查找��p�|也不需要遍历整个链表。这��是数据�l�构中的�怺�矛盾的两个问题，应根据实际情况协调�?br>#include
#define PRIME 99991
struct hashnode
{
    int key;
    int num;
    int next;
}a[1000005];
int b[1000005];
int hashl;
int hash(int num)
{
    int i;
    i=num%PRIME;
    while(a[i].next!=-1)
    {
        if(num>a[a[i].next].key)     //例如hash表中已有8�Q�后面又插入99999�Ӟ��那么99999>8,需要给99999重新分配                                                                           一个下标，即hashl�Q�即前面提到的开散列法解军_��H?br>            break;
        else if(num==a[a[i].next].key)    //例如hash表中已有8�Q�后面又插入8�Ӟ��q�是只要num++
            return a[i].next;
        i=a[i].next;                               //�q�句用于查找�Q�如果哈希表中已�?�?9999�Q�那么你要找8时a[8].next指向的是较大�?9999�Q�那么你��必��L��着next��C��去，因�ؓ(f��)�q�个所谓的链表是按减小的顺序排序的。最�l�走到return a[i].next推出while 循环
    }
    a[hashl].key=num;
    a[hashl].next=-1;
    a[hashl].num=0;
    a[hashl].next=a[i].next;
    a[i].next=hashl;
    hashl++;                                //以上6行用于第一�ơ插入元素（即while循环未执行）(j��)或while循环break退出的插入
    return hashl-1;
}

int main()
{
    int n,i,tmp,left,ans;
    while(scanf("%d",&n)!=EOF)
    {
        for(i=0;i            a[i].next=-1;
        hashl=PRIME;
        left=0;
        ans=1;
        scanf("%d",&b[0]);
        tmp=hash(b[0]);
        a[tmp].num++;
        for(i=1;i        {
            scanf("%d",&b[i]);
            tmp=hash(b[i]);
            a[tmp].num++;
            if(a[tmp].num<=1)     //插入的数字以前没有出现过�Q�肯定包含在ans�?br>            {
                ans=i-left+1;
                continue;
            }
            while(1)                     //对应于if的else,即a[tmp].num>=2�Q�即插入的数字以前出现过。如果是在left位置出现�q�，则left右移�Q�如果是�?#8220;left双��Q�i左边”出现�q�，则说明目前的i-left+1和ans都可以包括全部的知识点，当然取小的了(ji��n)�Q?nbsp;
            {
                tmp=hash(b[left]);
                if(a[tmp].num<=1)
                    break;
                a[tmp].num--;
                left++;
            }
            if(ans>i-left+1)
                ans=i-left+1;
        }
        printf("%d\n",ans);
    }
    return 0;
}

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/cugbliang/archive/2008/06/01/2497376.aspx

luis 2009-07-01 13:00 发表评论

激情欧美日韩一区,亚洲影院高清在线,在线亚洲欧美

哈希�?poj 3320 Jessica's Reading Problem