【2021-ICPC-华为挑战赛】ProD Interval

背景

华为挑战赛第二场ICPC赛制训练赛的D题。

比赛的时候没做出来，但是有一个接近正解的方向了。

下来学习了一下，发现这道题拓宽了我在数据结构题方面的思路，有必要总结一下。

---

题目描述

给定一维数轴上的 $n$ 条线段，每条线段形如 $[l_u,r_u]$ ，线段长度是 $r_u-l_u$ 。

$n$ 条线段分别用 $I_1,I_2...I_n$ 表示。

定义函数 $f(L,R)$ ，表示下标在 $[L,R]$ 的所有线段（也就是线段 $I_L,I_{L+1}...I_{R-1},I_R$ ）覆盖的总长度（重叠部分的长度只计算一次）。

接下来有 $m$ 组询问，每次一个区间 $[A,B]$ ，询问 $[A,B]$ 的所有子区间 $[L,R]$ 的 $f(L,R)$ 值之和除以 $[A,B]$ 子区间个数的结果，答案对 $998244353$ 取模，也就是求 $\frac{{\sum }_{A\le L\le R\le B}f(L,R)}{\frac{(A-B+1)(A-B+2)}{2}}\mathrm{m}\mathrm{o}\mathrm{d}998244353$ 。

允许离线，这恰恰是解题的关键之一。

---

题目分析与做法：

这种询问里面区间套子区间的情况对我来说还是比较陌生的，但我印象里之前打ECfinal的时候也有一道类似的题，因此不得不重视起来。

对于这样的问题，一般情况下，我们可以考虑两种方向：

• 线段树方向：能够把一个不断变化的序列多次完整的加在一个累加序列上的线段树。
• 树状数组方向：能够把查询转化为基于某个数列的高维求和，然后用树状数组维护。

入手：

如何解决一个区间的 $f(L,R)$ 值？解决了这个问题，再去谈如何解决一个区间所有子区间的答案之和。

我们考虑这样一个过程：从第 $1$ 个到第 $n$ 个，逐个逐个的把线段 $I_u$ 涂在数轴上，每次涂的时候新涂的线段会覆盖之前已经涂过的线段。在这个过程中，我们动态维护每条线段暴露在最表层的总长度，具体的，当前第 $i$ 条线段暴露在最表层的总长度用 $c_i$ 表示。那么，区间 $[L,R]$ 的 $f(L,R)$ 值就是在线段 $I_R$ 刚刚涂上之后， ${\sum }_{i=L}^R{c}_i$ 的值。

那这个 $c_i$ 怎么维护呢？其实就是每次涂上一条线段的时候需要找到每段其他的线段被这个线段覆盖的长度，这个可以用势能分析线段树解决，在区间赋值的时候递归直到节点是一个完整颜色区间，做处理就可以了，复杂度 $O(n\log n)$ （tag的处理可自行分析一下）。

当然，为了方便对 $c_i$ 做求和值，还需要用另外的数据结构对它做维护，因此修改 $c_i$ 需要看作 $O(\log n)$ 的，这样实际上总的处理是 $O(n{\log }^{2}n)$ 的。

至此，一个区间的 $f(L,R)$ 值已经解决了。

接下来分别介绍两种做法。

线段树：

考虑一下，如何在 $R$ 已经确定的情况下求解 ${\sum }_{i=L}^{R}f(i,R)$ ：

我们观察在这个值中，每个 $c_i$ 对答案贡献了 $(i-L+1)$ 次，因此这个值也等于 ${\sum }_{i=L}^R{c}_i(i-L+1)$ ，如果我们用两个数据结构维护分别维护 $i\times c_i$ 和 $c_i$ 的区间求和，以及单点修改，我们就能够在 $O(\log n)$ 的时间复杂度查询出 ${\sum }_{i=L}^R{c}_i$ 和 ${\sum }_{i=L}^{R}i\times c_i$ ，然后把前者乘上常数 $(1-L)$ 再求和就求出来这个值了。

接下来考虑求 $[L,R]$ 内所有子区间的值，也就是 ${\sum }_{i=L}^R{\sum }_{j=i}^{R}f(i,j)$：

