HihoCoder

Advanced CPU Manufacturer (ACM) is one of the best CPU manufacturer in the world. Every day, they manufacture n CPU chips and sell them all over the world.

As you may know, each batch of CPU chips must pass a quality test by the QC department before they can be sold. The testing procedure is as follows:

1) Randomly pick m pairs of CPU chips from the batch of chips (If there are less than 2m CPU chips in the batch of chips, pick as many pairs as possible.)

2) For each pair, measure the Relative Performance Difference (RPD) between the two CPU chips. Let D_i be the RPD of the i-th pair

3) Calculate the Sqared Performance Difference (SPD) of the batch according to the following formula:

SPD=∑D_i²

If there are only 1 CPU in a batch, then the SPD of that batch is 0.

4) The batch of chips pass the test if and only if SPD≤k, where k is a preseted constant

Usually they send all the n CPU chips as a single batch to the QC department every day. As one of the best CPU manufacturer in the world, ACM never fail the test. However, with the continuous improvement of CPU performance, they find that they are at risk!

Of course they don't want to take any risks. So they make a decision to divide the n chips into several batches to ensure all of them pass the test. What’s more, each batch should be a continuous subsequence of their productions, otherwise the QC department will notice that they are cheating. Quality tests need time and money, so they want to minimize the number of batches.

Given the absolute performance of the n chips P_{1 ...} P_n mesured by ACM in order of manufacture, your task is to determine the minimum number of batches to ensure that all chips pass the test. The RPD of two CPU chips equals to the difference of their absolute performance.

Input

The first line contains a single integer T, indicating the number of test cases.

In each test case, the first line contains three integers n, m, k. The second line contains n integers, P_{1 ...} P_n.

T≤12
1≤n,m≤5×10⁵
0≤k≤10¹⁸
0≤P_i≤2²⁰

Output

For each test case, print the answer in a single line.

Sample Input

2
5 1 49
8 2 1 7 9
5 1 64
8 2 1 7 9

Sample Output

2
1

思路一：对于每个起点，我们肯定要贪心地找到最大的一个右端点，使得其合法，这样一定是一个最优解。那么对于每个起点，二分终点，然后check，check时需要排序，每次check时间复杂度nlogn，因总共可能有O(n)段（最坏情况），
故时间复杂度n*n*logn*logn.
思路二：与一类似，不二分，换用倍增，因为每次找最大区间时，最坏排序2倍的合法长度，所以叠加起来时间复杂度n*logn*logn。但仍不足以通过此题。
思路三：在思路二的基础上，每次不重新排序，而考虑归并的思想，将倍增产生的新段排序，再与旧段合并，李煜东在蓝书上说这是nlogn的，感觉有待商榷，但运行确实快了不少，足以通过此题。

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cctype>
#include <cassert>
#include <bitset>
#include <ctime>

using namespace std;

#define pau system("pause")
#define ll long long
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define clr(a, x) memset(a, x, sizeof(a))

const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;

/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
tree<pli, null_type, greater<pli>, rb_tree_tag, tree_order_statistics_node_update> T;
*/

int get_int() {
    int res = 0; char c = getchar();
    while (!isdigit(c)) c = getchar();
    while (isdigit(c)) {
        res = res * 10 + c - '0';
        c = getchar();
    }
    return res;
}
int t, n, m, p[500015], b[500015], c[500015], d[500015];
ll k;
void merge_sort(int s, int e, int l) {
    for (int i = e + 1; i <= e + l; ++i) {
        c[i] = p[i];
    }
    sort(c + e + 1, c + e + l + 1);
    int i = s, j = e + 1, o = s;
    while (i <= e && j <= e + l) {
        if (b[i] < c[j]) d[o++] = b[i++];
        else d[o++] = c[j++];
    }
    while (i <= e) d[o++] = b[i++];
    while (j <= e + l) d[o++] = c[j++];
}
bool check(int s, int e, int l) {
    merge_sort(s, e, l);
    ll tcnt = 0;
    for (int j1 = s, j2 = e + l; j1 < j2 && j1 - s < m; ++j1, --j2) {
        tcnt += (ll)(d[j2] - d[j1]) * (d[j2] - d[j1]);
        if (tcnt > k) {
            return false;
        }
    }
    for (int i = s; i <= e + l; ++i) {
        b[i] = d[i];
    }
    return true;
}
int main() {
    scanf("%d", &t);
    while (t--) {
        scanf("%d%d%lld", &n, &m, &k);
        for (int i = 1; i <= n; ++i) p[i] = get_int();
        int ans = 0;
        for (int s = 1, e = 0, l = 1; s <= n; ) {
            int flag = check(s, e, l);
            //printf("s = %d, e = %d, l = %d, flag = %d
", s, e, l, flag);
            if (flag) {
                e = e + l;
                if (e == n) {
                    ++ans;
                    break;
                }
                l <<= 1;
                while (e + l > n) l >>= 1;
            } else {
                l >>= 1;
            }
            if (!l) {
                ++ans;
                s = e + 1;
                l = 1;
            }
        }
        printf("%d
", ans);
    }
    return 0;
}