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];
                for (int[] ar : startAndEnd) System.out.println(Arrays.toString(ar));
                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]};
                       
                        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;
            }
        }
    }