Codeforces 1136E(转化+线段树维护)

题目传送

虽然线段树比较显然但是发现a数组并不好维护。考虑将a转化为好维护的数组b。

方法

这里我将k[1]设为0,对应着$$a[1] + k[1] <= a[2]$$不难得出$$a[i] + k[i] <= a[i+1]$$

\[a[i]+k[i]+k[i+1] <=a[i+2] \]

所以设$$a[i] = b[i] + t[i],其中t[i]为k[i]的前缀和$$
以样例来说话:

pos 1 2 3
a 1 2 3
k 0 1 -1
t 0 1 0
b 1 1 3

可以发现b数组是一个不下降的序列,原因是b是以a[1]为基石的,无论t数组是正是负,只会影响a数组的升降。这样我们就可以选择用线段树维护b,对于'+'操作,相当于修改线段树上的b数组:

1.在b[i]的位置加上x:
ll k = T.Query(i, i, 1) + x;

2.找到小于“修改后的b[i]”的第一个位置,因为只要保持b不下降就可以了,大于等于这个b[i]的位置不修改:
int pos = T.Position(i, n, 1, k);

3.区间修改:
T.Modify(i, pos, 1, k);

对于询问操作,就不难得出:$$\sum_{i = l}^ra[i] = \sum_{i = l}^r b[i]+t[i]$$
所以求t[i]时顺手求个t[i]的前缀和,这道题就完成了。

最后注意线段树的tag,要设成-inf,这题的数组值是正负皆可的,不能用是否为0来判断tag:

void Push_down(int p) {
        if (t[p].tag > -INF) {

最终代码:

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

typedef long long ll;
const int maxn = 1e5 + 5;
const ll INF = 1e18;
int n, q;
ll a[maxn], k[maxn], t[maxn], sum[maxn], b[maxn];

class SegmentTree {
public:
    #define ls(p)   p << 1
    #define rs(p)   p << 1 | 1
    struct Node {
        int l, r;
        ll minn, sum, tag = -INF;
    }t[maxn << 2];

    void Push_up(int p) {
        t[p].minn = min(t[ls(p)].minn, t[rs(p)].minn);
        t[p].sum = t[ls(p)].sum + t[rs(p)].sum;
    }

    void Push_down(int p) {
        if (t[p].tag > -INF) {
            t[ls(p)].minn = t[rs(p)].minn = t[ls(p)].tag = t[rs(p)].tag = t[p].tag;
            t[ls(p)].sum = t[p].tag * (t[ls(p)].r - t[ls(p)].l + 1);
            t[rs(p)].sum = t[p].tag * (t[rs(p)].r - t[rs(p)].l + 1);
            t[p].tag = -INF;
        }
    }

    void Build(int l, int r, int p) {
        t[p].l = l, t[p].r = r;
        if (l == r) {
            t[p].minn = t[p].sum = b[l];
            return;
        }
        int mid = (l + r) >> 1;
        Build(l, mid, ls(p));
        Build(mid + 1, r, rs(p));
        Push_up(p);
    }

    void Modify(int l, int r, int p, ll k) {
        if (l <= t[p].l && t[p].r <= r) {
            t[p].minn = t[p].tag = k;
            t[p].sum = k * (t[p].r - t[p].l + 1);
            return;
        }
        int mid = (t[p].l + t[p].r) >> 1;
        Push_down(p);
        if (l <= mid)   Modify(l, r, ls(p), k);
        if (mid < r)    Modify(l, r, rs(p), k);
        Push_up(p);
    }

    int Position(int l, int r, int p, ll k) {
        if (t[p].minn < k && t[p].l == t[p].r)  return t[p].l;
        int mid = (t[p].l + t[p].r) >> 1;
        Push_down(p);
        if (t[rs(p)].minn < k)  return Position(l, r, rs(p), k);
        else    return  Position(l, r, ls(p), k);
    }

    ll Query(int l, int r, int p) {
        if (l <= t[p].l && t[p].r <= r) return t[p].sum;
        int mid = (t[p].l + t[p].r) >> 1;
        Push_down(p);
        if (l > mid)    return Query(l, r, rs(p));
        if (r <= mid)   return Query(l, r, ls(p));
        return Query(l, r, ls(p)) + Query(l, r, rs(p));
    }
}T;

int main(int argc, char const *argv[]) {
    ios_base::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    for (int i = 2; i <= n; i++)
        cin >> k[i], t[i] = t[i - 1] + k[i], sum[i] = sum[i - 1] + t[i];
    for (int i = 1; i <= n; i++)
        b[i] = a[i] - t[i];

    T.Build(1, n, 1);

    for (cin >> q; q; q--) {
        string op;
        cin >> op;
        if (op == "+") {
            int i, x;
            cin >> i >> x;
            ll k = T.Query(i, i, 1) + x;
            int pos = T.Position(i, n, 1, k);
            T.Modify(i, pos, 1, k);
        } else {
            int l, r;
            cin >> l >> r;
            cout << T.Query(l, r, 1) + sum[r] - sum[l - 1] << endl;
        }
    }

    return 0;
}
posted @ 2019-04-07 10:50  AlphaWA  阅读(171)  评论(0编辑  收藏  举报