[题解]codeforces 280d k-Maximum Subsequence Sum

Discription

题目大意：
给出一个长度为 n 的序列 ${A_n}$, m 次操作, 操作有如下两种:
1. 给出 i,val, 把 $A_i$ 变成 val。
2. 给出 l,r,k, 询问把区间 [l, r] 划分成不超过 k 个不相交的区间,这些区间中数的和的最大值。区间可以不满k个，也可以一个数都不取。
数据范围:$n, m\leq10^5 , k\leq20$

Solution

线段树模拟费用流。
我们把每个点拆成两个节点,一个入点和一个出点。
对于序列中的一个点,其出点向汇点连一条容量为1,费用为0的边,其出点向下一个点的入点连一条容量为1,费用为0的边;这个点的入点向出点连一条容量为1,费用为 $A_i$的边。从源点向每个点的入点连一条容量为1,费用为0的边。
于是增广 k 次后的最大费用流即为答案。
这个的复杂度特别高,但是我们发现可以用线段树来模拟。
根据费用流的算法,每次找到最大子段和,然后将其乘以-1,重复 k 次这个操作即可得到答案。
于是复杂度为$O(knlog_2n)$,可以解决本题。
代码：（线段树要维护14个值）

#include<cstdio>
#include<algorithm>
using namespace std;

template<typename T>inline void read(T &x){
    T f=1;char ch=getchar();
    for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
    for(x=0;ch>='0'&&ch<='9';ch=getchar())x=x*10+ch-'0';
    x*=f;
}

