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: Accepted)

//Original Code:
//#include <self/utility>
//#include <self/debug>
//using namespace std;
//
//template <typename T>
//struct SegmentTreeMaxUpdate//[)
//{
//	T minValue=-1e9;
//	T* data=0;
//	T* tag=0;
//	int nn;
//	int size()
//	{
//		return nn;
//	}
//	void init(int size)
//	{
//		if(data) delete data;
//		if(tag) delete tag;
//		nn=1;
//		while(nn<size)
//		{
//			nn<<=1;
//		}
//		data=new T[nn*2+5];
//		tag=new T[nn*2+5];
//		for(int i=0;i<=nn*2;i++)
//		{
//			data[i]=minValue;
//			tag[i]=minValue;
//		}
//	}
//	void pushdown(int x)
//	{
//		if(x>=nn) return;
//		data[x*2]=max(data[x*2],tag[x]);
//		data[x*2+1]=max(data[x*2+1],tag[x]);
//		tag[x*2]=max(tag[x*2],tag[x]);
//		tag[x*2+1]=max(tag[x*2+1],tag[x]);
//		tag[x]=minValue;
//	}
//	void update(int pos,T value)
//	{
//		update(pos,pos+1,value);
//	}
//	void update(int ql,int qr,T value)
//	{
//		update(1,0,nn,ql,qr,value);
//	}
//	void update(int x,int l,int r,int ql,int qr,T value)
//	{
//		if(l>=qr || r<=ql) return;
//		pushdown(x);
//		if(l>=ql && r<=qr)
//		{
//			data[x]=max(data[x],value);
//			tag[x]=max(tag[x],value);
//			return;
//		}
//		update(x*2,l,l+r>>1,ql,qr,value);
//		update(x*2+1,l+r>>1,r,ql,qr,value);
//		data[x]=max(data[x*2],data[x*2+1]);
//	}
//	T query(int ql,int qr)
//	{
//		return query(1,0,nn,ql,qr);
//	}
//	T query(int x,int l,int r,int ql,int qr)
//	{
//		if(l>=qr || r<=ql) return minValue;
//		pushdown(x);
//		if(l>=ql && r<=qr)
//		{
//			return data[x];
//		}
//		return max(query(x*2,l,l+r>>1,ql,qr),query(x*2+1,l+r>>1,r,ql,qr));
//	}
//	inline T query()
//	{
//		return data[1];
//	}
//	~SegmentTreeMaxUpdate()
//	{
//		delete data;
//		delete tag;
//	}
//};
//SegmentTreeMaxUpdate <int> sgt;
//int n,k;
//int a[300005];
//
//int main()
//{
////	freopen("input.txt","r",stdin);
//	cin>>n>>k;
//	for(int i=0;i<n;i++)
//	{
//		scanf("%d",a+i);
//	}
//	sgt.init(300005);
//	for(int i=0;i<n;i++)
//	{
//		int l=max(0,a[i]-k);
//		int r=min(300000,a[i]+k);
//		sgt.update(a[i],sgt.query(l,r+1)+1);
//		sgt.update(a[i],1);
//	}
//	cout<<sgt.query()<<endl;
//	return 0;
//}

//substituted with C++ Inliner
#ifndef _SELF_UTILITY
#define _SELF_UTILITY 1
#include <numeric>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <string.h>
#include <stack>
#include <assert.h>
#include <bitset>
#include <time.h>
#define Endl endl
#define mp make_pair
#define ll long long 
#define ull unsigned long long
#define pii pair<int,int>
#define over(A) {cout<<A<<endl;exit(0);}
#define all(A) A.begin(),A.end()
#define quickcin ios_base::sync_with_stdio(false);
const int mod=1e9+7;
const int gmod=2;
const int inf=1039074182;
const ll llinf=1LL*inf*inf;
template <typename T1,typename T2> inline void chmin(T1 &x,T2 b) {if(b<x) x=b;}
template <typename T1,typename T2> inline void chmax(T1 &x,T2 b) {if(b>x) x=b;}
template <typename T1,typename T2> inline void chadd(T1 &x,T2 b) {x+=b;if(x>=mod) x-=mod;}
template <typename T1,typename T2> inline void chmul(T1 &x,T2 b) {x=1LL*x*b%mod;}
template <typename T1,typename T2> inline void chmod(T1 &x,T2 b) {x%=b,x+=b;if(x>=b) x-=b;}
template <typename T> inline T mabs(T x) {return (x<0?-x:x);}
#endif

#ifndef _SELF_DEBUG
#define _SELF_DEBUG 1
#ifndef _SELF_OPERATOR
#define _SELF_OPERATOR 1
using namespace std;
template <typename T>
ostream & operator << (ostream& cout,vector<T> vec)
{
	cout<<"{";
	for(int i=0;i<(int)vec.size();i++)
	{
		cout<<vec[i];
		if(i!=(int)vec.size()-1) cout<<',';
	}
	cout<<"}";
	return cout;
}

template <typename T1,typename T2>
ostream & operator << (ostream & cout,pair<T1,T2> p)
{
	cout<<"("<<p.first<<','<<p.second<<")";
	return cout;
}

template <typename T,typename T2>
ostream & operator << (ostream & cout,set <T,T2> s)
{
	vector <T> t;
	for(auto x:s) t.push_back(x);
	cout<<t;
	return cout;
}

