天才acm(贪心+归并排序+倍增)

给定一个整数 M，对于任意一个整数集合 S，定义“校验值”如下:

从集合 S 中取出 M 对数(即 2∗M 个数，不能重复使用集合中的数，如果 S 中的整数不够 M 对，则取到不能取为止)，使得“每对数的差的平方”之和最大，这个最大值就称为集合 S 的“校验值”。

现在给定一个长度为 N 的数列 A 以及一个整数 T。

我们要把 A 分成若干段，使得每一段的“校验值”都不超过 T。

求最少需要分成几段。

输入格式
第一行输入整数 K，代表有 K 组测试数据。

对于每组测试数据，第一行包含三个整数 N,M,T 。

第二行包含 N 个整数，表示数列A1,A2…AN。

输出格式
对于每组测试数据，输出其答案，每个答案占一行。

数据范围
1≤K≤12,
1≤N,M≤500000,
0≤T≤1018,
0≤Ai≤220
输入样例：
2
5 1 49
8 2 1 7 9
5 1 64
8 2 1 7 9
输出样例：
2
1
该题用贪心+归并+倍增能比只用二分或倍增减少一个log（n）,代码如下：

#include <iostream>
#define ll long long
#include <bits/stdc++.h>
using namespace std;
ll x = 1;ll q,mod;ll n,m,t,k;ll a[500009],b[500009],c[500009];
inline ll read()
{
	ll x=0,f=1;char ch=getchar();
	while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}
	while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
	return x*f;
}
void merge_sort(ll l,ll r,ll mid){
    ll i = l,j = mid+1;
    for(ll p=l;p<=r;++p){
        if((b[i]<=b[j]&&i<=mid)||(j>r)){c[p] = b[i++]; }
        else c[p] = b[j++];
    }
    for(ll p=l;p<=r;++p){b[p] = c[p]; }
}
ll qpow(ll a){
    ll res = 1, t = a, k = mod-2;
    while(k){
        if(k&1)res*=t%mod;
        t*=t;t%=mod;
        k>>=1;
    }
    return res%mod;
}
bool judge(ll l,ll r,ll p){
    r = min(r,n);
    for(ll i=l;i<=min(r+p,n);++i){
        b[i] = a[i];
    }
    sort(b+r+1,b+min(r+p+1,n+1));
    merge_sort(l,min(n,r+p),r);
    ll x = l,y = min(r+p,n),ans = 0;
    for(ll i=1;i<=m;++i){
        if(x>=y){break; }
        ans+=(b[y]-b[x])*(b[y]-b[x]);
        x++;y--;
    }
    if(ans>t)return 0;
    for(ll i=l;i<=min(r+p,n);++i)a[i] = b[i];
    return 1;
}
void solve(){
    k=read();
    while(k--){
        n=read();m=read();t=read();
        for(ll i=1;i<=n;++i){
            a[i] = read();
        }
        ll l=1,r=1,p=1,cnt=0;
        while(r<=n){p = 1;
        while(p){
            if(r+p<=n&&judge(l,r,p)){r+=p;if(r>=n)break; p*=2; }
            else p/=2;
        }
        l = r+1;r = l;cnt++;
        }
        printf("%lld\n",cnt);
    }
}
int main()
{
    solve();
    return 0;
}

简单说一下几个坑点= =！就是你进行归并排序时不能刚开始就用a数组，因为你无法判断该方案是否合法，在你判断该方案时，[l,r]区间是已经拍好序的，这时候你只需要归并排序一次，即先sort(r+1,r+p+1)此区间，再用一次归并排序，即可排好序，排好序之后我们就要利用倍增的思想，每次p<<=1，去寻找该区间是否合法，当p为0时，即为最大合法区间。