Problem:
Score : 600 points

Problem Statement

There is a grid of squares with H+1 horizontal rows and W vertical columns.

You will start at one of the squares in the top row and repeat moving one square right or down. However, for each integer i from 1 through H, you cannot move down from the A_i-th, (A_i + 1)-th, \ldots, B_i-th squares from the left in the i-th row from the top.

For each integer k from 1 through H, find the minimum number of moves needed to reach one of the squares in the (k+1)-th row from the top. (The starting square can be chosen individually for each case.) If, starting from any square in the top row, none of the squares in the (k+1)-th row can be reached, print -1 instead.

Constraints

1 \leq H,W \leq 2\times 10^5

1 \leq A_i \leq B_i \leq W

Input

Input is given from Standard Input in the following format:

H W
A_1 B_1
A_2 B_2
:
A_H B_H

Output

Print H lines. The i-th line should contain the answer for the case k=i.

Sample Input 1

4 4
2 4
1 1
2 3
2 4

Sample Output 1

1
3
6
-1

Let (i,j) denote the square at the i-th row from the top and j-th column from the left.

For k=1, we need one move such as (1,1) → (2,1).

For k=2, we need three moves such as (1,1) → (2,1) → (2,2) → (3,2).

For k=3, we need six moves such as (1,1) → (2,1) → (2,2) → (3,2) → (3,3) → (3,4) → (4,4).

For k=4, it is impossible to reach any square in the fifth row from the top.

Solution in Java (OpenJDK 11.0.6) (judge verdict: Wrong Answer)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {
        new Main().solve();
    }

    private void solve() throws IOException {
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        StringTokenizer tokenizer = new StringTokenizer(f.readLine());
        int h = Integer.parseInt(tokenizer.nextToken());
        int w = Integer.parseInt(tokenizer.nextToken());

        int[][] intervals = new int[h][2];
        for (int i = 0; i < h; i++) {
            tokenizer = new StringTokenizer(f.readLine());
            intervals[i][0] = Integer.parseInt(tokenizer.nextToken()) - 1;
            intervals[i][1] = Integer.parseInt(tokenizer.nextToken()) - 1;
        }

        TreeSet<int[]> startAndEnd = new TreeSet<int[]>(new ArrayComparator());
        TreeSet<int[]> differences = new TreeSet<int[]>(new ArrayComparator());
        for (int i = 0; i < w; i++) {
            int[] pair = {i, i};
            startAndEnd.add(pair);
            int[] pair2 = {i, 0};
            differences.add(pair2);
        }


        for (int h1 = 0; h1 < h; h1++) {
            if (startAndEnd.isEmpty()) {
                out.println(-1);
                continue;
            }


            //System.out.println();
            int a = intervals[h1][0];
            int b = intervals[h1][1];
            int[] ar = {Integer.MAX_VALUE, a};
            SortedSet<int[]> notBeforeA = startAndEnd.tailSet(ar, true);
            if (!notBeforeA.isEmpty()) {
                int[] best = notBeforeA.first();
                ArrayList<int[]> removeInStartAndEnd = new ArrayList<int[]>();
                for (int[] toRemove : notBeforeA) {
                    if (toRemove[1] > b) break;
                    removeInStartAndEnd.add(toRemove);
                    int[] removeDiff = {toRemove[0], toRemove[1] - toRemove[0]};
                    if (!differences.contains(removeDiff)) throw new RuntimeException();
                    differences.remove(removeDiff);
                }
                for (int[] toRemove : removeInStartAndEnd){
                    startAndEnd.remove(toRemove);
                }
                if (best != null && best[1] <= b && b + 1 != w) {
                    best[1] = b + 1;
                    startAndEnd.add(best);
                    int[] diff = {best[0], best[1]- best[0]};
                    differences.add(diff);
                }
            }

            //System.out.println();
            if (startAndEnd.isEmpty()) {
                out.println(-1);
                continue;
            }
            out.println(differences.first()[1] + h1 + 1);
        }


        out.close();
    }

    private static class ArrayComparator implements Comparator<int[]> {

        @Override
        public int compare(int[] o1, int[] o2) {
            int compare1 = Integer.compare(o1[1], o2[1]);
            if (compare1 != 0) return compare1;
            return Integer.compare(o1[0], o2[0]) * -1;
        }
    }
}