这个查询也可以看作对一系列右端点确定的询问的求和，可以写作：
$$\sum _{j=L}^R\sum _{i=L}^{j}f(i,j)$$
结合我们上面的转化，这个值也就可以写作：
$$\sum _{j=L}^R\sum _{i=L}^j{c}_{ji}(i-L+1)$$
这里为什么用 $c_{ji}$ 表示呢？因为每当我们处理完一个新的右端点，$c_i$ 序列会发生变化，所以用 $c_{ji}$ 表示第 $j$ 个线段刚刚加入后的 $c_i$ 序列。值的注意的一点，每次 $c_i$ 序列经过了大概 $O(\log n)$ 次的单点修改得到了下一个版本的 $c_i$ 序列。我们为了能够在当前 $R$ 版本下求出之前每个版本的求和信息的和，我们可以维护一个能够实现序列累加的线段树。

也就是说，维护 $c_i$ 的线段树需要维护两个域：第一个是 $c_i$ 域，随着 $R$ 的增长，每次会进行单点修改生成新的 $c_i$ 序列。第二个是 ${\sum }_{j=1}^R{c}_{ji}$ 域，线段树的第 $i$ 个位置存的是当前所有版本的 $c_i$ 的累加。每次为了维护这个累加域，都需要执行一次区间操作，把第一个域当前的序列对应加一次在第二个域上。这个可以用 lazytag 的方式， $O(\log n)$实现。

这样我们在第二个域上进行区间求和，就可以 $O(\log n)$ 查出 ${\sum }_{i=L}^R{\sum }_{j=1}^R{c}_{ji}$ 的值，注意一点，因为对于任意的 $j<i,c_{ji}=0$ ，所以 ${\sum }_{i=L}^R{\sum }_{j=1}^R{c}_{ji}={\sum }_{i=L}^R{\sum }_{j=i}^R{c}_{ji}$。

同理，第二棵线段树也维护两个域，就能让我们 $O(\log n)$ 查出 ${\sum }_{i=L}^R{\sum }_{j=1}^{R}i\times c_{ji}$ 的值。

查出这两个值，在乘上系数，加一下，就是我们要求的查询值了。

也就是:
$$\begin{gathered} (1-L)(\sum _{i=L}^R\sum _{j=i}^R{c}_{ji})+(\sum _{i=L}^R\sum _{j=i}^{R}i\times c_{ji})=\sum _{i=L}^R\sum _{j=i}^R{c}_{ji}(i-L+1) \\ =\sum _{j=L}^R\sum _{i=L}^j{c}_{ji}(i-L+1) \end{gathered}$$
所以这道题解决完毕。

因为有下面的树状数组做法，所以我没有写上述做法的代码，但是据说 riteme 比赛的时候是这么写就过了的。

树状数组：

树状数组高维求和：

有一个著名的双树状数组解决区间求和区间查询问题的例子：

相信大家都比较熟悉：维护一个数据结构支持对序列 $a_i$ 进行区间加上同一个值，并且支持查询区间和。

考虑差分数组$b_i=a_i-a_{i-1}$，我们看一下一次区间求和用数组 $b_i$ 表示是什么样子的：
$$\begin{gathered} \because a_i=\sum _{j=1}^i{b}_j \\ \sum _{i=L}^R{a}_i=\sum _{i=L}^R\sum _{j=1}^i{b}_j=(R-L+1)\sum _{j=1}^{L-1}{b}_j+\sum _{j=L}^R{b}_j(R-j+1) \\ =(R-L+1)(\sum _{j=1}^{L-1}{b}_j)+(R+1)(\sum _{j=L}^R{b}_j)-(\sum _{j=L}^{R}j\times b_j) \end{gathered}$$
这样我们把原来的区间求和问题转化成了差分序列的高维度求和问题，我们用两个树状数组，每次区间修改的时候分别单点维护 $b_i$ 序列和 $i\times b_i$ 序列，询问的时候直接区间求和查出来，再做一点运算就可以求出答案了。

那么这道题也可以采用这种思想。

在讨论上一种做法的时候，我们用到了 $c_{ji}$ 序列，其中 $c_{ji}$ 表示的是刚刚添加完毕第 $j$ 个线段的时候，此时第 $i$ 条线段暴露在表面的总长度。而我们知道，这个 $c_{ji}$ 是在 $c_{(j-1)i}$ 的基础上加上变化量得到的。

那我们不妨设 $d_{ji}=c_{ji}-c_{(j-1)i}$，然后考虑重写我们的查询答案。

同样我们可以知道 $j<i$ 时 $d_{ji}=0$，这有助于我们化简。

