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 Rust (1.42.0) (judge verdict: Accepted)

use whiteread::Reader;

fn main() {
    let mut rdr = Reader::from_stdin_naive();
    let (n, k): (usize, usize) = rdr.p();
    const SIZE: usize = 300_000;
    let mut st = data::SegmentTree::new(SIZE, 0, std::cmp::max);
    for _ in 0..n {
        let a: usize = rdr.p();
        let m = st.get(a.saturating_sub(k), a.saturating_add(k + 1)) + 1;
        st.set(a, m);
        //println!("{:?}", st);
    }
    println!("{}", st.get(0, SIZE));
}

mod data {
    pub struct SegmentTree<F, T> {
        size: usize,
        tree: Vec<T>,
        element: T,
        o: F,
    }

    impl<F, T> std::fmt::Debug for SegmentTree<F, T>
    where
        T: std::fmt::Debug,
    {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "{:?}", self.tree)
        }
    }

    impl<F, T> SegmentTree<F, T>
    where
        F: Fn(T, T) -> T,
        T: Copy + Eq,
    {
        pub fn new(size: usize, element: T, o: F) -> Self {
            let size = size.next_power_of_two();
            Self {
                size,
                tree: vec![element; size * 2],
                element,
                o,
            }
        }

        /// get [a, b)
        pub fn get(&self, a: usize, b: usize) -> T {
            self._get(a, b, 1, 0, self.size)
        }

        fn _get(&self, a: usize, b: usize, k: usize, l: usize, r: usize) -> T {
            if r <= a || b <= l {
                self.element
            } else if a <= l && r <= b {
                self.tree[k]
            } else {
                (self.o)(
                    self._get(a, b, k * 2, l, (l + r) / 2),
                    self._get(a, b, k * 2 + 1, (l + r) / 2, r),
                )
            }
        }

        pub fn set(&mut self, index: usize, value: T) {
            let mut i = self.size + index;
            while i != 0 {
                let v = (self.o)(value, self.tree[i]);
                if v == self.tree[i] {
                    break;
                }
                self.tree[i] = v;
                i /= 2;
            }
        }
    }
}