CodeForces - 749D set+二分

题意：

        N个人竞拍一件物品，一共有N个报价，一个人可多次报价也可不报价。

        先给出N，接着是报价人和报价

        随后询问K次，求每次询问中去除M个人后谁能拍得此物，且最低价是多少

        每次询问给出人数M和M个人的序号

思路：

        首先注意到由于拍卖的性质，报价是升序给出的

        可以用vector保存每个人报价，并记录下每个人的最低和最高报价

        将他们的最高报价都记录在set中，利用set的高效性，解决每次询问时删除人和求最大值的工作，并且要在每次询问后将删除的人添加回去

        每次删除后做查询有三种情况

                     1.人都被删除了 此时输出0 0

                     2.只剩下一个人 此时输出此人的最低报价

                     3.剩下大于一个人 此时需找到次大的人的报价，答案就是给出最大报价的人的所有报价中大于次大报价的报价，这个用二分查找即可

        由于利用了set本题的复杂度就控制在了klogn中

代码：（390MS）

#include <bits/stdc++.h>

using namespace std;
const int MAXN=200100;
vector <int> pay[MAXN];
stack <int> del;
set <pair<int,int> >all;
set <pair<int,int> >::iterator it;


int main()
{
    int n,x,y,k,m;
    while(scanf("%d",&n)!=-1){
        all.clear();
        while(!del.empty()) del.pop();
        for(int i=1;i<=n;i++)
            if(!pay[i].empty()) pay[i].clear();
        for(int i=1;i<=n;i++){
            scanf("%d%d",&x,&y);
            pay[x].push_back(y);
        }
        for(int i=1;i<=n;i++)
            if(!pay[i].empty()){
                all.insert(make_pair(*(--pay[i].end()),i));
            }
        scanf("%d",&k);
        for(int i=0;i<k;i++){
            scanf("%d",&m);
            while(!del.empty()){
                x=del.top();
                all.insert(make_pair(*(--pay[x].end()),x));
                del.pop();
            }
            for(int j=0;j<m;j++){
                scanf("%d",&x);
                if(!pay[x].empty()){
                    all.erase(make_pair(*(--pay[x].end()),x));
                    del.push(x);
                }
            }
            if(all.empty()) printf("0 0\n");
            else{
                it=all.end();
                --it;
                if(it==all.begin())
                    printf("%d %d\n",it->second,*pay[it->second].begin());
                else{
                    int temp=it->second;
                    --it;
                    int temp1=it->second;
                    int maxn=it->first;
                    int ans=*(upper_bound(pay[temp].begin(),pay[temp].end(),maxn));
                    printf("%d %d\n",temp,ans);
                    //cout<<temp<<' '<<ans<<endl;
                }
            }
        }
    }
}

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 (a_i, b_i), where a_i is the index of the person, who made this bid and b_i is its size. Bids are given in chronological order, meaning b_i < b_i + 1 for all i < n. Moreover, participant never makes two bids in a row (no one updates his own bid), i.e. a_i ≠ a_i + 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 a_i and b_i (1 ≤ a_i ≤ n, 1 ≤ b_i ≤ 10⁹, b_i < b_i + 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 l_j (1 ≤ l_j ≤ n) — the number of people who are not coming in this question and their indices. It is guarenteed that l_j 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.

Example

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. 1 10
  2. 2 100
  3. 1 10 000
  4. 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. 1 10
  2. 1 10 000
  The winner is, of course, participant number 1 but the winning bid is 10instead 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:
  1. 3 1 000
  2. 3 1 000 000
  The winner is participant 3 with the bid 1 000.