1756: Vijos1083 小白逛公园　

Time Limit: 10 Sec Memory Limit: 64 MB

Description

小新经常陪小白去公园玩，也就是所谓的遛狗啦…在小新家附近有一条“公园路”，路的一边从南到北依次排着n个公园，小白早就看花了眼，自己也不清楚该去哪些公园玩了。 　　一开始，小白就根据公园的风景给每个公园打了分-.-。小新为了省事，每次遛狗的时候都会事先规定一个范围，小白只可以选择第a个和第b个公园之间（包括a、b两个公园）选择连续的一些公园玩。小白当然希望选出的公园的分数总和尽量高咯。同时，由于一些公园的景观会有所改变，所以，小白的打分也可能会有一些变化。 　　那么，就请你来帮小白选择公园吧。

Input

第一行，两个整数N和M，分别表示表示公园的数量和操作（遛狗或者改变打分）总数。 接下来N行，每行一个整数，依次给出小白 开始时对公园的打分。 接下来M行，每行三个整数。第一个整数K，1或2。K=1表示，小新要带小白出去玩，接下来的两个整数a和b给出了选择公园的范围（1≤a,b≤N）；K=2表示，小白改变了对某个公园的打分，接下来的两个整数p和s，表示小白对第p个公园的打分变成了s（1≤p≤N）。 其中，1≤N≤500 000，1≤M≤100 000，所有打分都是绝对值不超过1000的整数。

Output

小白每出去玩一次，都对应输出一行，只包含一个整数，表示小白可以选出的公园得分和的最大值。

Sample Input

5 3
1 2 -3 4 5
1 2 3
2 2 -1
1 2 3

Sample Output

2
-1

我没有别的意思，就是看我隔壁的传结构体让我很不爽。。。。
表示我也没有想到标算那么强，就自己瞎yy了一个方法，顺手卡个常啥的就过了。。。
一点也不毒瘤，就是有点暴力。。。
我是真的讨厌数据结构。。。。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5, L = 0, R = 1, INF = 0x7fffffff;
struct lpl{
    int l, r, data, ans, lans, rans, son[2];
}node[maxn * 2];
int n, m, cnt, root, ini[maxn];

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;
}  

inline void putit()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; ++i) ini[i] = read();
}

inline void update(int t)
{
    node[t].ans = -INF;
    node[t].ans = max(node[t].ans, node[node[t].son[L]].ans); node[t].ans = max(node[t].ans, node[node[t].son[R]].ans);
    node[t].ans = max(node[t].ans, node[node[t].son[L]].rans + node[node[t].son[R]].lans);
    node[t].data = node[node[t].son[L]].data + node[node[t].son[R]].data;
    node[t].lans = max(node[node[t].son[L]].lans, node[node[t].son[L]].data + node[node[t].son[R]].lans);
    node[t].rans = max(node[node[t].son[R]].rans, node[node[t].son[R]].data + node[node[t].son[L]].rans);
}

void build(int &t, int l, int r)
{
    t = ++cnt;
    node[t].l = l, node[t].r = r;
    if(l == r){
        node[t].ans = node[t].data = node[t].lans = node[t].rans = ini[l];
        return;
    }
    int mid = (l + r) / 2;
    build(node[t].son[L], l, mid);
    build(node[t].son[R], mid + 1, r);
    update(t);
}

int query_data(int t, int ql, int qr, int l, int r)
{
    if(ql == l && qr == r) return node[t].data;
    int mid = (l + r) / 2;
    if(mid >= qr) return query_data(node[t].son[L], ql, qr, l, mid);
    if(mid < ql) return query_data(node[t].son[R], ql, qr, mid + 1, r);
    return query_data(node[t].son[L], ql, mid, l, mid) + query_data(node[t].son[R], mid + 1, qr, mid + 1, r);
}

int query_left(int t, int ql, int qr, int l, int r)
{
    int ret = -INF;
    if(ql == l && qr == r) return node[t].lans;
    int mid = (l + r) / 2;
    if(mid >= qr) return query_left(node[t].son[L], ql, qr, l, mid);
    if(mid < ql) return query_left(node[t].son[R], ql, qr, mid + 1, r);
    ret = max(ret, query_data(node[t].son[L], ql, mid, l, mid) + query_left(node[t].son[R], mid + 1, qr, mid + 1, r));
    ret = max(ret, query_left(node[t].son[L], ql, mid, l, mid));
    return ret;
}

int query_right(int t, int ql, int qr, int l, int r)
{
    int ret = -INF;
    if(ql == l && qr == r) return node[t].rans;
    int mid = (l + r) / 2;
    if(mid >= qr) return query_right(node[t].son[L], ql, qr, l, mid);
    if(mid < ql) return query_right(node[t].son[R], ql, qr, mid + 1, r);
    ret = max(ret, query_data(node[t].son[R], mid + 1, qr, mid + 1, r) + query_right(node[t].son[L], ql, mid, l, mid));
    ret = max(ret, query_right(node[t].son[R], mid + 1, qr, mid + 1, r));
    return ret;
}

int query(int t, int ql, int qr, int l, int r)
{
    int ret = -0x7fffffff;
    if(ql == l && qr == r) return node[t].ans;
    int mid = (l + r) / 2;
    if(mid >= qr) return query(node[t].son[L], ql, qr, l, mid);
    if(mid < ql) return query(node[t].son[R], ql, qr, mid + 1, r);
    ret = max(ret, query(node[t].son[L], ql, mid, l, mid));
    ret = max(ret, query(node[t].son[R], mid + 1, qr, mid + 1, r));
    ret = max(ret, query_right(node[t].son[L], ql, mid, l, mid) + query_left(node[t].son[R], mid + 1, qr, mid + 1, r));
    return ret;
}

void modify(int t, int pos, int val, int l, int r)
{
    if(l == r){
        node[t].ans = node[t].data = node[t].lans = node[t].rans = val;
        return;
    }
    int mid = (l + r) / 2;
    if(pos <= mid) modify(node[t].son[L], pos, val, l, mid);
    if(pos > mid) modify(node[t].son[R], pos, val, mid + 1, r);
    update(t);
}

inline void workk()
{
    int opt, a, b;
    while(m--){
        scanf("%d%d%d", &opt, &a, &b);
        if(opt == 1) {
            if(a > b) swap(a, b);
            printf("%d\n", query(root, a, b, 1, n));
        }
        if(opt == 2) modify(root, a, b, 1, n);
    }
}

int main()
{
    putit();
    build(root, 1, n);
    workk();
    return 0;
}

原文地址：https://www.cnblogs.com/LLppdd/p/9042982.html