CodeForces - 280D k-Maximum Subsequence Sum 线段树模拟费用流操作

题意：给出序列a,长度为n

两种操作：1 将a[i]的值改为val

                   2 在【l,r】区间选择不相交的k段数，使这k段和最大，输出这个和。

解题: 如果是费用流，建图会将每个点拆点，然后限定每个点的流量为1，跑一边最小费用最大流就好了，但是这道题带修改而且数据范围较大不适合费用流。

         采用线段树模拟费用流操作，个人认为这道费用流可以用线段树模拟1是因为他的流路是顺序走的，只是按一段数连续走下去，再有就是每条边流量为1，这样就方便用线段树模拟，如果限定流量变大，或者流路不规则的话应该不方便用线段树模拟吧。

        很容易想到用一个延迟标记来标记区间流量是否正向走过或者反向走过。

        费用流中对于同一条边会建两条边，（cost,flow,u,v）和（-cost,0,v,u）;当一条边被正向走过x,那么反向走的流量会增加x,即提供一个修正的方式。

       这里因为流量都为1，所以可以建两个结构体，一个表示点权都为正cost情况下的node a,一个表示点权都为负cost情况下的node b,当一段区间的正向边被走过是，再统计这个区间中的值时只能用结构体b,如果反向边被走过则换为结构体a,不停反转即可，也就是区间延迟标记要记录的反转标记。

       单点更新不说了，主要是区间合并的问题，

       可以统计区间从左边界起的最大和和位置，从右边界起的最大和和位置，以及区间最大和的值和左右位置，这样当合并时只要选择1 合并左儿子右区间和右儿子左区间 2选左儿子  最大区间 3选右儿子最大区间 即可，选k段就跑k次查询，每次查询反转区间的值就好。

     ps.因为反转标记写错wa了n发。。下次写延迟标记真的不要弄乱了。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string.h>
#include<algorithm>
#include<stack>
using namespace std;
#define ls rt<<1
#define rs rt<<1|1
#define inf 100000000
const int maxn=100010;

//val为正向费用 fval为反向费用
//flag只是单纯的延迟标记,233..
//所以更新反转会有区间相交问题
//费用流通过反转费用实现自带维护
//再走就是原来费用相反的,
struct node
{
    int ql,qr,val,lval,rval,mal,mar,sum;
};
struct Tree{int l,r,flag;node a,b;}T[maxn<<2];//flag为流量标记
int a[maxn];
//0为正向费用 1为反向费用

//维护区间值max区间和区间值min的区间
//因为有正向费用和反向费用
//区间合并维护连左,连右的max值就好;

//考虑flag==0的情况

void pushup(int rt);

void build(int rt,int left,int right)
{
    T[rt].l=left;
    T[rt].r=right;
    T[rt].flag=0;
    if(left==right)
    {
        T[rt].a.ql=T[rt].a.qr=T[rt].a.mal=T[rt].a.mar=left;
        T[rt].a.val=T[rt].a.sum=T[rt].a.lval=T[rt].a.rval=a[left];
        T[rt].b.ql=T[rt].b.qr=T[rt].b.mal=T[rt].b.mar=left;
        T[rt].b.val=T[rt].b.sum=T[rt].b.lval=T[rt].b.rval=-a[left];
        return ;
    }
    int mid=(left+right)>>1;
    build(ls,left,mid);
    build(rs,mid+1,right);
    pushup(rt);
}

void pushdown(int rt)//反转正向费用和反向费用 正向反向取的都是区间最大值
{
   if(T[rt].flag)
   {

       T[ls].flag^=1;
       T[rs].flag^=1;
       T[rt].flag=0;
       swap(T[ls].a,T[ls].b);
       swap(T[rs].a,T[rs].b);
   }
}

void update(int rt,int pos,int val)//单点更新值
{
    if(T[rt].l==T[rt].r)
    {
        if(T[rt].l==pos)
        {
            T[rt].a.ql=T[rt].a.qr=T[rt].a.mal=T[rt].a.mar=pos;
            T[rt].a.val=T[rt].a.sum=T[rt].a.lval=T[rt].a.rval=val;
            T[rt].b.ql=T[rt].b.qr=T[rt].b.mal=T[rt].b.mar=pos;
            T[rt].b.val=T[rt].b.sum=T[rt].b.lval=T[rt].b.rval=-val;
        }
        return;
    }
    pushdown(rt);
    int mid=(T[rt].l+T[rt].r)>>1;
    if(pos<=mid) update(ls,pos,val);
    else update(rs,pos,val);
    pushup(rt);
}


