【GDOI2016模拟3.20】diyiti

题意

给定一列数a[N]
有两种操作，共M个：
0 x val 把a[x]的值改成val；
1 l r k 在l~r区间里选定不超过K个不相交的子段，即选定不超过k个独立区间，使他们加起来的权值最大。当然可以不选。
1<=n,m<=100000,k<=20

分析

一看到这种题就是什么数据结构乱搞一通啦，可是看到操作1就有点懵逼了，到底怎样才能作出最佳的决策呢?暴力法来个大DP，然而过不了，不能用线段树维护。哎，想想有什么方法能模拟出线段树呢？想想，至多弄k次，每次应该碰到有利的就尽量多走，又不是贪心，要修正之前的决策……哦，最大费用限制网络流。限制只能流 K次，构图后每次可以连续走好多个点，即取很多个连续的数，然后构反向弧，网络流的证明就感性吧···反正网络流的各种东西都很鬼畜
当然用网络流直接搞比DP还要慢很多，肯定要用线段树。那就线段树模拟咯。要最大费用，那么就是最大区间，要构反向弧，所以整个区间全部乘-1。注意，最后一定要还原，因为每个询问独立。
然后就是构造了，区间 和、区间内的最大值与最小值还有位置、从右边开始的、从左边开始的。不是维护最大值吗，维护最小值干嘛呢？想想吧。
这道题是道好题，思路比较新颖吧，又网络流又线段树，而且如果用好打代码技巧，是很好打的，虽然看上去繁琐。

贴上代码

#include<cstdio>
#include<algorithm>
#include<iostream>
#define fo(i,j,k) for(i=j;i<=k;i++)
#define fd(i,j,k) for(i=j;i>=k;i--)
using namespace std;
const int N=100005;
const int rev=1000;
struct reg
{
    int l,r,t;
}dur,op[25];
struct rec
{
    reg lmn,rmn,lmx,rmx,mn,mx,b;
    bool rev;
}b[N*6],temp;

int n,m,i,j,kase,l,r,k,x,y,a[N],ans,tot;



reg ri(reg a) {return {a.l,a.r,-a.t};}
reg operator +(reg a,reg b) {return {a.l,b.r,a.t+b.t};}
reg min(reg a,reg b){if (a.t<b.t) return a;else return b;}
reg max(reg a,reg b){if (a.t>b.t) return a;else return b;}
int reverse(int x)
{
    rec p=b[x];
    p.rev=0;
    p.b=ri(b[x].b);
    p.lmn=ri(b[x].lmx);
    p.lmx=ri(b[x].lmn);
    p.rmn=ri(b[x].rmx);
    p.rmx=ri(b[x].rmn);
    p.mn=ri(b[x].mx);
    p.mx=ri(b[x].mn);
    b[x]=p;
}

rec combine(rec a,rec b)
{
    rec p;
    p.lmn=min(a.b+b.lmn,a.lmn);
    p.lmx=max(a.b+b.lmx,a.lmx);
    p.rmn=min(a.rmn+b.b,b.rmn);
    p.rmx=max(a.rmx+b.b,b.rmx);
    p.b=a.b+b.b;
    p.mx=max(max(a.mx,b.mx),max(a.rmx+b.lmx,p.b));
    p.mn=min(min(a.mn,b.mn),min(a.rmn+b.lmn,p.b));
    p.rev=0;
    return p;
}

int make(int x,int l,int r)
{
    if (l==r)
    {
        b[x].b=b[x].lmn=b[x].rmn=b[x].mn=b[x].mx=b[x].lmx=b[x].rmx={l,r,a[l]};
        b[x].rev=0;
        return 0;
    }
    int m=(l+r)/2;
    make(x*2,l,m);
    make(x*2+1,m+1,r);
    b[x]=combine(b[x*2],b[x*2+1]);
}

int pdd(int x,int l,int r)
{
    if (b[x].rev)
    {
        reverse(x);
        if (!(l==r))
        {
            b[x*2].rev^=1;
            b[x*2+1].rev^=1;
        }
    }
}
int change(int x,int l,int r,int i,int j,int val)
{
    int m=(l+r)/2;
    pdd(x*2,l,m);
    pdd(x*2+1,m+1,r);
    if (l==i&&r==j)
    {
        if ((!(i==j))&&val==rev)
        {
            b[x*2].rev^=1;
            b[x*2+1].rev^=1;
        }
        if (val==rev)
            reverse(x);
        else 
        {
            b[x].b=b[x].lmn=b[x].rmn=b[x].mn=b[x].mx=b[x].lmx=b[x].rmx={l,r,val};
            b[x].rev=0;
        }
        return 0;
    }
    if (j<=m)
        change(x*2,l,m,i,j,val);
    else if (i>m)
        change(x*2+1,m+1,r,i,j,val);
    else
    {
        change(x*2,l,m,i,m,val);
        change(x*2+1,m+1,r,m+1,j,val);
    }
    b[x]=combine(b[x*2],b[x*2+1]);
}

rec get(int x,int l,int r,int i,int j)
{
    int m=(l+r)/2;
    pdd(x*2,l,m);
    pdd(x*2+1,m+1,r);
    if (l==i&&r==j)
        return b[x];
    if (j<=m)
        return get(x*2,l,m,i,j);
    else if (i>m)
        return get(x*2+1,m+1,r,i,j);
    else
        return combine(get(x*2,l,m,i,m),get(x*2+1,m+1,r,m+1,j));
}


int main()
{
    scanf("%d",&n);
    fo(i,1,n) scanf("%d",a+i);
    make(1,1,n);
    scanf("%d",&m);
    fo(i,1,m)
    {
        scanf("%d",&kase);
        if (kase)
        {
            scanf("%d %d %d",&l,&r,&k);
            ans=0;
            tot=0;
            fo(j,1,k)
            {
                dur=get(1,1,n,l,r).mx;
                change(1,1,n,dur.l,dur.r,rev);
                op[j]=dur;
                tot+=dur.t;
                if (tot>ans) ans=tot;
            }
            fd(j,k,1)
                change(1,1,n,op[j].l,op[j].r,rev);
            printf("%d\n",ans);
        }
        else
        {
            scanf("%d %d",&x,&y);
            change(1,1,n,x,x,y);
        }
    }
}

最后说两句

懵逼的是我下传区间修改的懒标记老是忘记往下再传一层，即目前搜索到的节点在合并的时候不会出事。改了我好久呢···
一定要记住的是，查询区间最大值也要像正常线段树合并一样合并上去，所以多打几个函数是好事，省事好调。