注意，我们的查询一定是刚刚处理到第 $R$ 条线段，然后给出一个 $L$ 常数，然后去查 ${\sum }_{i=L}^R{\sum }_{j=i}^{R}f(i,j)$ 的值。
$$\sum _{i=L}^R\sum _{j=i}^{R}f(i,j)=\sum _{j=L}^R\sum _{i=L}^j{c}_{ji}(i-L+1)=\sum _{j=L}^R\sum _{i=L}^j\sum _{k=1}^j{d}_{ki}(i-L+1)$$
先利用 $k<i$ 时 $d_{ki}=0$ 的条件改写一下得到：
$$\sum _{j=L}^R\sum _{i=L}^j\sum _{k=i}^j{d}_{ki}(i-L+1)$$
然后我们把 $j$ 换到最里面去：
$$=\sum _{i=L}^R\sum _{j=i}^R\sum _{k=i}^j{d}_{ki}(i-L+1)=\sum _{i=L}^R\sum _{k=i}^R\sum _{j=k}^R{d}_{ki}(i-L+1)$$
发现 $j$ 的求和直接就是一个常数了，于是可以写作：
$$\sum _{i=L}^R\sum _{k=i}^R{d}_{ki}(i-L+1)(R-k+1)$$
我们发现这里面常数是 $L,R$ 变量是 $i,k$ 于是根据变量的多项式分项得到：
$$\sum _{i=L}^R\sum _{k=i}^R(1-L)(R+1)d_{ki}+(R+1)i\cdot d_{ki}+(L-1)k\cdot d_{ki}-ik\cdot d_{ki}$$
再利用 $k<i$ 时 $d_{ki}=0$ 的条件改写一下得到：
$$\sum _{i=L}^R\sum _{k=1}^R(1-L)(R+1)d_{ki}+(R+1)i\cdot d_{ki}+(L-1)k\cdot d_{ki}-ik\cdot d_{ki}$$
现在 我们令
$$\begin{gathered} s_i=\sum _{k=1}^R{d}_{ki} \\ {t}_i=\sum _{k=1}^{R}k\cdot d_{ki} \\ {S}_i=i\cdot \sum _{k=1}^R{d}_{ki}=i\cdot s_i \\ {T}_i=i\cdot \sum _{k=1}^{R}k\cdot d_{ki}=i\cdot t_i \end{gathered}$$
那么所求答案值就可以写作：
$$\begin{gathered} (\sum _{i=L}^R(1-L)(R+1)s_i)+(\sum _{i=L}^R(R+1)S_i)+(\sum _{i=L}^R(L-1)t_i)-(\sum _{i=L}^R{T}_i) \\ =(1-L)(R+1)(\sum _{i=L}^R{s}_i)+(R+1)(\sum _{i=L}^R{S}_i)+(L-1)(\sum _{i=L}^R{t}_i)-(\sum _{i=L}^R{T}_i) \end{gathered}$$
也就是上面四个序列的区间求和再乘一乘常数在相加即可。

所以我们用四个树状数组维护上面四个序列。

但修改时怎么修改呢？我们可以看到每个序列的单个值都是一个从 $1$ 加到当前添加的第 $R$ 条线段的 $R$ 的求和。所以当 $R$ 增加时，我们对于四个序列所有个元素都要加上一个和 $d_{Ri}$ 有关的值。但是，我们已经分析过了，$d_{Ri}$ 其实就是第 $R$ 条线段添加时对第 $i$ 条线段暴露长度的影响值，纵观整个过程，$d_{ri},(1\le r\le n)$ 中不为 $0$ 的情形是不会超过 $O(n\log n)$ 个的，我们在最开始提到的势能分析线段树中，在修改某个完整节点的 tag 的时候，就可以维护与 $d_{Ri}$ 相关的值了。而且每次只会对一个 $i$ 进行修改，所以是单点修改。

因此用四个单点修改区间求和的树状数组就可以解决这道题了。

---

参考代码(树状数组做法)

#include <map>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define MAXN 200100
#define MOD 998244353
#define LL long long
using namespace std;

int n,m;
int stk[MAXN*2],cnt;
int b[MAXN*2];
map<int,int> h;
struct Itv{
    int pl,pr;
    int l,r;
    int id;
    int ans;
}a[MAXN],q[MAXN];
bool cmp(Itv x,Itv y )
{
    return x.r<y.r;
}
bool cmp_id(Itv x,Itv y)
{
    return x.id<y.id;
}
inline void Mod(int &x)
{
    if(x>=MOD)x-=MOD;
    if(x<=-MOD)x+=MOD;
}
int qpow(int x,int y)
{
    x%=MOD;
    int ret=1;
    while(y)
    {
        if(y&1)
            ret=1ll*ret*x%MOD;
        x=1ll*x*x%MOD;
        y>>=1;
    }
    return ret;
}