template <typename T>
ostream & operator << (ostream & cout,multiset <T> s)
{
	vector <T> t;
	for(auto x:s) t.push_back(x);
	cout<<t;
	return cout;
}

template <typename T>
ostream & operator << (ostream &cout,queue <T> q)
{
	vector <T> t;
	while(q.size())
	{
		t.push_back(q.front());
		q.pop();
	}
	cout<<t;
	return cout;
}

template <typename T1,typename T2>
ostream & operator << (ostream &cout,map <T1,T2> m)
{
	for(auto &x:m)
	{
		cout<<"Key: "<<x.first<<' '<<"Value: "<<x.second<<endl;
	}
	return cout;
}

template <typename T>
T operator * (vector <T> v1,vector <T> v2)
{
	assert(v1.size()==v2.size());
	int n=v1.size();
	T res=0;
	for(int i=0;i<n;i++)
	{
		res+=v1[i]*v2[i];
	}
	return res;
}

template <typename T1,typename T2>
pair<T1,T2> operator + (pair<T1,T2> x,pair<T1,T2> y)
{
	return make_pair(x.first+y.first,x.second+y.second);
}

template <typename T1,typename T2>
void operator += (pair<T1,T2> &x,pair<T1,T2> y)
{
	x.first+=y.first;
	x.second+=y.second;
}

template <typename T1,typename T2>
pair<T1,T2> operator - (pair<T1,T2> x)
{
	return make_pair(-x.first,-x.second);
}

template <typename T>
vector<vector<T> > operator ~ (vector<vector <T> > vec)
{
	vector <vector<T> > v;
	int n=vec.size(),m=vec[0].size();
	v.resize(m);
	for(int i=0;i<m;i++)
	{
		v[i].resize(n);
	}
	for(int i=0;i<m;i++)
	{
		for(int j=0;j<n;j++)
		{
			v[i][j]=vec[j][i];
		}
	}
	return v;
}
#endif

void print0x(int x)
{
	std::vector <int> vec;
	while(x)
	{
		vec.push_back(x&1);
		x>>=1;
	}
	std::reverse(vec.begin(),vec.end());
	for(int i=0;i<(int)vec.size();i++)
	{
		std::cout<<vec[i];
	}
	std::cout<<' ';
}

template <typename T>
void print0x(T x,int len)
{
	std::vector <int> vec;
	while(x)
	{
		vec.push_back(x&1);
		x>>=1;
	}
	reverse(vec.begin(),vec.end());
	for(int i=vec.size();i<len;i++)
	{
		putchar('0');
	}
	for(int i=0;i<vec.size();i++)
	{
		std::cout<<vec[i];
	}
	std::cout<<' ';
}
#endif
using namespace std;

template <typename T>
struct SegmentTreeMaxUpdate//[)
{
	T minValue=-1e9;
	T* data=0;
	T* tag=0;
	int nn;
	int size()
	{
		return nn;
	}
	void init(int size)
	{
		if(data) delete data;
		if(tag) delete tag;
		nn=1;
		while(nn<size)
		{
			nn<<=1;
		}
		data=new T[nn*2+5];
		tag=new T[nn*2+5];
		for(int i=0;i<=nn*2;i++)
		{
			data[i]=minValue;
			tag[i]=minValue;
		}
	}
	void pushdown(int x)
	{
		if(x>=nn) return;
		data[x*2]=max(data[x*2],tag[x]);
		data[x*2+1]=max(data[x*2+1],tag[x]);
		tag[x*2]=max(tag[x*2],tag[x]);
		tag[x*2+1]=max(tag[x*2+1],tag[x]);
		tag[x]=minValue;
	}
	void update(int pos,T value)
	{
		update(pos,pos+1,value);
	}
	void update(int ql,int qr,T value)
	{
		update(1,0,nn,ql,qr,value);
	}
	void update(int x,int l,int r,int ql,int qr,T value)
	{
		if(l>=qr || r<=ql) return;
		pushdown(x);
		if(l>=ql && r<=qr)
		{
			data[x]=max(data[x],value);
			tag[x]=max(tag[x],value);
			return;
		}
		update(x*2,l,l+r>>1,ql,qr,value);
		update(x*2+1,l+r>>1,r,ql,qr,value);
		data[x]=max(data[x*2],data[x*2+1]);
	}
	T query(int ql,int qr)
	{
		return query(1,0,nn,ql,qr);
	}
	T query(int x,int l,int r,int ql,int qr)
	{
		if(l>=qr || r<=ql) return minValue;
		pushdown(x);
		if(l>=ql && r<=qr)
		{
			return data[x];
		}
		return max(query(x*2,l,l+r>>1,ql,qr),query(x*2+1,l+r>>1,r,ql,qr));
	}
	inline T query()
	{
		return data[1];
	}
	~SegmentTreeMaxUpdate()
	{
		delete data;
		delete tag;
	}
};
SegmentTreeMaxUpdate <int> sgt;
int n,k;
int a[300005];

int main()
{
//	freopen("input.txt","r",stdin);
	cin>>n>>k;
	for(int i=0;i<n;i++)
	{
		scanf("%d",a+i);
	}
	sgt.init(300005);
	for(int i=0;i<n;i++)
	{
		int l=max(0,a[i]-k);
		int r=min(300000,a[i]+k);
		sgt.update(a[i],sgt.query(l,r+1)+1);
		sgt.update(a[i],1);
	}
	cout<<sgt.query()<<endl;
	return 0;
}