Candy Box (hard version)
Contest: Codeforces Round 570 (Div. 3)
Difficulty rating: 2000
Tags: greedy, implementation, sortings

This problem is a version of problem D from the same contest with some additional constraints and tasks.

There are $$$n$$$ candies in a candy box. The type of the $$$i$$$-th candy is $$$a_i$$$ ($$$1 \le a_i \le n$$$).

You have to prepare a gift using some of these candies with the following restriction: the numbers of candies of each type presented in a gift should be all distinct (i. e. for example, a gift having two candies of type $$$1$$$ and two candies of type $$$2$$$ is bad).

It is possible that multiple types of candies are completely absent from the gift. It is also possible that not all candies of some types will be taken to a gift.

You really like some of the candies and don't want to include them into the gift, but you want to eat them yourself instead. For each candy, a number $$$f_i$$$ is given, which is equal to $$$0$$$ if you really want to keep $$$i$$$-th candy for yourself, or $$$1$$$ if you don't mind including it into your gift. It is possible that two candies of the same type have different values of $$$f_i$$$.

You want your gift to be as large as possible, but you don't want to include too many of the candies you want to eat into the gift. So, you want to calculate the maximum possible number of candies that can be included into a gift, and among all ways to choose maximum number of candies, you want to maximize the number of candies having $$$f_i = 1$$$ in your gift.

You have to answer $$$q$$$ independent queries.

If you are Python programmer, consider using PyPy instead of Python when you submit your code.

Input format:
The first line of the input contains one integer $$$q$$$ ($$$1 \le q \le 2 \cdot 10^5$$$) — the number of queries.

The first line of each query contains one integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) — the number of candies.

Then $$$n$$$ lines follow, each containing two integers $$$a_i$$$ and $$$f_i$$$ ($$$1 \le a_i \le n$$$, $$$0 \le f_i \le 1$$$), where $$$a_i$$$ is the type of the $$$i$$$-th candy, and $$$f_i$$$ denotes whether you want to keep the $$$i$$$-th candy for yourself ($$$0$$$ if you want to keep it, $$$1$$$ if you don't mind giving it away).

It is guaranteed that the sum of $$$n$$$ over all queries does not exceed $$$2 \cdot 10^5$$$.

Output format:
For each query print two integers:

- the maximum number of candies in a gift you can compose, according to the constraints in the statement;
- the maximum number of candies having $$$f_i = 1$$$ in a gift you can compose that contains the maximum possible number of candies.

Constraints:
Time limit: 2.0 s
Memory limit: 256.0 MB

Note:
In the first query, you can include two candies of type $$$4$$$ and one candy of type $$$5$$$. All of them have $$$f_i = 1$$$ and you don't mind giving them away as part of the gift.

Example input:
3
8
1 0
4 1
2 0
4 1
5 1
6 1
3 0
2 0
4
1 1
1 1
2 1
2 1
9
2 0
2 0
4 1
4 1
4 1
7 0
7 1
7 0
7 1

Example output:
3 3
3 3
9 5

Editorial:
First of all, to maximize the number of candies in the gift, we can use the following greedy algorithm: let's iterate on the number of candies of some type we take from $$$n$$$ to $$$1$$$ backwards. For fixed $$$i$$$, let's try to find any suitable type of candies. A type is suitable if there are at least $$$i$$$ candies of this type in the box. If there exists at least one such type that wasn't used previously, let's pick any such type and take exactly $$$i$$$ candies of this type (and decrease $$$i$$$). It does not matter which type we pick if we only want to maximize the number of candies we take.
Okay, let's now modify this solution to maximize the number of candies having $$$f_i = 1$$$. We initially could pick any type that has at least $$$i$$$ candies, but now we should choose a type depending on the number of candies with $$$f_i = 1$$$ in this type. For example, if we have two types having $$$x_1$$$ and $$$x_2$$$ candies with $$$f_i = 1$$$ respectively, and we want to pick $$$i_1$$$ candies from one type and $$$i_2$$$ candies from another type, and $$$x_1 > x_2$$$ and $$$i_1 > i_2$$$, it's better to pick $$$i_1$$$ candies of the first type and $$$i_2$$$ candies of the second type. In this case we have $$$min(x_1, i_1) + min(x_2, i_2)$$$ candies with $$$f_i = 1$$$, in the other case it's $$$min(x_2, i_1) + min(x_1, i_2)$$$. And if $$$x_1 > x_2$$$ and $$$i_1 > i_2$$$, then $$$min(x_1, i_1) + min(x_2, i_2) \ge min(x_2, i_1) + min(x_1, i_2)$$$. So, when we want to pick a type of candies such that we will take exactly $$$i$$$ candies of this type, it's optimal to choose a type that wasn't used yet, contains at least $$$i$$$ candies, and has maximum possible number of candies with $$$f_i = 1$$$. This best type can be maintained with a multiset or a set of pairs.