struct BIT{
    int q[MAXN];
    BIT(){memset(q,0,sizeof(q));}

    void add(int loc,int v)
    {
        for(int i=loc;i<MAXN;i+=i&-i)
        {
            q[i]+=v;
            Mod(q[i]);
        }
    }
    int sum(int x)
    {
        int ret=0;
        for(int i=x;i;i-=i&-i)
        {
            ret+=q[i];Mod(ret);
        }
        return ret;
    }
}s,t,isi,iti;

void Add(int loc,int v,int r)
{
    s.add(loc,v);
    t.add(loc,1ll*r*v%MOD);
    isi.add(loc,1ll*loc*v%MOD);
    iti.add(loc,1ll*r*v%MOD*loc%MOD);
}

int Sum(int l,int r)
{
    return ((1ll*(isi.sum(r)-isi.sum(l-1))*(r+1) - (iti.sum(r)-iti.sum(l-1)) + 1ll*(1-l)*(r+1)%MOD*(s.sum(r)-s.sum(l-1)) + 1ll*(l-1)*(t.sum(r)-t.sum(l-1)))%MOD+MOD)%MOD;
}

struct Segment_Tree_A{
    struct node{
        int l,r,tag;
        int sum;
        node ()
        {
            l=r=tag=0;
        }
    }tr[MAXN*2*4];
    int num;

    Segment_Tree_A(){num=1;}
    void pushup(int x)
    {
        tr[x].tag=(tr[tr[x].l].tag!=tr[tr[x].r].tag)?-1:tr[tr[x].l].tag;
    }
    void Build(int x,int L,int R)
    {
        tr[x].tag=0;
        if(L==R)
        {
            tr[x].tag=0;
            tr[x].sum=b[L];
            return;
        }
        int mid=(L+R)/2;
        tr[x].l=++num;
        Build(tr[x].l,L,mid);
        tr[x].r=++num;
        Build(tr[x].r,mid+1,R);
        pushup(x);
        tr[x].sum=tr[tr[x].l].sum+tr[tr[x].r].sum;
        Mod(tr[x].sum);
    }
    void pushdown(int x)
    {
        if(tr[x].tag!=-1)
        {
            tr[tr[x].l].tag=tr[tr[x].r].tag=tr[x].tag;
        }
    }

    void Modify(int x,int L,int R,int al,int ar,int v)
    {
        if(R<al||ar<L)return;
        if(al<=L&&R<=ar&&tr[x].tag!=-1)
        {
            if(tr[x].tag)Add(tr[x].tag,-tr[x].sum,v);
            tr[x].tag=v;
            return;
        }
        pushdown(x);
        int mid=(L+R)/2;
        Modify(tr[x].l,L,mid,al,ar,v);
        Modify(tr[x].r,mid+1,R,al,ar,v);
        pushup(x);
    }

}segA;

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d",&a[i].pl,&a[i].pr);
        stk[++cnt]=a[i].pl;
        stk[++cnt]=a[i].pr;
    }
    sort(stk+1,stk+cnt+1);
    int UPD=0;
    for(int i=1;i<=cnt;i++)
    {
        if(i==1 || stk[i]!=stk[i-1])
        {
            h[stk[i]]=++UPD;
            b[UPD-1]=stk[i]-stk[i-1];
        }
    }
    for(int i=1;i<=n;i++)
    {
        a[i].l=h[a[i].pl];
        a[i].r=h[a[i].pr]-1;
    }

    segA.Build(1,1,UPD);

    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&q[i].l,&q[i].r);
        q[i].id=i;
    }

    sort(q+1,q+m+1,cmp);
    //cerr<<"done"<<endl;

    for(int i=1,j=1;i<=n && j<=m;i++)
    {
        segA.Modify(1,1,UPD,a[i].l,a[i].r,i);
        //cerr<<"mdone"<<endl;
        Add(i,(a[i].pr-a[i].pl)%MOD,i);
        //cerr<<"adddone"<<endl;
        while(j<=m && q[j].r == i)
        {
            //cerr<<"done"<<endl;
            q[j].ans=Sum(q[j].l,q[j].r);
            j++;
        }
    }

    sort(q+1,q+m+1,cmp_id);

    for(int i=1;i<=m;i++)
    {
        printf("%d\n",(int)(q[i].ans*2ll*qpow(q[i].r-q[i].l+1,MOD-2)%MOD*qpow(q[i].r-q[i].l+2,MOD-2)%MOD));
    }
    
    return 0;
}

---

致谢：

感谢 riteme 大爷的指导。

这篇 @范艺杰 的博客 让我学会了这道题。