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

Discription

題目大意：
給出一個長度爲 n 的序列 An , m 次操作, 操作有如下兩種:
1. 給出 i,val, 把 Ai 變成 val。
2. 給出 l,r,k, 詢問把區間 [l, r] 劃分成不超過 k 個不相交的區間,這些區間中數的和的最大值。區間可以不滿k個，也可以一個數都不取。
數據範圍:n,m≤105,k≤20

Solution

線段樹模擬費用流。
我們把每個點拆成兩個節點,一個入點和一個出點。
對於序列中的一個點,其出點向匯點連一條容量爲1,費用爲0的邊,其出點向下一個點的入點連一條容量爲1,費用爲0的邊;這個點的入點向出點連一條容量爲1,費用爲 Ai 的邊。從源點向每個點的入點連一條容量爲1,費用爲0的邊。
於是增廣 k 次後的最大費用流即爲答案。
這個的複雜度特別高,但是我們發現可以用線段樹來模擬。
根據費用流的算法,每次找到最大子段和,然後將其乘以-1,重複 k 次這個操作即可得到答案。
於是複雜度爲O(knlog2n) ,可以解決本題。
代碼：（線段樹要維護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;
}