bzoj3638

费用流+线段树

看见这个题我们马上就能想到费用流，设立源汇，分别向每个点连接容量为1费用为0的边，然后相邻的点之间连边，费用为点权，跑费用流就行了，但是很明显这样会超时，那么我们要优化一下，我们观察费用流的过程，发现对于点与点之间的边，每次取一段区间相当于把正向边改为反向边，费用变负，于是我们可以用线段树来模拟这个过程，像费用流一样贪心地选取区间的最大子段和，然后取反，每次取k次，然后恢复。这样就好了

但是写的时候有很多问题，比如如何返回一个区间？结构体！参考了popoqqq大神的代码，发现我们可以通过重载小于号直接对结构体取max，这样就十分好写了

然后这道题有点卡常，一定要在重载的时候把传入参数变成const+引用，这样在cf上快了200ms

这就是传说中的五倍经验吗

#include<bits/stdc++.h>
using namespace std;
const int N = ;
namespace IO
{
    const int Maxlen = N * ;
    char buf[Maxlen], *C = buf;
    int Len;
    inline void read_in()
    {
        Len = fread(C, , Maxlen, stdin);
        buf[Len] = '\0';
    }
    inline void fread(int &x)
    {
        x = ;
        int f = ;
        while (*C < '' || '' < *C) { if(*C == '-') f = -; ++C; }
        while ('' <= *C && *C <= '') x = (x << ) + (x << ) + *C - '', ++C;
        x *= f;
    }
    inline void read(int &x)
    {
        x = ;
        int f = ; char c = getchar();
        while(c < '' || c > '') { if(c == '-') f = -; c = getchar(); }
        while(c >= '' && c <= '') { x = (x << ) + (x << ) + c - ''; c = getchar(); }
        x *= f;
    }
    inline void read(long long &x)
    {
        x = ;
        long long f = ; char c = getchar();
        while(c < '' || c > '') { if(c == '-') f = -; c = getchar(); }
        while(c >= '' && c <= '') { x = (x << 1ll) + (x << 3ll) + c - ''; c = getchar(); }
        x *= f;
    }
} using namespace IO;
struct data {
    int l, r, v;
    data() {}
    data(int l, int r, int v) : l(l), r(r), v(v) {}
    friend bool operator < (const data &a, const data &b) { return a.v < b.v; }
    friend data operator + (const data &a, const data &b) { return data(a.l, b.r, a.v + b.v); }
};
struct node {
    data lmax, rmax, mx, mn, lmin, rmin, sum;
    int tag;
    node() {}
    node(int x, int v) {
        lmax = rmax = mx = mn = lmin = rmin = sum = data(x, x, v);
    }
    friend node operator + (const node &a, const node &b) {
        node c;
        if(a.tag == -) return b;
        if(b.tag == -) return a;
        c.tag = ;
        c.sum = a.sum + b.sum;
        c.lmax = max(a.lmax, a.sum + b.lmax);
        c.lmin = min(a.lmin, a.sum + b.lmin);
        c.rmax = max(b.rmax, a.rmax + b.sum);
        c.rmin = min(b.rmin, a.rmin + b.sum);
        c.mx = max(max(a.mx, b.mx), a.rmax + b.lmax);
        c.mn = min(min(a.mn, b.mn), a.rmin + b.lmin);
        return c;
    }
} tree[N << ], st[];
int n, q;
int a[N];
void paint(node &o)
{
    swap(o.lmax, o.lmin);
    swap(o.rmax, o.rmin);
    swap(o.mx, o.mn);
    o.sum.v *= -;
    o.lmax.v *= -;
    o.lmin.v *= -;
    o.rmax.v *= -;
    o.rmin.v *= -;
    o.mx.v *= -;
    o.mn.v *= -;
    o.tag ^= ;
}
void pushdown(int x)
{
    if(tree[x].tag <= ) return;
    paint(tree[x << ]);
    paint(tree[x <<  | ]);
    tree[x].tag ^= ;
}
void build(int l, int r, int x)
{
    if(l == r)
    {
        tree[x] = node(l, a[l]);
        return;
    }
    int mid = (l + r) >> ;
    build(l, mid, x << );
    build(mid + , r, x <<  | );
    tree[x] = tree[x << ] + tree[x <<  | ];
}
node query(int l, int r, int x, int a, int b)
{
    if(l > b || r < a) return tree[];
    if(l >= a && r <= b) return tree[x];
    pushdown(x);
    int mid = (l + r) >> ;
    return (query(l, mid, x << , a, b)) + (query(mid + , r, x <<  | , a, b));
}
void reverse(int l, int r, int x, int a, int b)
{
    if(l > b || r < a) return;
    if(l >= a && r <= b)
    {
        paint(tree[x]);
        return;
    }
    pushdown(x);
    int mid = (l + r) >> ;
    reverse(l, mid, x << , a, b);
    reverse(mid + , r, x <<  | , a, b);
    tree[x] = tree[x << ] + tree[x <<  | ];
}
void update(int l, int r, int x, int pos, int v)
{
    if(l == r)
    {
        tree[x] = node(l, v);
        return;
    }
    pushdown(x);
    int mid = (l + r) >> ;
    if(pos <= mid) update(l, mid, x << , pos, v);
    else update(mid + , r, x <<  | , pos, v);
    tree[x] = tree[x << ] + tree[x <<  | ];
}
int main()
{
    read_in();
    fread(n);
    for(int i = ; i <= n; ++i) fread(a[i]);
    tree[].tag = -;
    build(, n, );
    fread(q);
    while(q--)
    {
        int opt, l, r, v;
        fread(opt);
        if(opt == )
        {
            fread(l);
            fread(v);
            update(, n, , l, v);
        }
        if(opt == )
        {
            fread(l);
            fread(r);
            fread(v);
            int sum = , top = ;
            while(v--)
            {
                node ans = query(, n, , l, r);
                if(ans.mx.v <= ) break;
                reverse(, n, , ans.mx.l, ans.mx.r);
                node tmp = query(, n, , ans.mx.l, ans.mx.r);
                st[++top] = ans;
                sum += ans.mx.v;
            }
            printf("%d\n", sum);
            for(int i = top; i; --i) reverse(, n, , st[i].mx.l, st[i].mx.r);
        }
    }
    return ;
}