#include <bits/stdc++.h>

using namespace std;

struct segtree {
    int n;
    vector<int> t;
    segtree() = default;
    segtree(int n_) {
        n = n_;
        t.assign(4 * n, 0);
    }

    void upd(int v, int tl, int tr, int p, int vl) {
        if (tl + 1 == tr) {
            t[v] = vl;
            return;
        }
        int tm = (tl + tr) / 2;
        if (p < tm) upd(v * 2, tl, tm, p, vl);
        else upd(v * 2 + 1, tm, tr, p, vl);
        t[v] = max(t[v * 2], t[v * 2 + 1]);
    }

    int get(int v, int tl, int tr, int l, int r) {
        if (l <= tl && tr <= r) return t[v];
        if (tr <= l || tl >= r) return 0;
        int tm = (tl + tr) / 2;
        return max(get(v * 2, tl, tm, l, r), get(v * 2 + 1, tm, tr, l, r));
    }

    int getr(int v, int tl, int tr, int p, int vl) {
        if (tr <= p || t[v] <= vl) return -1;
        if (tl + 1 == tr) return tl;
        int tm = (tl + tr) / 2;
        int answ = getr(v * 2, tl, tm, p, vl);
        if (answ == -1) return getr(v * 2 + 1, tm, tr, p, vl);
        return answ;
    }
};

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

    int n, d; cin >> n >> d;
    vector<int> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    vector<int> ord(n);
    for (int i = 0; i < n; i++) ord[i] = i;
    sort(ord.begin(), ord.end(), [&](int i, int j) {
        return a[i] < a[j];
    });
    
    vector<int> pos(n);
    for (int i = 0; i < n; i++) pos[ord[i]] = i;
    vector<int> prv(n, 0);
    prv[ord[0]] = -1;
    for (int i = 1; i < n; i++) {
        if (a[ord[i]] == a[ord[i - 1]]) prv[ord[i]] = prv[ord[i - 1]];
        else prv[ord[i]] = i - 1;
    }
    set<int> st;
    segtree sg_x(n);
    auto add = [&](int i) {
        auto it = st.lower_bound(i);
        int prv = -1, nxt = -1;
        if (it != st.end()) {
            nxt = *it;
        }
        st.insert(i);
        if (st.find(i) != st.begin()) {
            auto it2 = --st.find(i);
            prv = *it2;
        }
        if (nxt == -1) {
            sg_x.upd(1, 0, n, i, 1e9);  
        } else{
            sg_x.upd(1, 0, n, i, nxt - i);
        }
        if (prv != -1) {
            sg_x.upd(1, 0, n, prv, i - prv);
        }
    };
    vector<int> x(n);
    int cur = 0;
    for (int i = 1; i < n; i++) {
        if (prv[ord[i]] == i - 1) {
            for (int j = cur; j < i; j++) {
                add(ord[j]);
            }
            for (int j = cur; j < i; j++) {
                int ans = sg_x.getr(1, 0, n, ord[j], d);
                if (ans == -1) x[j] = n;
                else x[j] = ans;
            }
            cur = i;
        }
    }
    segtree sg(n);
    vector<int> dp(n);
    vector<vector<int>> del(n);
    for (int i = 0; i < n; i++) {
        for (auto &u : del[i]) {
            sg.upd(1, 0, n, pos[u], 0);
        }
        if (prv[i] == -1) dp[i] = 1;
        else {
            dp[i] = sg.get(1, 0, n, 0, prv[i] + 1) + 1;
        }
        sg.upd(1, 0, n, pos[i], dp[i]);
        if (x[i] + d + 1 < n) del[x[i] + d + 1].push_back(pos[i]);
    }
    cout << dp[n - 1] << '\n';

    return 0;
}