Trash Problem
Contest: Educational Codeforces Round 95 (Rated for Div. 2)
Difficulty rating: 2100
Tags: data structures, implementation

Vova decided to clean his room. The room can be represented as the coordinate axis $$$OX$$$. There are $$$n$$$ piles of trash in the room, coordinate of the $$$i$$$-th pile is the integer $$$p_i$$$. All piles have different coordinates.

Let's define a total cleanup as the following process. The goal of this process is to collect all the piles in no more than two different $$$x$$$ coordinates. To achieve this goal, Vova can do several (possibly, zero) moves. During one move, he can choose some $$$x$$$ and move all piles from $$$x$$$ to $$$x+1$$$ or $$$x-1$$$ using his broom. Note that he can't choose how many piles he will move.

Also, there are two types of queries:

- $$$0$$$ $$$x$$$ — remove a pile of trash from the coordinate $$$x$$$. It is guaranteed that there is a pile in the coordinate $$$x$$$ at this moment.
- $$$1$$$ $$$x$$$ — add a pile of trash to the coordinate $$$x$$$. It is guaranteed that there is no pile in the coordinate $$$x$$$ at this moment.

Note that it is possible that there are zero piles of trash in the room at some moment.

Vova wants to know the minimum number of moves he can spend if he wants to do a total cleanup before any queries. He also wants to know this number of moves after applying each query. Queries are applied in the given order. Note that the total cleanup doesn't actually happen and doesn't change the state of piles. It is only used to calculate the number of moves.

For better understanding, please read the Notes section below to see an explanation for the first example.

Input format:
The first line of the input contains two integers $$$n$$$ and $$$q$$$ ($$$1 \le n, q \le 10^5$$$) — the number of piles in the room before all queries and the number of queries, respectively.

The second line of the input contains $$$n$$$ distinct integers $$$p_1, p_2, \dots, p_n$$$ ($$$1 \le p_i \le 10^9$$$), where $$$p_i$$$ is the coordinate of the $$$i$$$-th pile.

The next $$$q$$$ lines describe queries. The $$$i$$$-th query is described with two integers $$$t_i$$$ and $$$x_i$$$ ($$$0 \le t_i \le 1; 1 \le x_i \le 10^9$$$), where $$$t_i$$$ is $$$0$$$ if you need to remove a pile from the coordinate $$$x_i$$$ and is $$$1$$$ if you need to add a pile to the coordinate $$$x_i$$$. It is guaranteed that for $$$t_i = 0$$$ there is such pile in the current set of piles and for $$$t_i = 1$$$ there is no such pile in the current set of piles.

Output format:
Print $$$q+1$$$ integers: the minimum number of moves Vova needs to do a total cleanup before the first query and after each of $$$q$$$ queries.

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

Note:
Consider the first example.

Initially, the set of piles is $$$[1, 2, 6, 8, 10]$$$. The answer before the first query is $$$5$$$ because you can move all piles from $$$1$$$ to $$$2$$$ with one move, all piles from $$$10$$$ to $$$8$$$ with $$$2$$$ moves and all piles from $$$6$$$ to $$$8$$$ with $$$2$$$ moves.

After the first query, the set becomes $$$[1, 2, 4, 6, 8, 10]$$$. Then the answer is $$$7$$$ because you can move all piles from $$$6$$$ to $$$4$$$ with $$$2$$$ moves, all piles from $$$4$$$ to $$$2$$$ with $$$2$$$ moves, all piles from $$$2$$$ to $$$1$$$ with $$$1$$$ move and all piles from $$$10$$$ to $$$8$$$ with $$$2$$$ moves.

After the second query, the set of piles becomes $$$[1, 2, 4, 6, 8, 9, 10]$$$ and the answer is the same (and the previous sequence of moves can be applied to the current set of piles).

After the third query, the set of piles becomes $$$[1, 2, 4, 8, 9, 10]$$$ and the answer is $$$5$$$ because you can move all piles from $$$1$$$ to $$$2$$$ with $$$1$$$ move, all piles from $$$2$$$ to $$$4$$$ with $$$2$$$ moves, all piles from $$$10$$$ to $$$9$$$ with $$$1$$$ move and all piles from $$$9$$$ to $$$8$$$ with $$$1$$$ move.

After the fourth query, the set becomes $$$[1, 2, 4, 8, 9]$$$ and the answer is almost the same (the previous sequence of moves can be applied without moving piles from $$$10$$$).

After the fifth query, the set becomes $$$[1, 2, 4, 8, 9, 100]$$$. You can move all piles from $$$1$$$ and further to $$$9$$$ and keep $$$100$$$ at its place. So the answer is $$$8$$$.

After the sixth query, the set becomes $$$[1, 2, 4, 8, 9, 50, 100]$$$. The answer is $$$49$$$ and can be obtained with almost the same sequence of moves as after the previous query. The only difference is that you need to move all piles from $$$50$$$ to $$$9$$$ too.

Example input:
5 6
1 2 6 8 10
1 4
1 9
0 6
0 10
1 100
1 50

Example output:
5
7
7
5
4
8
49

Example input:
5 8
5 1 2 4 3
0 1
0 2
0 3
0 4
0 5
1 1000000000
1 1
1 500000000

Example output:
3
2
1
0
0
0
0
0
499999999

Editorial:
First, let's understand that if we choose some subset of points $$$x_1, x_2, \dots, x_k$$$, then it does not matter to which point we move it (inside the segment [$$$\min(x_1, x_2, \dots, x_k); \max(x_1, x_2, \dots, x_k)]$$$) because the minimum number of moves will always be the same and it is equal to $$$\max(x_1, x_2, \dots, x_k) - \min(x_1, x_2, \dots, x_k)$$$.
Okay, we need to split all points into two subsets and collect all points of the first subset in some point inside it and the same with the second subset. What can we notice? If we sort the points, it's always optimal to choose these subsets as segments. I.e. if the maximum point of the first subset is $$$x_r$$$, the minimum point of the second subset is $$$x_l$$$ and $$$x_l < x_r$$$, we can swap them and decrease answers for both subsets.
So, we need to cover all the points with two segments with the minimum total length. What is this length? It is $$$x_n - x_1 - maxGap$$$. $$$MaxGap$$$ is the maximum distance between two consecutive points (i.e. $$$max(x_2 - x_1, x_3 - x_2, \dots, x_n - x_{n-1})$$$. So, we can solve the problem in $$$O(n \log{n})$$$ without queries. But how to deal with queries?
Let's maintain the set which contains all points $$$x_i$$$ and the multiset (set with repetitions) that maintains all gaps between two adjacent points. So, the answer is maximum in the set of points minus minimum in the set of points minus maximum in the multiset of lengths. How do we recalculate these sets between queries?
If some point $$$x$$$ is removed, let's find the maximum point less than $$$x$$$ (let it be $$$x_l$$$) and the minimum point greater than $$$x$$$ (let it be $$$x_r$$$) in the current set of points. Both these points can be found in a logarithmic time. Then we need to remove $$$x - x_l$$$ with $$$x_r - x$$$ from the multiset and add $$$x_r - x_l$$$ to the multiset (and, of course, remove $$$x$$$ from the set). If some point $$$x$$$ is added, then we need to remove $$$x_r - x_l$$$ from the multiset and add $$$x - x_l$$$ with $$$x_r - x$$$ to the multiset (and add $$$x$$$ to the set).
So, we can process every query in $$$O(\log{n + q})$$$ time and the total time complexity is $$$O((n+q) \log{(n + q)})$$$.