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 C++ (GCC 9.2.1) (judge verdict: Wrong Answer)

#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"

using namespace std;

constexpr long long int MOD = 1000000007;
//constexpr int MOD = 1000000007;
//constexpr int MOD = 998244353;
//constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-12;

//int N, M, K, T, H, W, L, R;
long long int N, M, K, T, H, W, L, R;


int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);

	cin >> H >> W;
	vector<int>l(H);
	vector<int>r(H);
	for (int i = 0; i < H; i++) {
		cin >> l[i] >> r[i];
	}
	vector<int>ans;
	queue<pair<int, int>>Q;
	queue<int>numQ;
	if (l[0] >= 2) {
		Q.push({ 1,l[0] - 1 });
		numQ.push(1);
	}
	if (r[0] < W) {
		Q.push({ r[0] + 1,W });
		numQ.push(1);
	}
	if(Q.size())ans.push_back(1);
	else ans.push_back(MOD);
	for (int i = 1; i < H; i++) {
		int nx = MOD;
		int cnt = Q.size();
		while (cnt--) {
			int cl, cr;
			tie(cl, cr) = Q.front();
			Q.pop();
			int nl, nr;
			int num = numQ.front();
			numQ.pop();
			int nnum = 0;
			if (l[i] <= cl && cl <= r[i]&&r[i]!=W) {
				nl = r[i] + 1;
				nr = max(cr, nl);
				nnum = num + nr - cr + 1;
				nx = min(nx, nnum);
				Q.push({ nl,nr });
				numQ.push(nnum);
			}
			else if (cl < l[i]) {
				nl = cl;
				nr = min(l[i] - 1, cr);
				nnum = num + 1;
				nx = min(nx, nnum);
				Q.push({ nl,nr });
				numQ.push(nnum);
				if (cnt&&r[i] + 1 < Q.front().first) {
					nl = nr = r[i] + 1;
					nnum = num + nr - cr + 1;
					nx = min(nx, nnum);
					Q.push({ nl,nr });
					numQ.push(nnum);
				}
			}
			else if (r[i] < cl) {
				nl = cl, nr = cr;
				nnum = num + 1;
				nx = min(nx, nnum);
				Q.push({ nl,nr });
				numQ.push(nnum);
			}
		}
		ans.push_back(nx);
	}
	for (auto i : ans) {
		if (i == MOD)i = -1;
		cout << i << endl;
	}
}