2 seconds
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.
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.
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.
6
1 10
2 100
3 1000
1 10000
2 100000
3 1000000
3
1 3
2 2 3
2 1 2
2 100000
1 10
3 1000
3
1 10
2 100
1 1000
2
2 1 2
2 2 3
0 0
1 10
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.
题目链接：http://codeforces.com/problemset/problem/749/D
题意：有n次竞价，每次竞价格式为ai和bi（ai表示第i次竞标人的编号，bi表示第i次竞标的价格）。bi < bi + 1。自己不和自己竞标，即ai ！= ai + 1。q次询问，每次询问中有k中标号无效竞标，求每次询问后物品竞标编号和价格。
思路：set+二分。把每个人竞标的最高价和标号存储入set。每次询问，从set中删除k中标号。如果最后set为空，那么说明无人竞标输出0 0；如果set大小为1，那么说明只有一个人竞标，只需输出最低价格。如果set大小大于1，那么set中价格最高的标号为pos的人竞标成功。但是自己不能和自己竞标，所以最后的竞标价格为在pos所有的竞标价格中二分大于set中价格第二高的价格，为最终价格。
代码：
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
using namespace std;
const int MAXN=2e5+;
vector<int>v[MAXN];
int vis[MAXN],Max[MAXN];
int del[MAXN];
int main()
{
int n;
scanf("%d",&n);
for(int i=; i<=n; i++)
{
int a,b;
scanf("%d%d",&a,&b);
v[a].push_back(b);
vis[a]=;
Max[a]=max(Max[a],b);
}
set<pair<int,int> >s;
for(int i=; i<=n; i++)
if(vis[i]) s.insert(make_pair(Max[i],i));
int q;
scanf("%d",&q);
while(q--)
{
int k;
scanf("%d",&k);
for(int i=; i<=k; i++)
{
scanf("%d",&del[i]);
if(vis[del[i]]) s.erase(make_pair(Max[del[i]],del[i]));
}
if(s.size()==) cout<<<<" "<<<<endl;
else if(s.size()==)
cout<<s.begin()->second<<" "<<v[s.begin()->second][]<<endl;
else
{
set<pair<int,int> >::iterator it=s.end();
it--;
int pos=it->second;
it--;
int num=it->first;
int ans=upper_bound(v[pos].begin(),v[pos].end(),num)-v[pos].begin();
cout<<pos<<" "<<v[pos][ans]<<endl;
}
for(int i=; i<=k; i++)
if(vis[del[i]]) s.insert(make_pair(Max[del[i]],del[i]));
}
return ;
}