bzoj 1112 砖块 KLO-Building blocks

这道题居然是treap。。。

根据题目的要求，我们可以发现，因为题目要求是用最小的修改次数（即+1，-1）达到连续k个相同

的数，根据数学上的玄学知识可以得知，在选取中位数的时候，修改次数最小。

证明：

当选择2到3点之间的时候，修改次数最小，假设选择了2，此时为s1+s2+s2+s3

而换成1的时候，虽然1不用到2的s1但是2,3,4都多了一步s1，所以只有在中位数的位置时才不会

有多余的步数，而如果是偶数个，选择2到3之间任何一个都可以，因为2和3左右的位置一定是偶数个

那么他们互相配对，一对到选择位置的值的和为s2。

那么选择之后这道题就清晰了一些，只需枚举每k个位置，求出排名为（k+1）/2的数，设为mid。

因为贡献是|a[2]-a[1]|+|a[2]-a[3]|+|a[2]-a[4]|，这样的绝对值形式，那么可以找出比mid小的数的和

和大于他的和，用（mid-1）$*$a[mid]-lsum+rsum-（k-mid）$*$a[mid]算出贡献，在计算结果即可

代码

#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<ctime>
#define ls tree[rt].lson
#define rs tree[rt].rson
using namespace std;
typedef long long ll;
struct Tree
{
    int lson;
    int rson;
    ll val;
    ll sum;
    int huge;
    int same;
    int rank;
}tree[100005];
void update(int rt)
{
    tree[rt].huge=tree[ls].huge+tree[rs].huge+tree[rt].same;
    tree[rt].sum=tree[ls].sum+tree[rs].sum+tree[rt].same*tree[rt].val;
}
void lturn(int &rt)
{
    int rc=rs;
    tree[rt].rson=tree[rc].lson;
    tree[rc].lson=rt;
    tree[rc].huge=tree[rt].huge;
    tree[rc].sum=tree[rt].sum;
    update(rt);
    rt=rc;
}
void rturn(int &rt)
{
    int rc=ls;
    tree[rt].lson=tree[rc].rson;
    tree[rc].rson=rt;
    tree[rc].huge=tree[rt].huge;
    tree[rc].sum=tree[rt].sum;
    update(rt);
    rt=rc;
}
int cnt;
void insert(int &rt,ll x)
{
    if(!rt)
    {
        rt=++cnt;
        tree[rt].val=x;
        tree[rt].huge=1;
        tree[rt].same=1;
        tree[rt].rank=rand();
        tree[rt].sum=x;
        return;
    }
    tree[rt].huge++;
    tree[rt].sum+=x;
    if(tree[rt].val==x)
    {
        tree[rt].same++;
        return;
    }
    if(x<tree[rt].val)
    {
        insert(ls,x);
        if(tree[rt].rank>tree[ls].rank)
        {
            rturn(rt);
        }
    }else
    {
        insert(rs,x);
        if(tree[rt].rank>tree[rs].rank)
        {
            lturn(rt);
        }
    }
}
void del(int &rt,ll x)
{
    if(!rt)return;
    if(tree[rt].val==x)
    {
        if(tree[rt].same>1)
        {
            tree[rt].same--;
            tree[rt].huge--;
            tree[rt].sum-=x;
            return;
        }
        if(ls*rs==0)
        {
            rt=ls+rs;
            return;
        }
        if(tree[ls].rank<tree[rs].rank)
        {
            rturn(rt);
            del(rt,x);
        }else
        {
            lturn(rt);
            del(rt,x);
        }
        return;
    }
    tree[rt].huge--;
    tree[rt].sum-=x;
    if(x<tree[rt].val)
    {
        del(ls,x);
    }else
    {
        del(rs,x);
    }
    //update(rt);
}
ll lsum,rsum;
int query_sum(int rt,int x)//求排名 
{
    if(!rt)return 0;
    if(x<=tree[ls].huge)
    {
        rsum+=tree[rs].sum+tree[rt].same*tree[rt].val;
        return query_sum(ls,x);
    }else if(x>tree[ls].huge+tree[rt].same)
    {
        lsum+=tree[ls].sum+tree[rt].same*tree[rt].val;
        return query_sum(rs,x-tree[rt].same-tree[ls].huge);
    }else
    {
        lsum+=tree[ls].sum+(x-tree[ls].huge-1)*tree[rt].val;
        rsum+=tree[rs].sum+(tree[ls].huge+tree[rt].same-x)*tree[rt].val;
        return tree[rt].val;
    }   
}
ll a[100005];
int main()
{
    srand(time(NULL));
    int n,k;
    scanf("%d%d",&n,&k);
    int mid=(k+1)/2;
    int root=0;
    ll ans,ans1;
    int tt,lret=1,rret=k;
    int t1;
    for(int i = 1;i <= n;i++)
    {
        scanf("%lld",&a[i]);
        insert(root,a[i]);
        if(i==k)
        {
            tt=query_sum(root,mid);
            ans=(mid-1)*tt-lsum+rsum-(k-mid)*tt;
        }
        if(i>k)
        {
            del(root,a[i-k]);
            lsum=0;rsum=0;
            t1=query_sum(root,mid);
            ans1=(mid-1)*t1-lsum+rsum-(k-mid)*t1;
            if(ans>ans1)
            {
                ans=ans1;
                lret=i-k+1;rret=i;
                tt=t1;
            }
        }
    }
    printf("%lld\n",ans);
/*  for(int i = 1;i <= n;i++)
    {
        if(i<lret||i>rret)
        {
            printf("%lld\n",a[i]);
        }else
        {
            printf("%lld\n",tt);
        }
    }*/
    return 0;
}