题目

题目

题解

参考题解：
https://www.acwing.com/solution/content/15458/
很好。

首先考虑我们用贪心证明两个东西：

1. 如果第$i$个可以归到前面的部分就归到前面的部分，不要放到后面的部分，反正放到后面也只会让校验值增大，还不如不放。
2. 对于一个数列而言，如何求校验值？答案是最大的减最小的的平方加上次大的…。
   至于证明，首先，如果对于$(x-y{)}^2(x>y)$，而数列中有 没有用的比$x$更大或比$y$更小的数字的话，那么我们肯定要用啊。
   第二，对于$a<b<c<d$而言，最大的方案肯定是：$(a-d{)}^2+(b-c{)}^2$，要证明的话全部化成平方和就变成了问两两数字相乘最小的问题了：$a^2+b^2+c^2+d^2-2ad-bc$，这个大家肯定都会证明的吧，不会证明看这里：
   
   通过这两个结论就可以证明了。

方法1

因为长度越长校验值越大，根据这个可以二分，也就是二分+check，但是如果每个块都很小的话时间复杂度就很容易被卡成：$O(K{n}^{2}lo{g}^{2}n)$，。

方法2

这个时候就要用到倍增了，倍增算法完美解决了二分处理小数据时无力的问题，倍增的流程是：

1. 确定一个$x=1,R=1$，然后如果$[1,R+x]$可以的话，那么$R+=x,x<<=1$，并重复1操作，但是如果不可以的话，$x>>=1$并跳到2操作。
2. 如果[1,R+x]可以的话，$R+=x$，不管可不可以，$x>>=1$并重复2操作直到$x=0$。

当然还有一种较慢的倍增：是如果不可以$x>>=1$，可以$x<<=1$，但是会慢（因为其实也是跟上面一样的流程，但是在2步骤中一旦可以会$x<<=1$又要花一次$x>>=1$来重回正轨）。

（其实我一开始的写法是是1操作没有$R+=x$，跳到2操作时再$R=x$，但是没必要，还会慢）

当然，上面的三种做法，单次的时间复杂度都是$O(\log t)$（$t$为最终的$R$），因此倍增是一个时间复杂度很优秀的算法，而且在处理数据块很小时更是展现出比二分大得多的优越性。（至于为什么，你可以把第一个步骤看成找最大$?$使得$2^{?}-1\le t$，至于第二个步骤，则是又把$?$遍历一遍，所以是$O(\log t)$）

采用快速排序的时间复杂度是$O(nlo{g}^{2}n)$。

证明我先写的下面的证明，哈哈：

设第$i$个块长度为$l_i$，且在倍增第一个步骤中$x$最大去到了$xx$。

注：计算校验值的时间复杂度是块长，而排序的复杂度大于等于块长，因此默认忽略校验值的时间复杂度计算。

第一个步骤是一个$log$，我们不管他，我们要证的是第二个步骤，第一个步骤完毕后，确定的$R$大于等于$\frac{l_i}{2}$，因为要check $log{l}_i$次，所以时间复杂度为：$O(Rlog{l}_{i}logR)=R(l_{i}lo{g}^2{l}_i)$。

所有块合并起来的时间复杂度就是：$O(nlo{g}^{2}n)$。

常数小可以AC此题。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define  N  510000
using  namespace  std;
int  a[N],b[N],n,m;
long  long  T;
inline  int  mymin(int  x,int  y){
    
    return  x<y?x:y;}
bool  check(int  x,int  now)
{
    
    
	int  l=now+1,r=x+now;
	int  t=0;
	for(int  i=l;i<=r;i++)b[++t]=a[i];
	sort(b+1,b+t+1);  
	int  f=t/2;
	long  long  ans=0;
	for(int  i=mymin(f,m);i>=1;i--)ans+=(long  long)(b[t-i+1]-b[i])*(b[t-i+1]-b[i]);
	return  ans<=T;
}
int  main()
{
    
    
	int  K;scanf("%d",&K);
	while(K--)
	{
    
    
		scanf("%d%d%lld",&n,&m,&T);
		for(int  i=1;i<=n;i++)scanf("%d",&a[i]);
		int  now=0,ans=0;
		while(now<n)
		{
    
    
			int  cnt=1,R=1;
			while(check(mymin(R+cnt,n-now),now)==1)
			{
    
    
				R+=cnt;
				if(R>n-now){
    
    R=n-now;break;}
				cnt*=2;
			}
			if(cnt!=n-now)
			{
    
    
				cnt/=2;
				while(cnt)
				{
    
    
					if(check(mymin(R+cnt,n-now),now)==1)
					{
    
    
						R+=cnt;
						if(R>n-now){
    
    R=n-now;break;}
					}
					cnt>>=1;
				}
			}
			now+=R;
			ans++;
		}
		printf("%d\n",ans);
	}
	return  0;
}

