【动态规划 + 线段树】P5280 [ZJOI2019] 线段树

[ZJOI2019]线段树

题目描述

九条可怜是一个喜欢数据结构的女孩子，在常见的数据结构中，可怜最喜欢的就是线段树。

线段树的核心是懒标记，下面是一个带懒标记的线段树的伪代码，其中 $tag$ 数组为懒标记：

其中函数 $\mathrm{Lson}(Node)$ 表示 $Node$ 的左儿子，$\mathrm{Rson}(Node)$ 表示 $Node$ 的右儿子。

现在可怜手上有一棵 $[1,n]$ 上的线段树，编号为 $1$。这棵线段树上的所有节点的 $tag$ 均为$0$。接下来可怜进行了 $m$ 次操作，操作有两种：

• $1lr$，假设可怜当前手上有 $t$ 棵线段树，可怜会把每棵线段树复制两份（$tag$ 数组也一起复制），原先编号为 $i$ 的线段树复制得到的两棵编号为 $2i-1$ 与 $2i$，在复制结束后，可怜手上一共有 $2t$ 棵线段树。接着，可怜会对所有编号为奇数的线段树进行一次 $\mathrm{Modify}(root,1,n,l,r)$。

• $2$，可怜定义一棵线段树的权值为它上面有多少个节点 $tag$ 为 $1$。可怜想要知道她手上所有线段树的权值和是多少。

输入格式

第一行输入两个整数 $n,m$ 表示初始区间长度和操作个数。

接下来 $m$ 行每行描述一个操作，输入保证 $1\le l\le r\le n$。

输出格式

对于每次询问，输出一行一个整数表示答案，答案可能很大，对 $998244353$ 取模后输出即可。

样例 #1

样例输入 #1

5 5
2
1 1 3
2
1 3 5
2

样例输出 #1

0
1
6

提示

[1,5] 上的线段树如下图所示：

在第一次询问时，可怜手上有一棵线段树，它所有点上都没有标记，因此答案为 $0$。

在第二次询问时，可怜手上有两棵线段树，按照编号，它们的标记情况为：

1. 点 $[1,3]$ 上有标记，权值为 $1$。
2. 没有点有标记，权值为 $0$。

因此答案为 $1$。

在第三次询问时，可怜手上有四棵线段树，按照编号，它们的标记情况为：

1. 点 $[1,2],[3,3],[4,5]$ 上有标记，权值为 $3$。
2. 点 $[1,3]$ 上有标记，权值为 $1$。
3. 点 $[3,3],[4,5]$ 上有标记，权值为 $2$。
4. 没有点有标记，权值为 $0$。

因此答案为 $6$。

---

Solution

STEP 1 - 题意转换

题目中有一个复制操作，可以发现其实相当于将原来的所有线段树进行备份，再进行操作。

相当于是一个前缀和。这说明答案可以通过递推得到。

STEP 2 - 分析性质

由上面的题意转换，我们可以考虑每一次操作的贡献。

观察在线段树上的操作，所有的节点可以分成如下 $5$ 类：

• 一类点（白色）： 这类点被修改区间半覆盖 ，在 $\mathrm{pushdown}$ 时标记下传消失
• 二类点（黑色）： 被修改区间全覆盖，并且可以遍历到 ，得到标记
• 三类点（橙色）： 无法遍历到， 但可以得到 $\mathrm{pushdown}$ 来的标记
• 四类点（灰色）： 被修改区间全覆盖，但无法遍历到
• 五类点（橙色）： 无法遍历到，且无法得到标记

设 $f_{i,u}$ 表示共有多少棵线段树的节点 $u$ 在第 $i$ 次修改时有标记，就可以利用这个性质进行 $dp$ 。

STEP 3 - 动态规划

由于复制操作会带来许多冗余的统计，所以我们可以稍微改变一下状态：

$f_{i,u}$ 表示节点 $u$ 在第 $i$ 次修改时有标记的线段树的占比，也就是概率 。

最后将总数 $2^i$ 乘回来即可。

发现这个式子对于三类点不好转移，

再考虑 $g_{i,u}$ 表示 $1\sim u$ 经过的节点都没有标记的概率，那么：

一类点：

复制后修改时一半的标记消失，因此 $f_{i,u}=\frac{1}{2}{f}_{i-1,u}$ ，

但这时后一半的线段树中 $1\sim u$ 路径上都没有标记了，故 $g_{i,u}=\frac{1}{2}+\frac{1}{2}{g}_{i,u}$ 。

