CodeForces 749D. Leaving Auction

传送门

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.

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 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:
  1. 3 1 000
  2. 3 1 000 000

  The winner is participant 3 with the bid 1 000.

题意：有n个人参加拍卖，一共有n次投标（这n个人中可以有人没投标也可以有人多次投标），投标按时间顺序给出：哪个人投标多少钱，注意不会有一个人连续两次投标（他不会自己和自己抢），现在问你如果有一些人没来参加拍卖的话，最终会是谁买花多少钱竞拍到。

题解：我们先要记录有哪些人参加了投标（可以用set，好方便计算最终参加投标的有多少人），以及他们每次投标的价格是多少（为了找到花费的最少的钱），每次询问的时候我们将不参加的人从set中删掉，如果最终没人投标那么输出0 0，如果参加投标的人只有一个显然输出那个人的编号和他第一次投标的价格，当参加投标的人超过一个时，我们可以找出出价最高的两个人，再在出价最高的人中选出他投标价格中比另一个人最高价高的最低价。注意询问结束后要将之前删掉的人加回去不影响后面的计算。这题用好set操作就行了。

代码：

#include <cstdio>

#include <cstring>

#include <algorithm>

#include <set>

#include <vector>

#include <cstdlib>

#define ll long long

#define ull unsigned ll

using namespace std;

const int N = 2e5 + ;

const double eps = 1e-;

vector<int> v[N];

int x[N];

struct node{

    int id,ma;

    node(int id,int ma) {

        this->id = id;

        this->ma = ma;

    }

    bool operator < (const node &x)const {

        return ma > x.ma;

    }

};

set<node> s;

int main() {

    int n,a,b,q,k;

    scanf("%d",&n);

    for (int i = ; i < n; i++) {

        scanf("%d%d",&a,&b);

        v[a].push_back(b);

    }

    for (int i = ; i <= n; i++)

        if (v[i].size()) s.insert(node(i,v[i][v[i].size()-]));

    scanf("%d",&q);

    while(q--) {

        scanf("%d",&k);

        for (int i = ; i < k; i++) {

            scanf("%d",&x[i]);

            if(v[x[i]].size() == ) continue;

            s.erase(node(x[i],v[x[i]][v[x[i]].size()-]));

        }

        if (s.size() == ) printf("0 0\n");

        else if (s.size() == ) {

            a = s.begin()->id;

            printf("%d %d\n", a,v[a][]);

        } else {

            set<node>::iterator t = s.begin();

            int max1 = t->ma,pos1 = t->id;

            s.erase(s.begin());

            set<node>::iterator it = s.begin();

            int max2 = it->ma,pos2 = it->id;

            int i = upper_bound(v[pos1].begin(),v[pos1].end(),max2)-v[pos1].begin();

            printf("%d %d\n", pos1,v[pos1][i]);

            s.insert(*t);

        }

        for (int i = ; i < k; i++) {

            if (v[x[i]].size() == ) continue;

            s.insert(node(x[i],v[x[i]][v[x[i]].size()-]));

        }

    }

    return ;

}