void update2(int rt,int posl,int posr)//区间更新标记
{
    if(T[rt].l>=posl && T[rt].r<=posr)
    {
        swap(T[rt].a,T[rt].b);
//         cout<<T[rt].l<<" "<<T[rt].r<<" qian  "<<T[rt].a.val<<" "<<T[rt].flag<<endl;
        T[rt].flag^=1;
       //flag只是延迟标记,还是要换的
//           cout<<T[rt].l<<" "<<T[rt].r<<" hou "<<T[rt].a.val<<" "<<T[rt].flag<<endl;
        return;
    }
    pushdown(rt);
    int mid=(T[rt].l+T[rt].r)>>1;
    if(posl<=mid) update2(ls,posl,posr);
    if(posr>mid) update2(rs,posl,posr);
    pushup(rt);
}


//查询只能用合并,不能pushup
node merge(node ls2,node rs2)
{
    int tmp;
    node rt;
    //更新0
    rt.sum=ls2.sum+rs2.sum;
    //合并区间左右位置
    //更新lval
    tmp=ls2.sum+rs2.lval;
    if(tmp>ls2.lval) rt.lval=tmp,rt.ql=rs2.ql;
    else rt.lval=ls2.lval,rt.ql=ls2.ql;
    tmp=rs2.sum+ls2.rval;
    if(tmp>rs2.rval) rt.rval=tmp,rt.qr=ls2.qr;
    else rt.rval=rs2.rval,rt.qr=rs2.qr;
    //
    tmp=ls2.rval+rs2.lval;
    if(tmp>ls2.val && tmp>rs2.val)
    {
        rt.val=tmp;
        rt.mal=ls2.qr;
        rt.mar=rs2.ql;

    }
    else if(ls2.val>rs2.val)
    {
        rt.val=ls2.val;
        rt.mal=ls2.mal;
        rt.mar=ls2.mar;

    }
    else {
        rt.val=rs2.val;
        rt.mal=rs2.mal;
        rt.mar=rs2.mar;

    }
    return rt;
}
void pushup(int rt)
{
    T[rt].a=merge(T[ls].a,T[rs].a);
    T[rt].b=merge(T[ls].b,T[rs].b);
}

node query(int rt,int posl,int posr)
{

    if(T[rt].l==posl && T[rt].r==posr)
    {
//        cout<<" query "<<rt<<" "<<T[rt].l<<" "<<T[rt].r<<endl;
//        cout<<rt<<" return "<<T[rt].a.mal<<" "<<T[rt].a.mar<<endl;
        return T[rt].a;
    }
    pushdown(rt);
    int mid=(T[rt].l+T[rt].r)>>1;
    node tmp;
    if(posr<=mid) tmp=query(ls,posl,posr);
    else if(posl>mid) tmp=query(rs,posl,posr);
    else tmp=merge(query(ls,posl,mid),query(rs,mid+1,posr));
//    cout<<" query "<<rt<<" "<<T[rt].l<<" "<<T[rt].r<<endl;
//    cout<<tmp.val<<" return "<<tmp.mal<<" "<<tmp.mar<<endl;
    return tmp;
}


int op,val,l,r,k,pos;
stack<int>stl,str;
int main()
{
    int n,m;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        scanf("%d",&m);
        build(1,1,n);
        for(int i=1;i<=m;i++)
        {
            scanf("%d",&op);
            if(op==0)
            {
                scanf("%d%d",&pos,&val);
                update(1,pos,val);
                a[pos]=val;
            }
            else
            {
                scanf("%d%d%d",&l,&r,&k);
//                cout<<op<<" "<<l<<" "<<r<<" "<<k<<endl;
                int ans=0;
                for(int j=1;j<=k;j++)
                {
                    node tmp=query(1,l,r);
//                    cout<<tmp.val<<" "<<tmp.mal<<" "<<tmp.mar<<endl;
                    if(tmp.val<0) break;
                    ans+=tmp.val;
//                    cout<<" update2 "<<endl;
                    update2(1,tmp.mal,tmp.mar);
                    stl.push(tmp.mal);
                    str.push(tmp.mar);
                }
                printf("%d\n",ans);
                while(!stl.empty())
                {
                    int tp1=stl.top();stl.pop();
                    int tp2=str.top();str.pop();
                    update2(1,tp1,tp2);
                }
//                build(1,1,n);

            }
        }
    }
    return 0;
}