#include <bits/stdc++.h>
#define int long long
#define lson (rt << 1)
#define rson (rt << 1 | 1)

using namespace std;
template <class Info>
struct SegmentTree {
    vector <Info> tr;
    int n;
    
    SegmentTree () : n (0) {}
    
    SegmentTree (int N, vector <Info> a) : tr (N << 2 | 1) {
        n = N;
        auto build = [&] (auto self, int rt, int l, int r) -> void {
            if (l == r) {
                tr[rt] = a[l];
                return;
            }
            int mid = (l + r) >> 1;
            self (self, lson, l, mid); self (self, rson, mid + 1, r);
            pushup (rt);
		};
		build (build, 1, 1, n);
    }
    
    SegmentTree (int N) : tr (N << 2 | 1) {
        n = N;
    }
    
    void pushup (int rt) {
        tr[rt] = tr[lson] + tr[rson];
    }
    
    void modify (int rt, int l, int r, int x, const Info &y) {
        if (l == r) {
            tr[rt] = y;
            return;
        }
        int mid = (l + r) / 2;
        if (x <= mid) {
            modify (lson, l, mid, x, y);
        } else {
            modify (rson, mid + 1, r, x, y);
        }
        pushup (rt);
    }
    
    Info query (int rt, int l, int r, int x, int y) {
        if (l >= x && r <= y) {
            return tr[rt];
        }
        int mid = (l + r) >> 1;
        if (x <= mid && y > mid) {
            return query (lson, l, mid, x, y) + query (rson, mid + 1, r, x, y);
        }
        if (x <= mid) return query (lson, l, mid, x, y);
        return query (rson, mid + 1, r, x, y);
    }
    
    template <class F>
    int findFirst (int rt, int l, int r, int x, int y, F &&pred) {
        if (l > y || r < x) {
            return -1;
        }
        if (l >= x && r <= y && ! pred (tr[rt])) {
            return -1;
        } 
        if (l == r) {
            return l;
        }
        int mid = (l + r) / 2;
        int ans = findFirst (lson, l, mid, x, y, pred);
        if (ans == -1) {
            ans = findFirst (rson, mid + 1, r, x, y, pred);
        }
        return ans;
    }

    template <class F>
    int findLast (int rt, int l, int r, int x, int y, F &&pred) {
        if (l > y || r < x) {
            return -1;
        }
        if (l >= x && r <= y && ! pred (tr[rt])) {
            return -1;
        } 
        if (l == r) {
            return l;
        }
        int mid = (l + r) / 2;
        int ans = findLast (rson, mid + 1, r, x, y, pred);
        if (ans == -1) {
            ans = findLast (lson, l, mid, x, y, pred);
        }
        return ans;
    }
};

struct Info {
    int maxx = 0;
};

Info operator+(const Info &x, const Info &y) {
    Info c;
    c.maxx = max (x.maxx, y.maxx);
    return c;
}

void solve () {
    int n, k;
    cin >> n >> k;

    vector <int> a (n + 1);
    vector <vector <int>> id (n + 1);
    for (int i = 1; i <= n; i ++) {
        cin >> a[i];
        id[a[i]].push_back (i);
    }

    int ans = 0;
    SegmentTree <Info> seg (n);
    for (int i = n; i >= 1; i --) {
        const int m = id[i].size ();
        for (int j = 0; j <= m - k; j ++) {
            if (seg.query (1, 1, n, id[i][j], id[i][j + k - 1]).maxx == 0) {
                int x = seg.findLast (1, 1, n, 1, id[i][j], 
                    [&](const Info &info) {
                        return info.maxx > 0;
                    }
                );
                if (x == -1) {
                    x = 1;
                } else {
                    x ++;
                }
                int y = seg.findFirst (1, 1, n, id[i][j + k - 1], n, 
                    [&](const Info &info) {
                        return info.maxx > 0;
                    }
                );
                if (y == -1) {
                    y = n;
                } else {
                    y --;
                }
                ans += (id[i][j] - x + 1) * (y - id[i][j + k - 1] + 1);
            }
            seg.modify (1, 1, n, id[i][j], {1});
        }
        for (auto x : id[i]) {
            seg.modify (1, 1, n, x, {1});
        }
    }

    cout << ans << '\n';
}

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

    int T = 1;
    cin >> T;

    while (T --) {
        solve ();
    }
    
    return 0;
}