二类点：

一半的点打上标记，故 $f_{i,u}=\frac{1}{2}+\frac{1}{2}{f}_{i-1,u}$ ，

但一半的线段树中 $1\sim u$ 路径上一定有标记，故 $g_{i,u}=\frac{1}{2}{g}_{i-1,u}$

这相当于跟一类点的情况反过来

三类点：

只有 $1\sim u$ 路径上有标记的三类点才会对答案有贡献，

故 $f_{i,u}=\frac{1}{2}-\frac{1}{2}{g}_{i-1,u}+\frac{1}{2}{f}_{i-1,u}$

此时 $g$ 无变化

四类点：

标记的没变，因此 $f$ 无变化

而一半的线段树 $1\sim u$ 的路径上因为全覆盖，在这类点的祖先节点一定有至少一个点有标记，

故 $g_{i,u}=\frac{1}{2}{g}_{i-1,u}$ 。

五类点：

$f,g$ 均无变化。

STEP 4 - 快速维护

可以发现，对于 1，2，3 类点，最多 $O(\log n)$ 个，

五类点不操作，四类点有 $O(n)$ 个，

而对于四类点，只有 $g$ 每次变化，乘 1/2 ，可以用懒标记快速维护。

对于答案的统计，记录 $s{f}_{i,u}=f_{i,u}+s{f}_{i,l{s}_u}+s{f}_{i,r{s}_u}$ 即可，

最后输出 $s{f}_{i,1}\ast 2^i$ 即可。

---

Code

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define int long long
using namespace std;

const int N = 1e5 + 10, MOD = 998244353, GRY = 499122177;

inline void read(int &x)
{
    int sgn = 1; x = 0;
    char ch = getchar();
    while(ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
    if(ch == '-') sgn = -1, ch = getchar();
    while(ch >= '0' && ch <= '9') x = (x << 1) + (x << 3), x += (ch ^ '0'), ch = getchar();
    x *= sgn;
}

int n, m;

struct SegmentTree
{
    int l, r, sf, f, g, tag;
}t[N << 3];

void pushup(int p)
{
    t[p].sf = (t[p].f + (t[p << 1].sf + t[p << 1 | 1].sf) % MOD) % MOD;
}

void build(int p, int l, int r)
{
    t[p].l = l; t[p].r = r;
    t[p].tag = t[p].g = 1;
    if(l == r) return;
    int mid = l + r >> 1;
    build(p << 1, l, mid);
    build(p << 1 | 1, mid + 1, r);
} 

void spread(int p)
{
    if(t[p].tag != 1)
    {
        t[p << 1].g = t[p].tag * t[p << 1].g % MOD;
        t[p << 1 | 1].g = t[p].tag * t[p << 1 | 1].g % MOD;
        t[p << 1].tag = t[p].tag * t[p << 1].tag % MOD;
        t[p << 1 | 1].tag = t[p].tag * t[p << 1 | 1].tag % MOD;
        t[p].tag = 1; 
    }
}

void update(int p)
{
    t[p].f = GRY * ((1 - t[p].g + t[p].f) % MOD) % MOD;
    t[p].f += MOD; t[p].f %= MOD; pushup(p);
}

void change(int p, int l, int r)
{
    if(l <= t[p].l && t[p].r <= r)
    {
        t[p].f = GRY * (t[p].f + 1) % MOD;
        t[p].g = GRY * t[p].g % MOD;
        t[p].tag = GRY * t[p].tag % MOD;
        pushup(p);
        return;
    }
    int mid = t[p].l + t[p].r >> 1; spread(p);
    t[p].f = GRY * t[p].f % MOD; t[p].g = GRY * (1 + t[p].g) % MOD;
    if(r <= mid) change(p << 1, l, r), update(p << 1 | 1);
    else if(l > mid) change(p << 1 | 1, l, r), update(p << 1);
    else change(p << 1, l, r), change(p << 1 | 1, l, r); 
    pushup(p);
}

signed main()
{
    read(n); read(m);
    int sum = 1; build(1, 1, n);
    for(int i = 1; i <= m; i ++ )
    {
        int op, l, r; read(op);
        if(op == 1) read(l), read(r), change(1, l, r), sum <<= 1ll, sum %= MOD;
        else printf("%lld\n", sum * t[1].sf % MOD);
    }
    return 0;
}

---

END.