Problem:
Score : 400 points

Problem Statement

You are given a sequence A_1, A_2, ..., A_N and an integer K.

Print the maximum possible length of a sequence B that satisfies the following conditions:

B is a (not necessarily continuous) subsequence of A.

For each pair of adjacents elements of B, the absolute difference of the elements is at most K.

Constraints

1 \leq N \leq 300,000

0 \leq A_i \leq 300,000

0 \leq K \leq 300,000

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K
A_1
A_2
:
A_N

Output

Print the answer.

Sample Input 1

10 3
1
5
4
3
8
6
9
7
2
4

Sample Output 1

7

For example, B = (1, 4, 3, 6, 9, 7, 4) satisfies the conditions.

It is a subsequence of A = (1, 5, 4, 3, 8, 6, 9, 7, 2, 4).

All of the absolute differences between two adjacent elements (|1-4|, |4-3|, |3-6|, |6-9|, |9-7|, |7-4|) are at most K = 3.

Solution in C++ (GCC 9.2.1) (judge verdict: Runtime Error)

#include <bits/stdc++.h>
using namespace std;
 
#define ll long long int
#define pb push_back
#define FastIO cin.sync_with_stdio(false),cin.tie(NULL)
#define file freopen("input.txt", "r", stdin),freopen("output.txt", "w", stdout)
 
 
ll max(ll a, ll b){
    if(a>b) return a;
    return b;}
 
ll min(ll a, ll b){
    if(a<b) return a;
    return b;}
 
ll ceil_div(ll a, ll b){return (a+b-1)/b;}
 
const ll N = 3e5 + 5, INF = 2e9+2, MOD = 998244353, M = 6000, K = 20;
int a[2*N], segment[4*N], b[N];
 
void build(int ind, int l, int r){
	if(r==l)return;
	if(r-l == 1){segment[ind] = a[l]; return;}
	int mid = (l+r)/2;
	build(ind*2, l , mid); build(ind*2+1, mid, r);
	segment[ind] = max(segment[2*ind], segment[2*ind+1]);
}

void update(int ind, int l ,int r, int i, int v){
	int mid = (l+r)/2;
	if(r-l == 1){segment[ind] = v; return;}
	if(i < mid)update(2*ind, l, mid, i, v);
	else update(2*ind+1, mid, r, i, v);
	segment[ind] = max(segment[2*ind], segment[2*ind+1]);
}

int ql , qr;
ll query(int ind, int l, int r){
	int mid = (l+r)/2;
	if(l >= ql && r <= qr)return segment[ind];
	if(r <= ql || l >= qr)return 0;
	ll ans = 0;
	ans = max(query(2*ind, l, mid), query(2*ind+1, mid, r));
	return ans;
}

int main(){
	FastIO;
	int n, k;
	cin >> n >> k;
	for(int i = 0; i < n; i++)cin >> b[i];
	a[b[0]] = 1;
	build(1, 0, 2*N);

	ll tp;
	for(int i = 1; i < n; i++){
		ql = max(0, b[i]-k); qr = min(2*N, b[i]+k+1);
		tp = query(1, 0, 2*N);
		a[b[i]] = tp+1;
		update(1, 0, 2*N, b[i], tp+1); 
	}

	cout << max(segment[1], *max_element(a, a+N) ) << "\n";


 
	return 0;
}