Codeforces Round #388 (Div. 2)D. Leaving Auction

题目链接：http://codeforces.com/contest/749/problem/D
Codeforces Round #388 (Div. 2) D

There are n people taking part in auction today. The rules of auction are classical. There were n bids made, though it’s not guaranteed they were from different people. It might happen that some people made no bids at all.

Each bid is define by two integers (ai, bi), where ai is the index of the person, who made this bid and bi is its size. Bids are given in chronological order, meaning bi < bi + 1 for all i < n. Moreover, participant never makes two bids in a row (no one updates his own bid), i.e.ai ≠ ai + 1 for all i < n.

Now you are curious with the following question: who (and which bid) will win the auction if some participants were absent? Consider that if someone was absent, all his bids are just removed and no new bids are added.

Note, that if during this imaginary exclusion of some participants it happens that some of the remaining participants makes a bid twice (or more times) in a row, only first of these bids is counted. For better understanding take a look at the samples.

You have several questions in your mind, compute the answer for each of them.
Input

The first line of the input contains an integer n (1 ≤ n ≤ 200 000) — the number of participants and bids.

Each of the following n lines contains two integers ai and bi (1 ≤ ai ≤ n, 1 ≤ bi ≤ 109, bi < bi + 1) — the number of participant who made the i-th bid and the size of this bid.

Next line contains an integer q (1 ≤ q ≤ 200 000) — the number of question you have in mind.

Each of next q lines contains an integer k (1 ≤ k ≤ n), followed by k integers lj (1 ≤ lj ≤ n) — the number of people who are not coming in this question and their indices. It is guarenteed that lj values are different for a single question.

It’s guaranteed that the sum of k over all question won’t exceed 200 000.
Output

For each question print two integer — the index of the winner and the size of the winning bid. If there is no winner (there are no remaining bids at all), print two zeroes.
Examples
input

6
1 10
2 100
3 1000
1 10000
2 100000
3 1000000
3
1 3
2 2 3
2 1 2

output

2 100000
1 10
3 1000

input

3
1 10
2 100
1 1000
2
2 1 2
2 2 3

output

0 0
1 10

Note

Consider the first sample:

In the first question participant number 3 is absent so the sequence of bids looks as follows:
    1 10
    2 100
    1 10 000
    2 100 000
Participant number 2 wins with the bid 100 000.
In the second question participants 2 and 3 are absent, so the sequence of bids looks:
    1 10
    1 10 000
The winner is, of course, participant number 1 but the winning bid is 10 instead of 10 000 as no one will ever increase his own bid (in this problem).
In the third question participants 1 and 2 are absent and the sequence is:
    3 1 000
    3 1 000 000
The winner is participant 3 with the bid 1 000.

题意：有个拍卖会，然后出价（出价貌似是上升的），最后说有几个出价是失效的，问最后是哪个价格竞拍到了

1 10
2 100
3 1000
1 10000
2 100000
3 1000000
比如这个，我们知道每人两次出价（价格上升），最后3出价失效，最后保留1 2,2的出价最高，输出2 10000

题意：有有许多人参加拍卖，问当假定某些人不参加的时候剩余的人当中谁是最终的赢家，输出他的编号和最终竞价，注：每个人都不能和自己竞价，即若某人连续竞价两次，以第一次价格为准。输入数据保证竞价递增。（注意这个“连续”）

题目说了 sum of k 《200000 所以可以遍历每次的k，
手残，继续拿别人的代码。

    #include <iostream>  
    #include <cstdio>  
    #include <cstring>  
    #include <map>  
    #include <set>  
    #include <vector>  
    using namespace std;  
    set<int>bk;  
    map<int,int>p,q;  
    map<int,int>::iterator it;  
    set<int>num[200005];  
    int a[200005];  
    int main()  
    {  
        int n,x,y;  
        scanf("%d",&n);  
        for(int i=0;i<n;i++)  
        {  
            scanf("%d%d",&x,&y);  
            num[x].insert(y);  
            p[x]=max(p[x],y);//这里不用map，开个数组也能实现相同功能   
        }  
        for(int i=1;i<=n;i++)  
        if(p[i])//一定要加这个判断，因为输入数据中可能某些人不会出现  
        q.insert(make_pair(p[i],i));//之所以把竞价方法前面是因为map默认按first从小到大排序，这样刚好符合我们的要求   
        int k,t1,t2;  
        scanf("%d",&x);  
        while(x--)  
        {  
            scanf("%d",&k);  
            for(int i=0;i<k;i++)  
            {  
                scanf("%d",&a[i]);  
                if(p[a[i]])  
                q.erase(p[a[i]]);  
            }  
            //for(it=q.begin();it!=q.end();it++)  
            //cout<<(*it).first<<" "<<(*it).second<<endl;  
            int cnt=q.size();  
            if(!cnt)  
            printf("0 0\n");  
            else if(cnt==1)//特判   
            {  
                it=q.end();  
                it--;  
                int t1=it->second;  
                printf("%d %d\n",t1,*num[t1].begin());  
            }  
            else  
            {  
                it=q.end();  
                it--;  
                int t1=it->second;  
                it--;  
                int t2=it->first;  
                set<int>::iterator it1=num[t1].upper_bound(t2);//这里就是'恰好大于'部分   
                printf("%d %d\n",t1,*it1);  
            }  
            for(int i=0;i<k;i++)//因为下面还有其他操作，所以要把q复原  
            if(p[a[i]])  
            q.insert(make_pair(p[a[i]],a[i]));  
        }  

    return 0;  
    }