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: Time Limit Exceeded)

import java.util.Scanner;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

public class Main {
    
    private static class Move {
        private final int origin;
        private final int current;
        private final int gap;
        
        private Move(int i) {
            this.origin = i;
            this.current = i;
            this.gap = 0;
        }
        
        private Move(int origin, int current) {
            this.origin = origin;
            this.current = current;
            this.gap = current - origin;
        }
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        final int H = sc.nextInt();
        final int W = sc.nextInt();
        
        final int[][] cannotDown = new int[H][2];
        
        for (int i = 0; i < H; i++) {
            cannotDown[i][0] = sc.nextInt() - 1;
            cannotDown[i][1] = sc.nextInt() - 1;
        }
        
        TreeSet<Move> byCurrent = new TreeSet<>((m1, m2) -> m1.current != m2.current
                ? Integer.compare(m1.current, m2.current)
                : Integer.compare(m1.origin, m2.origin));
        TreeSet<Move> byGap = new TreeSet<>((m1, m2) -> m1.gap != m2.gap
                ? Integer.compare(m1.gap, m2.gap)
                : Integer.compare(m1.origin, m2.origin));
        for (int j = 0; j < W; j++) {
            Move m = new Move(j);
            byCurrent.add(m);
            byGap.add(m);
        }
        
        for (int i = 0; i < H; i++) {
            if (byCurrent.isEmpty()) {
                System.out.println(-1);
                continue;
            }
            
            int left = cannotDown[i][0];
            int right = cannotDown[i][1];
            
            SortedSet<Move> subset = byCurrent.subSet(new Move(0, left), new Move(W, right));
            
            if (!subset.isEmpty()) {
                Set<Move> subset2 = Set.copyOf(subset);
                Move edge1 = subset.last();
                byCurrent.removeAll(subset2);
                byGap.removeAll(subset2);
                
                if (right < W - 1) {
                    SortedSet<Move> tmp = byCurrent.subSet(new Move(0, right + 1), new Move(W, right + 1));
                    
                    if (tmp.isEmpty()) {
                        Move moved = new Move(edge1.origin, right + 1);
                        byCurrent.add(moved);
                        byGap.add(moved);
                    }
                }
            }
            
            if (byCurrent.isEmpty()) {
                System.out.println(-1);
            } else {
                Move minGap = byGap.first();
                System.out.println(minGap.gap + i + 1);
            }
        }
    }
}