线段树进门

线段树区间更新

区间问题

我们把之前的区间问题进行一下修改，变成如下问题：

给定一个长度为 \(n\) 的数组 \(a\)，有两种操作：

1. 查询 \([x,y]\) 区间内的最小值
2. 把区间 \([x,y]\) 中的所有数增加 \(v\)

延迟标记

我们考虑利用区间查询的思想，对于更新的区间 \([x,y]\)，我们可以划分为线段树上的结点，这些结点的区间合并起来就是区间 \([x,y]\)。例如对于区间 \([3,9]\) 区间分割如下：

我们利用一种特殊的技术手段来解决——延迟标记。

延迟标记也称为懒惰标记。对于红点而言，我们暂时标记整个区间都要加上 \(v\)，但却不真的进行更新。

也就是说，我们能保证所有绿点和红点的信息完全正确，但是不能保证灰点的信息正确。

向下传递标记

灰色结点的信息虽然不正确，但是不要紧，因为我们现在也用不到这些结点。等需要用的时候，再去更新即可。

延迟标记的思想就是，某个结点需要用到的时候再去维护其正确性。向上更新（pushup）是利用子结点的信息更新父节点，我们需要保证子结点信息的正确性，而向下更新（pushdown）是利用父节点的信息去更新子结点的信息，所以需要保证父节点的信息信息的正确性。

这样和区间查询一样，一次区间更新时间复杂度也是 \(\mathcal{O}(\log n)\)。

示例代码

void pushup(int id) {
    minv[id] = min(minv[id << 1], minv[id << 1 | 1]);
}
void pushdown(int id) {
    if (lazy[id]) {
        lazy[id << 1] += lazy[id];
        lazy[id << 1 | 1] += lazy[id];
        minv[id << 1] += lazy[id];
        minv[id << 1 | 1] += lazy[id];
        lazy[id] = 0;
    }
}
void update(int id, int l, int r, int x, int y, int v) {
    if (x <= l && r <= y) {
        lazy[id] += v;
        minv[id] += v;
        return;
    }
    pushdown(id);
    int mid = (l + r) >> 1;
    if (x <= mid) {
        update(id << 1, l, mid, x, y, v);
    }
    if (y > mid) {
        update(id << 1 | 1, mid + 1, r, x, y, v);
    }
    pushup(id);
    return;
}

代码实现

#include <iostream>
using namespace std;
const int maxn = 110;
int a[maxn];
int minv[4 * maxn], lazy[4 * maxn];
void pushup(int id) {
    minv[id] = min(minv[id << 1], minv[id << 1 | 1]);
}
void pushdown(int id) {
    if (lazy[id]) {
        lazy[id << 1] += lazy[id];
        lazy[id << 1 | 1] += lazy[id];
        minv[id << 1] += lazy[id];
        minv[id << 1 | 1] += lazy[id];
        lazy[id] = 0;
    }
}
void build(int id, int l, int r) {
    if (l == r) {
        minv[id] = a[l];
        return;
    }
    int mid = (l + r) >> 1;
    build(id << 1, l, mid);
    build(id << 1 | 1, mid + 1, r);
    pushup(id);
}
void update(int id, int l, int r, int x, int y, int v) {
    if (x <= l && r <= y) {
        lazy[id] += v;
        minv[id] += v;
        return;
    }
    pushdown(id);
    int mid = (l + r) >> 1;
    if (x <= mid) {
        update(id << 1, l, mid, x, y, v);
    }
    if (y > mid) {
        update(id << 1 | 1, mid + 1, r, x, y, v);
    }
    pushup(id);
}
int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    build(1, 1, n);
    int q;
    cin >> q;
    while (q--) {
        int x, y, v;
        cin >> x >> y >> v;
        update(1, 1, n, x, y, v);
    }
    return 0;
}

区间查询

因为我们区间修改的时候使用到了懒惰标记，这样就会使得部分结点答案不正确。所以需要对之前查询函数进行微调。

int query(int id, int l, int r, int x, int y) {
    if (x <= l && r <= y) {
        return minv[id];
    }
    pushdown(id);
    int mid = (l + r) >> 1;
   	int ans = inf;
    if (x <= mid) {
        ans = min(ans, query(id << 1, l, mid, x, y));
    }
    if (y > mid) {
        ans = min(ans, query(id << 1 | 1, mid + 1, r, x, y));
    }
    return ans;
}

代码实现

#include <iostream>
using namespace std;
const int maxn = 110;
const int inf = 0x3f3f3f3f;
int a[maxn];
int minv[4 * maxn], lazy[4 * maxn];
void pushup(int id) {
    minv[id] = min(minv[id << 1], minv[id << 1 | 1]);
}
void pushdown(int id) {
    if (lazy[id]) {
        lazy[id << 1] += lazy[id];
        lazy[id << 1 | 1] += lazy[id];
        minv[id << 1] += lazy[id];
        minv[id << 1 | 1] += lazy[id];
        lazy[id] = 0;
    }
}
void build(int id, int l, int r) {
    if (l == r) {
        minv[id] = a[l];
        return;
    }
    int mid = (l + r) >> 1;
    build(id << 1, l, mid);
    build(id << 1 | 1, mid + 1, r);
    pushup(id);
}
void update(int id, int l, int r, int x, int y, int v) {
    if (x <= l && r <= y) {
        lazy[id] += v;
        minv[id] += v;
        return;
    }
    pushdown(id);
    int mid = (l + r) >> 1;
    if (x <= mid) {
        update(id << 1, l, mid, x, y, v);
    }
    if (y > mid) {
        update(id << 1 | 1, mid + 1, r, x, y, v);
    }
    pushup(id);
}
int query(int id, int l, int r, int x, int y) {
    if (x <= l && r <= y) {
        return minv[id];
    }
    pushdown(id);
    int mid = (l + r) >> 1;
    int ans = inf;
    if (x <= mid) {
        ans = min(ans, query(id << 1, l, mid, x, y));
    }
    if (y > mid) {
        ans = min(ans, query(id << 1 | 1, mid + 1, r, x, y));
    }
    return ans;
}
int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    build(1, 1, n);
    int q;
    cin >> q;
    while (q--) {
        int x, y, v;
        cin >> x >> y >> v;
        update(1, 1, n, x, y, v);
    }
    cin >> q;
    while (q--) {
        int x, y;
        cin >> x >> y;
        cout << query(1, 1, n, x, y) << endl;
    }
    return 0;
}