SPOJ: Lost and survived (multiset + union search)

On September 22, 2004, Oceanic Flight 815 crashed on a mysterious island somewhere in the pacific.

There actually were survivors in the crash , N survivors . The mysterious island kept on moving in space - time, so no rescue reached them.

Initially every survivor was on his own .But soon they realized there are these “The Others” (Scientists of damn Dharma Initiative) on this Island too.

So to protect themselves from mad Scientists they started uniting into groups after Dr. Shephard  said  “ Live together Die alone ”.

You have to handle Q queries; which consist of two survivors becoming friends and thereby uniting there respective groups into a  larger group.

After each query, output the difference between the group of largest size and group of smallest size at that time.

If there is only one group, output 0. At first, everyone is in their own group.

Also note, if the two survivors in the query are already in the  same group, print the current answer, and skip merging groups.

Also do comment if you have watched Lost :-p

Input

 

The first line consists of two space separated integers, N and Q

The next Q line consists of two integers, A and B, meaning that 

the groups involving survivor A and survivor B unite into a larger group.

The first line consists of two space separated integers, N and Q

 

The next Q line consists of two integers, A and B, meaning that 

survivor A and survivor B became friends uniting there groups.

 

Output

Output Q lines, the answer after each query.

 

1<=N<=100000

1<=Q<=100000

Example

Input:
5 3
1 2
2 3
5 4

Output:
1
2
1

 Submit solution!

 The meaning of the question: There are N people, and they all have a set at the beginning. There are Q operations. Each time u and v are given, it is required to combine u and v into a set (if it is already there, ignore it), and then output the current maximum number of set elements minus the minimum number of set elements.

Idea: The set is represented by a union search set, and the number of elements is stored by a multiset.

Note the deletion of multiset: s.erase(find(x)), deletes only one; and s.erase(x), deletes all elements whose value is x    

#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
multiset<int>s;
int fa[maxn],num[maxn],Max=1,Min=1;
int find(int u){
    if(u==fa[u]) return u;
    fa [u] = find (fa [u]); return fa [u];
}
void merge(int u,int v){
    int fau=find(u),fav=find(v);
    if(num[fau]>num[fav]) swap(fau,fav);
    fa [fau] = fav;
    s.erase(s.find(num[fau])); s.erase(s.find(num[fav]));
    num[fav]+=num[fau];    s.insert(num[fav]);  
    if(num[fav]>Max) Max=num[fav];
    Min=*s.begin();
}
intmain ()
{
    int N,Q,u,v,i,j,ans;
    scanf("%d%d",&N,&Q);
    for(i=1;i<=N;i++){
        fa [i] = i; num [i] = 1 ;
        s.insert(1);
    }
    while(Q--){
        scanf("%d%d",&u,&v);
        if(find(u)!=find(v))  merge(u,v);
        printf("%d\n",Max-Min);
    }
    return 0;
}