洛谷传送门：月下“毛景树”
由于没有合适的题目，就从这道题入手，解此题时用到的算法/数据结构包括：
- 树链剖分
- 线段树（区间覆盖、区间加、区间查询、单点修改）
这道题被我调试了四个小时才过，而且此题的测试点设置得极不友好，提交记录非0即100，每个点的数据范围都很大，几乎没有供调试的价值，所以推荐那些下载数据调试的朋友们，自己捏几组数据调试，没问题以后再和下载的数据对拍，可以说是能够对一个点就能全部AC了。
这篇博客不谈题解，只来说说线段树上的lazy标记如何下放
接下来进入正题
线段树的lazy标记
众所周知，线段树的单点修改、单点查询理论复杂度是O(logn)的，那么如果修改/查询m次，那么理论复杂度就达到O(mlogn)，这样的复杂度是可以被接受的；但是如果一次修改/查询一个区间，并且连续进行m次这样的操作，那么最坏情况下的复杂度就上升到了O(mnlogn)，这在1e5的数据范围下是很容易超时的，所以我们采取一种策略来降低复杂度——lazy标记。
lazy就是将线段树上的操作推迟进行，具体推迟到什么时候呢？什么时候再次需要用到这一个区间了就什么时候再操作，也就是说如果这段区间不再被需要使用，那么这次操作是否执行就是对后续要进行的工作没有影响的，那么我们也就没有必要做这个操作，可以将它推迟到永远也不执行，以此实现对时间复杂度的优化。
举个例子：
现在我有一棵线段树，原序列编号从1开始，我希望进行的操作是将区间 [5,8] 的权值加一，并查询区间 [5,6] 的最值，按照单点修改的方法，就要在线段树上二分查找，直到找到了线段树的叶子节点，然后修改叶子节点的点权，再回溯修改上面的节点。
但我们会发现，这样一来，对 [7,8] 的修改操作是否进行是对答案没有影响的，所以我们就可以选择将对 [7,8] 的修改操作推迟，只进行 [5,6] 的修改操作，具体如何执行呢？
- 在维护线段树上每个节点信息的同时对每个节点维护一个名为“lazy”的变量
- lazy代表当前节点有(过)区间修改的操作
- 如果要对当前区间进行修改，那么修改信息的同时修改lazy值
- 维护好lazy信息后不再继续向下遍历，回溯即可
- 如果再次遍历到该节点，则下放lazy标记
如图所示：
进行区间修改时首先找到线段树上的区间 [l,r]，满足 l >= 5 && r <= 8 ，然后对该区间打一个lazy标记并更新该区间信息，接着回溯，更新上面节点的信息。
这样第一步操作就结束了，接下来进行第二步操作，查询时依然用二分的方法找到一个区间 [l,r]，满足 l >= 5 && r <= 6，并返回该区间的信息，最后合并所有返回的信息（这里我们只返回了一个区间，不需要合并）。
但出现了一个问题，要查询的区间因为lazy标记而导致操作推迟，返回的并不是正确的信息，怎么办呢？好说，在返回之前把被推迟的操作做了就行了。具体来说，就是在遍历过程中把被遍历到的节点的lazy标记下放。
图中红色箭头表示遍历路径，凡是被遍历过并且lazy标记不为零的节点，都要对lazy标记进行下放，这样就能保证之前被推迟的操作在直接产生作用之前被执行。
区间覆盖与区间加的lazy下放
区间覆盖与区间加是两个完全不同的操作，自然就需要两个不同的lazy标记。这一部分我就拿例题中的线段树来举例好了。
struct node {
int l, r, v;
int lz = 0;
int cvr = -1;
};
node tr[maxn << 2];我们首先定义好线段树上的lazy标记和其他信息。其中 lz 表示区间加的 lazy，cvr 表示区间覆盖的 lazy。
int ask(int id, int tgtl, int tgtr);
int pls(int id, int tgtl, int tgtr, int k);
int cvr(int id, int tgtl, int tgtr, int k);此题中涉及了区间查询、区间加、区间覆盖，所以我们定义以上三个函数（单点修改可以认为是在区间 [l,r] 上的区间修改，其中 l == r），参数 id 表示线段树上当前节点的编号，tgtl 和 tgtr表示目标区间的左端点和右端点，k 表示操作参数。
在这三个函数中，每到达一个节点，就应该有如下语句：
int l = tr[id].l;
int r = tr[id].r;
if (tr[id].cvr != -1) {
if (l != r) cvrdown(id); //如果不是叶子结点才需要下放
tr[id].cvr = -1;
tr[id].lz = 0;
}
if (tr[id].lz) {
if (l != r) putdown(id); //同上，判断叶子结点
tr[id].lz = 0;
}其中 cvrdown(int id) 和 putdown(int id) 是另外定义的两个函数，用来执行两个lazy标记的下放操作，函数的定义如下：
inline void cvrdown(int id) {
tr[id << 1].v = tr[id].cvr;
tr[id << 1 | 1].v = tr[id].cvr;
tr[id << 1].cvr = tr[id].cvr;
tr[id << 1 | 1].cvr = tr[id].cvr;
return;
}
inline void putdown(int id) {
node ls = tr[id << 1];
node rs = tr[id << 1 | 1];
ls.v += tr[id].lz;
rs.v += tr[id].lz;
ls.lz += tr[id].lz;
rs.lz += tr[id].lz;
tr[id << 1] = ls;
tr[id << 1 | 1] = rs;
return;
}
值得注意的是，上面的代码是不正确的！如果覆盖操作在区间加操作之后，那么区间覆盖会掩盖之前的所有操作，所以cvr标记的下放可以将节点的cvr和lz都清空。但是！如果区间加操作在覆盖操作之后，那么区间加操作的结果是建立在区间覆盖的结果之上的，也就是在执行putdown函数时，要先检查儿子节点有没有 cvr 标记，如果有的话，先把 cvr 标记下放了，再下放 lz 标记，那么正确的代码如下：
inline void cvrdown(int id) {
tr[id << 1].v = tr[id].cvr;
tr[id << 1 | 1].v = tr[id].cvr;
tr[id << 1].cvr = tr[id].cvr;
tr[id << 1 | 1].cvr = tr[id].cvr;
return;
}
inline void putdown(int id) {
node ls = tr[id << 1];
node rs = tr[id << 1 | 1];
if (ls.cvr != -1) {
if (ls.l != ls.r) cvrdown(id << 1);
ls.cvr = -1;
ls.lz = 0;
}
if (rs.cvr != -1) {
if (rs.l != rs.r) cvrdown(id << 1 | 1);
rs.cvr = -1;
rs.lz = 0;
}
ls.v += tr[id].lz;
rs.v += tr[id].lz;
ls.lz += tr[id].lz;
rs.lz += tr[id].lz;
tr[id << 1] = ls;
tr[id << 1 | 1] = rs;
return;
}
这样一来lazy的下放就完成了！
由于本篇博客主要是分享线段树lazy标记的下放，树链剖分的部分我就不多讲了，例题的AC代码如下：
#include<bits/stdc++.h>
using namespace std;
//月下“毛景树”
const int maxn = (int)1e5 + 10;
struct alled {
int u, v, w;
};
struct edge {
int to, vl;
};
alled e[maxn];
vector<edge> ed[maxn];
int n, cnt;
int dfn[maxn], dep[maxn], fa[maxn];
int top[maxn], sz[maxn], vl[maxn];
int fstson[maxn], opdfn[maxn];
struct node {
int l, r, v;
int lz = 0;
int cvr = -1;
};
node tr[maxn << 2];
void dfs1(int x) {
sz[x] = 1;
for (int i = 0; i < ed[x].size(); i++) {
int y = ed[x][i].to;
if (y == fa[x]) continue;
fa[y] = x;
dep[y] = dep[x] + 1;
vl[y] = ed[x][i].vl;
dfs1(y);
sz[x] += sz[y];
if (sz[y] > sz[fstson[x]]) fstson[x] = y;
}
return;
}
void dfs2(int x, int t) {
opdfn[++cnt] = x;
dfn[x] = cnt;
top[x] = t;
if (fstson[x]) dfs2(fstson[x], t);
for (int i = 0; i < ed[x].size(); i++) {
int y = ed[x][i].to;
if (y == fa[x] || y == fstson[x]) continue;
dfs2(y, y);
}
return;
}
void build(int id, int l, int r) {
tr[id].l = l;
tr[id].r = r;
if (l == r) {
tr[id].v = vl[opdfn[l]];
return;
}
int mid = l + r >> 1;
build(id << 1 | 1, mid + 1, r);
build(id << 1, l, mid);
tr[id].v = max(tr[id << 1].v, tr[id << 1 | 1].v);
return;
}
inline void cvrdown(int id) {
tr[id << 1].v = tr[id].cvr;
tr[id << 1 | 1].v = tr[id].cvr;
tr[id << 1].cvr = tr[id].cvr;
tr[id << 1 | 1].cvr = tr[id].cvr;
return;
}
inline void putdown(int id) {
node ls = tr[id << 1];
node rs = tr[id << 1 | 1];
if (ls.cvr != -1) {
if (ls.l != ls.r) cvrdown(id << 1);
ls.cvr = -1;
ls.lz = 0;
}
if (rs.cvr != -1) {
if (rs.l != rs.r) cvrdown(id << 1 | 1);
rs.cvr = -1;
rs.lz = 0;
}
ls.v += tr[id].lz;
rs.v += tr[id].lz;
ls.lz += tr[id].lz;
rs.lz += tr[id].lz;
tr[id << 1] = ls;
tr[id << 1 | 1] = rs;
return;
}
void pls(int id, int tgtl, int tgtr, int k) {
int l = tr[id].l;
int r = tr[id].r;
if (tr[id].cvr != -1) {
if (l != r) cvrdown(id);
tr[id].cvr = -1;
tr[id].lz = 0;
}
if (tr[id].lz) {
if (l != r) putdown(id);
tr[id].lz = 0;
}
if (tgtl <= l && r <= tgtr) {
tr[id].v += k;
tr[id].lz += k;
return;
}
int mid = l + r >> 1;
if (mid < tgtl) pls(id << 1 | 1, tgtl, tgtr, k);
else if (mid >= tgtr) pls(id << 1, tgtl, tgtr, k);
else {
pls(id << 1 | 1, tgtl, tgtr, k);
pls(id << 1, tgtl, tgtr, k);
}
tr[id].v = max(tr[id << 1].v, tr[id << 1 | 1].v);
return;
}
void cvr(int id, int tgtl, int tgtr, int k) {
int l = tr[id].l;
int r = tr[id].r;
if (tr[id].cvr != -1) {
if (l != r) cvrdown(id);
tr[id].cvr = -1;
tr[id].lz = 0;
}
if (tr[id].lz) {
if (l != r) putdown(id);
tr[id].lz = 0;
}
if (tgtl <= l && r <= tgtr) {
tr[id].v = k;
tr[id].lz = 0;
tr[id].cvr = k;
return;
}
int mid = l + r >> 1;
if (mid < tgtl) cvr(id << 1 | 1, tgtl, tgtr, k);
else if (mid >= tgtr) cvr(id << 1, tgtl, tgtr, k);
else {
cvr(id << 1 | 1, tgtl, tgtr, k);
cvr(id << 1, tgtl, tgtr, k);
}
tr[id].v = max(tr[id << 1].v, tr[id << 1 | 1].v);
return;
}
int ask(int id, int tgtl, int tgtr) {
int l = tr[id].l;
int r = tr[id].r;
if (tr[id].cvr != -1) {
if (l != r) cvrdown(id);
tr[id].cvr = -1;
tr[id].lz = 0;
}
if (tr[id].lz) {
if (l != r) putdown(id);
tr[id].lz = 0;
}
if (tgtl <= l && r <= tgtr) return tr[id].v;
int mid = l + r >> 1;
if (mid < tgtl) return ask(id << 1 | 1, tgtl, tgtr);
else if (mid >= tgtr) return ask(id << 1, tgtl, tgtr);
else return max(ask(id << 1 | 1, tgtl, tgtr), ask(id << 1, tgtl, tgtr));
}
inline void prepls(int x, int y, int k) {
while (top[x] != top[y]) {
if (dep[top[x]] > dep[top[y]]) {
pls(1, dfn[top[x]], dfn[x], k);
x = fa[top[x]];
} else {
pls(1, dfn[top[y]], dfn[y], k);
y = fa[top[y]];
}
}
if (x != y) dep[x] > dep[y] ? pls(1, dfn[y] + 1, dfn[x], k) : pls(1, dfn[x] + 1, dfn[y], k);
return;
}
inline void precvr(int x, int y, int k) {
while (top[x] != top[y]) {
if (dep[top[x]] > dep[top[y]]) {
cvr(1, dfn[top[x]], dfn[x], k);
x = fa[top[x]];
} else {
cvr(1, dfn[top[y]], dfn[y], k);
y = fa[top[y]];
}
}
if (x != y) dep[x] > dep[y] ? cvr(1, dfn[y] + 1, dfn[x], k) : cvr(1, dfn[x] + 1, dfn[y], k);
return;
}
inline int preask(int x, int y) {
int ans = 0;
while (top[x] != top[y]) {
if (dep[top[x]] > dep[top[y]]) {
ans = max(ans, ask(1, dfn[top[x]], dfn[x]));
x = fa[top[x]];
} else {
ans = max(ans, ask(1, dfn[top[y]], dfn[y]));
y = fa[top[y]];
}
}
if (x != y) ans = max(ans, dep[x] > dep[y] ? ask(1, dfn[y] + 1, dfn[x]) : ask(1, dfn[x] + 1, dfn[y]));
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d %d", &e[i].u, &e[i].v, &e[i].w);
edge zhx; zhx.vl = e[i].w;
zhx.to = e[i].v; ed[e[i].u].push_back(zhx);
zhx.to = e[i].u; ed[e[i].v].push_back(zhx);
}
dfs1(1);
dfs2(1, 1);
build(1, 1, n);
register char s[10];
register int u, v, w;
while (true) {
cin >> s;
if (strlen(s) == 4) break;
else if (strlen(s) == 5) {
scanf("%d %d %d", &u, &v, &w);
precvr(u, v, w);
}
else if (strlen(s) == 6) {
scanf("%d %d", &u, &w);
if (dep[e[u].u] < dep[e[u].v]) cvr(1, dfn[e[u].v], dfn[e[u].v], w);
else cvr(1, dfn[e[u].u], dfn[e[u].u], w);
}
else if (s[0] == 'A') {
scanf("%d %d %d", &u, &v, &w);
prepls(u, v, w);
}
else {
scanf("%d %d", &u, &v);
printf("%d\n", preask(u, v));
}
}
return 0;
}
466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
