BZOJ#3267. KC采花

3267: KC采花

Time Limit: 30 Sec Memory Limit: 256 MB
Submit: 152 Solved: 107

Description

KC在公园里种了一排花，一共有n朵，游手好闲的KC常常在公园里采花。他对每朵花都有一个美丽度鉴赏。由于对

花的喜好不同，有的花分数很高，有的花分数很低，甚至会是负数。KC很忙，每次采花的时候，不可能从第一朵花

，走到第n朵。所以他会先选定一个区间[l,r](1<=l<=r<=n)，作为当天的采花范围。同时为了方便采花，他总是从

[l,r]中最多选出k个互不相交的子区间，将这些子区间的花全部采光。当然，他希望美丽度总和最大。KC对花的鉴

赏随着他对世界观人生观的改变而改变，他会不时地对每朵花的美丽度进行修改，可能改低，也可能提高。KC的行

为持续m天，每天的行为要么是采花，要么是改变花的美丽度。注：(1)[l,r]的最多k个互不相同子区间可以表示成

：[x1,y1],[x2,y2],...,[xt,yt]，满足l<=x1<=y1<x2<=y2<...<xt<=yt<=r，且0<=t<=k。(2)由于是KC种的花，一

朵花采掉第二天会立刻生出来。

Input

第一行一个正整数n,n<=100000。

第二行n个整数a1,a2...an，表示n朵花的美丽度。|ai|<=500。

第三行一个正整数m,m<=100000。

第四行开始，接下来m行，每行表示该天KC的行为。

修改美丽度的行为用0 i val描述，表示将ai修改为val,|val|<=500。

采花行为用1 l r k描述,k<=20意义如题面。

n,m<=50000,k<=20,ai以及修改的val的绝对值不超过500。

Output

对于每个采花行为，每行一个整数表示最大的美丽度总和

Sample Input

9
9 -8 9 -1 -1 -1 9 -8 9
3
1 1 9 1
1 1 9 2
1 4 6 3

Sample Output

17
25
0

HINT

题目大意：给一段序列，任意选其中k段，求最大值，支持修改操作。

分析：考虑暴力怎么求，我们可以想出一个最大费用流的简单模型：

建边：
s-S 建边容量为K，费用为0；
S-每条边建边容量为1，费用为0；
每个点拆成两个点建边容量为1，费用为a[i]
每个点可以到到达下一个点，也可以退出。

求值：

进行K次增广，可得最后答案。

不足：

但是复杂度很高，直接做肯定是不可以的。

优化：

我们可以看到，每次他增广都是有规律的，路线是连续的，实际上它每次走的就是最大子序列，
所以我们可以模拟这个过程，每次选了一段最大序列，就把这个序列取法(模拟网络流的反边)。
可以用线段树来操作。
线段树就需要进行，维护最大序列，最小序列(每次要取反)，取反，单点修改。

挺好的一道题，思路挺新颖。

代码：

#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=1e5+12;
int n,m,a[N];
inline int read()
{
    int x=0,f=1; 
    char ch=getchar();
    while (ch<'0'||ch>'9') {if (ch=='-') f=-1;ch=getchar();}
    while (ch>='0'&&ch<='9') {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct data
{
    int lmax,rmax,maxn,sum,pl,pr,p1,p2;
    void add(int pos,int x) {p1=p2=pl=pr=pos,maxn=sum=lmax=rmax=x;}
};
struct SegmentTreeNode
{
    int l,r,lazy;
    data imax,mini;
    void add(int x) {imax.add(l,x); mini.add(l,-x);}
}tree[N<<2];
inline data merge(data l,data r)
{
    data now;
    now.sum=l.sum+r.sum;
    now.lmax=max(l.lmax,l.sum+r.lmax);
    if(now.lmax==l.lmax) now.pl=l.pl;else now.pl=r.pl;
    now.rmax=max(r.rmax,r.sum+l.rmax);
    if(now.rmax==r.rmax) now.pr=r.pr;else now.pr=l.pr;
    now.p1=l.pr;now.p2=r.pl;
    now.maxn=l.rmax+r.lmax;
    if(now.maxn<l.maxn) now.maxn=l.maxn,now.p1=l.p1,now.p2=l.p2;
    if(now.maxn<r.maxn) now.maxn=r.maxn,now.p1=r.p1,now.p2=r.p2;
    return now;
}

void pushup(int now)
{
    tree[now].mini=merge(tree[now<<1].mini,tree[now<<1|1].mini);
    tree[now].imax=merge(tree[now<<1].imax,tree[now<<1|1].imax);
}
inline void pushdown(int now)
{
    if(!tree[now].lazy||tree[now].l==tree[now].r) return ;
    swap(tree[now<<1].imax,tree[now<<1].mini);
    swap(tree[now<<1|1].imax,tree[now<<1|1].mini);
    tree[now<<1].lazy^=1;tree[now<<1|1].lazy^=1;
    tree[now].lazy^=1;
}
inline void build(int l,int r,int rt)
{
    tree[rt].l=l;tree[rt].r=r;tree[rt].lazy=0;
    if(l==r) {tree[rt].add(a[l]);return ;}
    int mid=(l+r)>>1;
    build(l,mid,rt<<1);build(mid+1,r,rt<<1|1);
    pushup(rt);
}

inline void updata(int L,int C,int now)
{
    pushdown(now);
    if(tree[now].l==tree[now].r) {tree[now].add(C);return ;}
    int mid=(tree[now].l+tree[now].r)>>1;
    if(L<=mid) updata(L,C,now<<1);
    else updata(L,C,now<<1|1);
    pushup(now);
}
inline data query(int L,int R,int now)
{
    pushdown(now);
    if(L==tree[now].l&&R==tree[now].r) {return tree[now].imax;}
    int mid=(tree[now].l+tree[now].r)>>1;
    if(R<=mid) return query(L,R,now<<1);
    if(L>mid) return query(L,R,now<<1|1);
    return merge(query(L,mid,now<<1),query(mid+1,R,now<<1|1));
}

inline void Reverse(int L,int R,int now)
{
    pushdown(now);
    if(L<=tree[now].l&&R>=tree[now].r) {swap(tree[now].imax,tree[now].mini);tree[now].lazy^=1;return ;}
    int mid=(tree[now].l+tree[now].r)>>1;
    if(L<=mid) Reverse(L,R,now<<1);
    if(R>mid) Reverse(L,R,now<<1|1);
    pushup(now);
}

struct Stack
{
    int l,r;
}stack[25];
int temp,ans;
inline void SolveAsk(int L,int R,int K)
{
    ans=0;temp=0;
    while(K--)
    {
        data t=query(L,R,1);
        if(t.maxn>0) ans+=t.maxn;else break;
        Reverse(t.p1,t.p2,1);
        stack[++temp]=(Stack){t.p1,t.p2};
    }
    while(temp) Reverse(stack[temp].l,stack[temp].r,1),temp--;
    printf("%d\n",ans);       
}
inline void Updata(int pos,int x) {updata(pos,x,1);}



int main()
{
//    freopen("a.in","r",stdin); 
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    scanf("%d",&m);
    build(1,n,1);
    int type,l,r,x;
    for(int i=1;i<=m;i++)
    {
        scanf("%d",&type);
        if(type==0)
        {
            scanf("%d%d",&l,&x);
            Updata(l,x);
            continue;
        }
        else 
        {
            scanf("%d%d%d",&l,&r,&x);
            SolveAsk(l,r,x);
            continue;
        }
    }
}

View Code