HDU5316 Magician（线段树）

/**
题意：一个初始序列A， 长度为n， 有m个操作， 操作两种：
0 l r 求区间的一个子序列， 子序列需要满足其下标奇偶性交互，求其最大值
1 x y 将A[x] 赋值为 y

思路： 求区间最大值， 一般想到是线段树， 但是这个怎么维护呢？我们想到既然是求子序列， 那么我们应该也是维护线段树中
每个节点的下标奇偶性交互的序列最大值， 但是怎么合并呢？ 既然是奇偶性交互，那么可以维护区间中下标奇偶性交互的序列开
始是偶数， 结束是偶数的即标记为00序列最大值， 同理还有01, 10, 11， 那么合并的时候， 如果更新00的时候，
那么00的取值 = max(left_son(00) , right_son(00), left_son(01)+right_son(00) , left_son(01)+right_son(10)),同理其他的也
是这样更新
**/

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 1e5 + 10;
const ll INF = 1e18 + 10;
using namespace std;

struct P {
    ll x[4];
    void init() { for(int i = 0; i < 4; i++) x[i] = -INF; }
};
int n, m, T, kase = 1, ans;
int dp[55][55];
char s[55][55];
int col[55][55];
ll a[maxn];
ll C[maxn * 4][4];
void push_up(int o) {
    int o1 = o << 1, o2 = o << 1 | 1;
    for(int i = 0; i < 4; i++) {
        C[o][i] = max(C[o1][i], C[o2][i]);
        int t = i / 2, k = i & 1;
        for(int j = 0; j < 2; j++) {
            int L = t * 2 + j, R = (1 - j) * 2 + k;
            //printf("i = %d L = %d R = %d\n", i, L, R);
            C[o][i] = max(C[o][i], C[o1][L] + C[o2][R]);
        }
    }
}
void build(int o, int l, int r) {
    if(l == r) {
        int ix = l & 1;
        for(int i = 0; i < 4; i++) C[o][i] = -INF;
        C[o][ix * 2 + ix] = a[l];
        return ;
    }
    int mid = (l + r) >> 1;
    int o1 = o << 1, o2 = o << 1 | 1;
    build(o1, l, mid);
    build(o2, mid + 1, r);
    push_up(o);
    //cout << endl;
}



int op, ql, qr;
P query(int o, int l, int r) {
    P p; p.init();
    if(l > qr || r < ql) {
        return p;
    }
    if(l >= ql && r <= qr) {
        for(int i = 0; i < 4; i++) {
            p.x[i] = C[o][i];
        }
        return p;
    }
    int mid = (l + r) >> 1;
    int o1 = o << 1, o2 = o << 1 | 1;
    P p1 = query(o1, l, mid);
    P p2 = query(o2, mid + 1, r);
    for(int i = 0; i < 4; i++) {
        p.x[i] = max(p1.x[i], p2.x[i]);
        int t = i / 2, k = i & 1;
        for(int j = 0; j < 2; j++) {
            int L = t * 2 + j, R = (1 - j) * 2 + k;
            p.x[i] = max(p.x[i], p1.x[L] + p2.x[R]);
        }
    }
    return p;
}

void update(int o, int l, int r, int ind) {
    if(l == r) {
        int ix = l & 1;
        for(int i = 0; i < 4; i++) C[o][i] = -INF;
        C[o][ix * 2 + ix] = a[l];
        return ;
    }
    int mid = (l + r) >> 1;
    int o1 = o << 1, o2 = o << 1 | 1;
    if(ind <= mid) update(o1, l, mid, ind);
    else update(o2, mid + 1, r, ind);
    push_up(o);
}

int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d %d", &n, &m);
        for(int i = 1; i <= n; i++) {
            scanf("%lld", &a[i]);
        }
        build(1, 1, n);
        while(m--) {
            scanf("%d %d %d", &op, &ql, &qr);
            if(op == 1) {
                a[ql] = qr;
                update(1, 1, n, ql);
            } else {
                P p = query(1, 1, n);
                ll ans = -INF;
                for(int i = 0; i < 4; i++) ans = max(ans, p.x[i]);
                printf("%lld\n", ans);
            }
        }
    }
    return 0;
}