倍增

• 天才ACM

原题链接

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

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

现在给定一个长度为N的数列A以及一个整数T。我们要把A分成若干段，使得每一段“校验值”都不超过T。求最少需要分成几段？

即当确定一个左端点L之后，右端点R在A[L]~A[R]的校验值不超过T的前提下，最大能取到多少

---

倍增主要用于解决二分的缺点：如果每次询问给定的整数T都非常小，造成答案k也非常小，那么该算法可能还不如从前向枚举更优

---

因此对于这道题：

1.初始化p=1,R=L=0。

2.求出[L,R+p]这一段区间的“校验值”，若“校验值<=T”,则R+=p,p*=2；否则p/=2

3.重复上一步，直到p的值变为0，此时R即为所求

int start=0,end=0;
        while(end<n)
        {
            int len=1;
            while(len)
            {
                if(end+len<=n&&check(start,end+len))//(范围成立)&&(cheeck)
                {
                    end+=len;//更新起点
                    len<<=1;//更新扩大步伐
                }
                else 
                    len>>=1;//缩小步伐
                
            }
            start=end;//前一部分已经完成，下一段起点从终点开始
        }

---

时间复杂度：

以上过程最多循环O(logN)次，每次循环对长度为O(R-L)的一段进行排序，完成整个题目的求解累计扩展长度为N，因次总体时间复杂度为O(NlogN*logN)

优化：

在处理 [start,end)[start,end) 的时候，已经将 [start,end)[start,end) 排好序了，所以不需要在处理 [start,end+len)[start,end+len) 时再排序。

处理 [start,end+len)[start,end+len) 时，只需要将 [end,end+len)[end,end+len) 排序，然后将 [start,end)[start,end) 与 [end,end+len)[end,end+len) 这两段区间进行归并即可。

假设一共将数组划分成了 kk 个区间(这里的区间指的是每次二分里面check的区间总和，并非题目中所指的区间)，每个区间的长度分别为 len1,len2,⋯,lenklen1,len2,⋯,lenk。

那么按上述方法只需要将每个区间排序一遍，所以时间复杂度为 O(len1loglen1+len2loglen2+..+lenkloglenk)≤O(nlogn)
加上每次归并的时间复杂度为O(n)，总的时间复杂度为 O(n+nlogn)=O(nlogn)

---

收获一个精炼板块

for(int i=0;i<k&&i<m;i++,k--)
     sum+=sq(t[i]-t[k-1]);
//从最前(0)与最后(k-1)分别开始取最多m对,双指针取数

---

• 解法一： 倍增O(NlogN*logN)

#include<iostream>
#include<algorithm>

using namespace std;

typedef long long ll;

const int N=500005;

int num,n,m;
ll T;

ll a[N],t[N],temp[N];

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

bool check(ll l,ll r)
{
    int k=0;
    for(int i=l;i<r;i++)
        t[k++]=a[i];
    sort(t,t+k);
    ll sum=0;
    for(int i=0;i<k&&i<m;i++,k--)//最多取m对,双指针取数
        sum+=sq(t[i]-t[k-1]);
    return sum<=T;
}

int main()
{
    scanf("%d",&num);
    while(num--)
    {
        scanf("%d%d%lld",&n,&m,&T);
        for(int i=0;i<n;i++)
            scanf("%lld",&a[i]);
        int ans=0;
        ll start=0,end=0;
        while(end<n)
        {
            ll len=1;
            while(len)
            {
                if(end+len<=n&&check(start,end+len))//end从0开始可以取等号
                {
                    end+=len;
                    len<<=1;
                }
                else 
                    len>>=1;
                
            }
            start=end;
            ans++;
        }
        printf("%d\n",ans);
    }
    
    return 0;
}

• 解法二：倍增+归并(NlogN)

#include<iostream>
#include<algorithm>

using namespace std;

typedef long long ll;

const int N=500005;

ll a[N],t[N],temp[N];
ll num,n,m,T,ans;

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

bool check(ll l,ll mid,ll r)
{
    for(int i=mid;i<r;i++)//复制数组，check尝试可不可以，可能不可以的话，就要重来，所以必须备份
        t[i]=a[i];
    sort(t+mid,t+r);
    ll i=l,j=mid,k=0;
    while(i<mid&&j<r)
    {
        if(t[i]<t[j])
            temp[k++]=t[i++];
        else
            temp[k++]=t[j++];
    }
    while(i<mid)temp[k++]=t[i++];
    while(j<r)temp[k++]=t[j++];
    
    
   //计算校验值
   ll sum=0;
   for(int i=0;i<m&&i<k;i++,k--)
        sum+=sq(temp[i]-temp[k-1]);
    return sum<=T;
}

int main()
{
    scanf("%lld",&num);
    while(num--)
    {
        scanf("%lld%lld%lld",&n,&m,&T);
        for(int i=0;i<n;i++)
            scanf("%lld",&a[i]);
        ans=0;
        ll len,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;
                    for(ll i=start;i<end;i++)//temp里存的是从0开始的归并序列，所以要减去start
                        t[i]=temp[i-start];
                }
                else
                    len>>=1;
            }
            start=end;
            ans++;
        }
        printf("%lld\n",ans);
    }
    
    return 0;
}