方法3

我们上面采用的是快速排序，但是如果用类似归并排序的方法呢？

即我现在已经知道了$X$，然后要对$X+Y$进行排序，那么就对$Y$进行排序，然后合并。

这个优化在较快的倍增中的第一个步骤中是毫无优化的，因为：$\frac{n}{2}\ast \log \frac{n}{2}\ast 2+n=n\log n$。

但是再第二个步骤中，就不会因为长度较小的$Y$而重复排序了，优化程度很大。

（下面证明用的是目前讲的最快的倍增打法）

那么我们现在就来证明一波时间复杂度：

设第$i$个块长度为$l_i$，且在倍增第一个步骤中$x$最大去到了$xx$。

注：计算校验值的时间复杂度是块长，而排序的复杂度大于等于块长，因此默认忽略校验值的时间复杂度计算。

对于第一个步骤而言：$O(1\ast log(1)+3\ast log(2)+7\ast log(4)+...+(2\ast xx-1)\ast log(xx)+(4\ast xx-1)\ast log(xx\ast 2))=O(xx\log xx)$（根据$a_1\log a_1+a_2\log a_2+...+a_i\log a_i\le sum\log sum$得出，$sum$为总和）

对于第二个步骤而言：
合并的话，即使假设单次合并的的时间是最终块长的两倍，那么时间复杂度也是：$O(lo{g}_{l_i}{l}_i)$，所以就是分析快速排序的时间复杂度：$O(1\ast log(1)+2\ast log(2)+4\ast log(4)+...+\frac{xx}{2}\ast log(\frac{xx}{2})=O(xx\log xx)$，因此对于一个块而言，时间复杂度即为：$O(l_i\log l_i)$，所有块时间复杂度一合并，就是$O(nlogn)$了。

代码：

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long ll;

const int N = 500005;

int n, m;
int ans;
ll T;
ll w[N], t[N];
ll tmp[N];

ll sq(ll x)
{
    
    
    return x * x;
}

bool check(int l, int mid, int r)           // 判断区间 [l, r) 是否合法，并将 t 中的 [l, mid) 区间和 [mid, r) 区间合并到 tmp 中
{
    
    
    for (int i = mid; i < r; i ++ )         // 将 w 数组的 [l, r) 区间复制到 t 的 [l, r) 区间中
        t[i] = w[i];
    sort(t + mid, t + r);                   // 将 t 的 [mid, r) 排序
    int i = l, j = mid, k = 0;              // 双指针进行区间合并
    while (i != mid && j != r)              // 当 i 不到 mid 且 j 不到 r 时，执行循环
        if (t[i] < t[j])                    // 如果 t[i] 比 t[j] 小，那么将 t[i] 放入 tmp 中
            tmp[k ++ ] = t[i ++ ]; 
        else                                // 否则将 t[j] 放入 tmp 中
            tmp[k ++ ] = t[j ++ ];
    while (i != mid) tmp[k ++ ] = t[i ++ ]; // 处理剩下的元素
    while (j != r) tmp[k ++ ] = t[j ++ ];
    ll sum = 0;                             // 计算校验值
    for (i = 0; i < m && i < k; i ++ , k -- )
        sum += sq(tmp[i] - tmp[k - 1]);
    return sum <= T;                        // 返回当前区间 [l, r) 是否合法
}

int main()
{
    
    
    int K;
    scanf("%d", &K);
    while (K -- )
    {
    
    
        scanf("%d %d %lld\n", &n, &m, &T);
        for (int i = 0; i < n; i ++ )
            scanf("%lld", &w[i]);
        ans = 0;
        int len;
        int start = 0, end = 0;
        while (end < n)
        {
    
    
            len = 1;
            while (len)
            {
    
    
                if (end + len <= n && check(start, end, end + len)) // 如果 w 的 [start, end + len) 区间合法
                {
    
    
                    end += len, len <<= 1;
                    if (end >= n) break ;               // 一个小剪枝，如果 end >= n，那么直接跳出
                    for (int i = start; i < end; i ++ ) // 在 check 时，已经将 t 数组的 [start, end + len) 这段区间归并在 tmp 中了。现在只需要将 tmp 中的有序数组复制到 t 中即可
                        t[i] = tmp[i - start];          // 复制的时候注意下标变换，tmp 是从 0 开始存的，t 是从 start 开始存的
                }
                else    len >>= 1;
            }
            start = end;
            ans ++ ;
        }
        printf("%d\n", ans);
    }
    return 0;
}

作者：垫底抽风
链接：https://www.acwing.com/solution/content/15458/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。