【动态规划 + 线段树】P5280 [ZJOI2019] 线段树_线段树维护矩阵转移动态规划-优快云博客

本文链接：https://blog.youkuaiyun.com/o_Invincible_o/article/details/130255583

文章介绍了ZJOI2019竞赛中关于线段树的一道题目，涉及线段树的懒标记概念和操作。题目要求处理一系列区间修改和查询操作，通过动态规划和前缀和的思想，分析不同节点在每次操作后的标记状态，以计算所有线段树的权值和。文章给出了问题的解题思路，包括状态转移方程和代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

[ZJOI2019]线段树

题目描述

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

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

其中函数 $Lson⁡(Node)\operatorname{Lson}(Node)$ 表示 $N o d e$ 的左儿子， $Rson⁡(Node)\operatorname{Rson}(Node)$ 表示 $N o d e$ 的右儿子。

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

$r1\ l\ r$ ，假设可怜当前手上有 $t$ 棵线段树，可怜会把每棵线段树复制两份（ $t a g$ 数组也一起复制），原先编号为 $i$ 的线段树复制得到的两棵编号为 $2 i - 1$ 与 $2 i$ ，在复制结束后，可怜手上一共有 $2 t$ 棵线段树。接着，可怜会对所有编号为奇数的线段树进行一次 $Modify⁡(root,1,n,l,r)\operatorname{Modify}(root,1,n,l,r)$ 。
$2$ ，可怜定义一棵线段树的权值为它上面有多少个节点 $t a g$ 为 $1$ 。可怜想要知道她手上所有线段树的权值和是多少。

输入格式

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

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

输出格式

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

样例 #1

样例输入 #1

样例输出 #1

0
1
6

提示

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

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

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

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

因此答案为 $1$ 。

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

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

因此答案为 $6$ 。

Solution

STEP 1 - 题意转换

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

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

STEP 2 - 分析性质

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

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

在这里插入图片描述

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

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

STEP 3 - 动态规划

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

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

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

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

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

一类点：

复制后修改时一半的标记消失，因此 $fi,u=12fi−1,uf_{i,u}=\dfrac{1}{2}f_{i-1,u}$ ，

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

二类点：

一半的点打上标记，故 $fi,u=12+12fi−1,uf_{i,u}=\dfrac{1}{2}+\dfrac{1}{2}f_{i-1,u}$ ，

但一半的线段树中 $1∼u1\sim u$ 路径上一定有标记，故 $gi,u=12gi−1,ug_{i,u}=\dfrac{1}{2}g_{i-1,u}$

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

三类点：

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

故 $fi,u=12−12gi−1,u+12fi−1,uf_{i,u}=\dfrac{1}{2}-\dfrac{1}{2}g_{i-1,u}+\dfrac{1}{2}f_{i-1,u}$

此时 $g$ 无变化

四类点：

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

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

故 $gi,u=12gi−1,ug_{i,u}=\dfrac{1}{2}g_{i-1,u}$ 。

五类点：

$f, g$ 均无变化。

STEP 4 - 快速维护

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

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

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

对于答案的统计，记录 $sf_{i,u}=f_{i,u}+sf_{i,ls_u}+sf_{i,rs_u}$ 即可，

最后输出 $sf_{i,1} * 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.