const int maxn=100010;
struct Tag{
    int lmax,rmax,lmin,rmin;
    int rngmax,rngmin,sum;
    int lmaxp,rmaxp,lminp,rminp;
    int rngmaxl,rngmaxr,rngminl,rngminr;
};
Tag operator+(Tag taglc,Tag tagrc){
    Tag tagx;
    tagx.sum=taglc.sum+tagrc.sum;
    if(taglc.lmax>taglc.sum+tagrc.lmax)tagx.lmax=taglc.lmax,tagx.lmaxp=taglc.lmaxp;
    else tagx.lmax=taglc.sum+tagrc.lmax,tagx.lmaxp=tagrc.lmaxp;
    if(tagrc.rmax>tagrc.sum+taglc.rmax)tagx.rmax=tagrc.rmax,tagx.rmaxp=tagrc.rmaxp;
    else tagx.rmax=tagrc.sum+taglc.rmax,tagx.rmaxp=taglc.rmaxp;
    if(taglc.lmin<taglc.sum+tagrc.lmin)tagx.lmin=taglc.lmin,tagx.lminp=taglc.lminp;
    else tagx.lmin=taglc.sum+tagrc.lmin,tagx.lminp=tagrc.lminp;
    if(tagrc.rmin<tagrc.sum+taglc.rmin)tagx.rmin=tagrc.rmin,tagx.rminp=tagrc.rminp;
    else tagx.rmin=tagrc.sum+taglc.rmin,tagx.rminp=taglc.rminp;
    Tag tagtemp;
    if(taglc.rngmax>tagrc.rngmax)tagtemp=taglc;
    else tagtemp=tagrc;
    if(tagtemp.rngmax>taglc.rmax+tagrc.lmax)
        tagx.rngmax=tagtemp.rngmax,
        tagx.rngmaxl=tagtemp.rngmaxl,tagx.rngmaxr=tagtemp.rngmaxr;
    else tagx.rngmax=taglc.rmax+tagrc.lmax,
        tagx.rngmaxl=taglc.rmaxp,tagx.rngmaxr=tagrc.lmaxp;
    if(taglc.rngmin<tagrc.rngmin)tagtemp=taglc;
    else tagtemp=tagrc;
    if(tagtemp.rngmin<taglc.rmin+tagrc.lmin)
        tagx.rngmin=tagtemp.rngmin,
        tagx.rngminl=tagtemp.rngminl,tagx.rngminr=tagtemp.rngminr;
    else tagx.rngmin=taglc.rmin+tagrc.lmin,
        tagx.rngminl=taglc.rminp,tagx.rngminr=tagrc.lminp;
    return tagx;
}
struct Segment_Tree{
    #define lc x<<1
    #define rc x<<1|1
    int L[maxn<<2],R[maxn<<2],f[maxn<<2];
    Tag tag[maxn<<2];
    void init(int x,int val){
        tag[x].lmax=tag[x].rmax=tag[x].rngmax=tag[x].lmin=tag[x].rmin=tag[x].rngmin=val;
        tag[x].lmaxp=tag[x].rmaxp=tag[x].lminp=tag[x].rminp=L[x];tag[x].sum=val;
        tag[x].rngmaxl=tag[x].rngmaxr=tag[x].rngminl=tag[x].rngminr=L[x];
    }
    void update(int x){
        tag[x]=tag[lc]+tag[rc];
    }
    void Build(int x,int *a,int l,int r){
        L[x]=l;R[x]=r;f[x]=1;
        if(l==r)return init(x,a[l]),void();
        int mid=(l+r)>>1;
        Build(lc,a,l,mid);Build(rc,a,mid+1,r);
        update(x);
    }
    void pushtag(int x){
        swap(tag[x].lmax,tag[x].lmin);swap(tag[x].rmax,tag[x].rmin);
        swap(tag[x].lmaxp,tag[x].lminp);swap(tag[x].rmaxp,tag[x].rminp);
        swap(tag[x].rngmax,tag[x].rngmin);
        swap(tag[x].rngmaxl,tag[x].rngminl);swap(tag[x].rngmaxr,tag[x].rngminr);
        tag[x].sum*=-1;f[x]*=-1;
        tag[x].lmax*=-1;tag[x].rmax*=-1;
        tag[x].lmin*=-1;tag[x].rmin*=-1;
        tag[x].rngmax*=-1;tag[x].rngmin*=-1;
    }
    void pushdown(int x){
        if(f[x]==1)return;
        pushtag(lc);pushtag(rc);f[x]=1;
    }
    void Change(int x,int pos,int val){
        if(L[x]==R[x])return init(x,val),void();
        int mid=(L[x]+R[x])>>1;
        pushdown(x);
        if(pos<=mid)Change(lc,pos,val);
        else Change(rc,pos,val);
        update(x);
    }
    void Multi(int x,int l,int r){
        if(R[x]<l||L[x]>r)return;
        if(L[x]>=l&&R[x]<=r)return pushtag(x),void();
        pushdown(x);
        Multi(lc,l,r);Multi(rc,l,r);
        update(x);
    }
    Tag Query(int x,int l,int r){
        if(L[x]>=l&&R[x]<=r)return tag[x];
        int mid=(L[x]+R[x])>>1;
        pushdown(x);
        if(l<=mid&&r>mid)return Query(lc,l,r)+Query(rc,l,r);
        if(l<=mid)return Query(lc,l,r);
        else return Query(rc,l,r);
    }
}tree;
int n,m,a[maxn];

int main(){
    read(n);
    for(int i=1;i<=n;i++)read(a[i]);
    tree.Build(1,a,1,n);
    int opt,l,r,k,top,sta[25][2],ans;
    Tag temp;
    read(m);
    while(m--){
        read(opt);read(l);read(r);
        if(!opt)tree.Change(1,l,r);
        else{
            read(k);ans=top=0;
            while(k--){
                temp=tree.Query(1,l,r);
                if(temp.rngmax<=0)break;
                top++;ans+=temp.rngmax;
                tree.Multi(1,sta[top][0]=temp.rngmaxl,sta[top][1]=temp.rngmaxr);
            }
            while(top--)tree.Multi(1,sta[top+1][0],sta[top+1][1]);
            printf("%d\n",ans);
        }
    }
    return 0;
}