poj 1611 the suspect 并查集

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，一定注意初始化带来的影响，1，是什么地方初始化，2，前一个case不应当对下一个造成影响
        2，有层次性的问题一定要处理好，不要
        3，例如重复数据不能重复初始化。
                          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
这道题目可以用哈希表法也可以用二分查找法，现在用哈希，二分查找将在后面的博客中推出。
这道题目用到的是数的哈希，对于不需要删除的字典，哈希表是一种理想的实现方式。
1.哈希表的插入和查找算法
(1)计算函数值h(k)
(2)从槽h(k)开始，使用冲突解决策略定位包含关键码k的纪录
(3)如果需要插入，再槽内插入即可
两种操作的复杂度在忽略冲突时是O(1)
2.哈希函数的选取
本题使用最简单的直接取余法，除数为PRIME，最好是质数，可减小冲突。
3.冲突解决方法
开散列法（这也是大多数情况下使用的）
开散列法也叫拉链法，通俗地说就是“既然元素a和b都该放在里面，只好挤一挤了”。即在每个槽里存放所有该放在里面的元素。那么怎么把很多的元素放在槽里呢？只在槽里放一个链表表头就行了，该链表中包含所有该放在槽里的元素。但在实际中并不是这样做的，而是自己维护一个大数组，给链表元素分配数组下标，这样既方便又节省时间和空间。那么链表中的元素的排列顺序怎样呢？如果按照查找成功时的效率，显然可以按照访问的频率；而如果按照查找失败的效率，则可以按照关键值排序，即使查找失败也不需要遍历整个链表。这就是数据结构中的相互矛盾的两个问题，应根据实际情况协调。
#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，后面又插入99999时，那么99999>8,需要给99999重新分配                                                                           一个下标，即hashl，即前面提到的开散列法解决冲突
            break;
        else if(num==a[a[i].next].key)    //例如hash表中已有8，后面又插入8时，这是只要num++
            return a[i].next;
        i=a[i].next;                               //这句用于查找，如果哈希表中已有8和99999，那么你要找8时a[8].next指向的是较大的99999，那么你就必须沿着next走下去，因为这个所谓的链表是按减小的顺序排序的。最终走到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循环未执行）或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)     //插入的数字以前没有出现过，肯定包含在ans里
            {
                ans=i-left+1;
                continue;
            }
            while(1)                     //对应于if的else,即a[tmp].num>=2，即插入的数字以前出现过。如果是在left位置出现过，则left右移；如果是在“left右边，i左边”出现过，则说明目前的i-left+1和ans都可以包括全部的知识点，当然取小的了！
            {
                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博客，转载请标明出处：http://blog.csdn.net/cugbliang/archive/2008/06/01/2497376.aspx

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

C++博客-I believe-随笔分类-并查集*哈希表*类似

poj 1611 the suspect 并查集

哈希表 poj 3320 Jessica's Reading Problem

C++博客-I believe-随笔分类-并查集哈希表类似