【题解】 P7077 [CSP-S2020] 函数调用（dp，拓扑排序）

【题解】 P7077 [CSP-S2020] 函数调用

好题！

结合了 topsort 和线段树 \(lazy\) 标记的思想！

(所以这题跟 DP 有什么关系？)

题目链接

P7077 [CSP-S2020] 函数调用 - 洛谷

题意概述

给定一个长度为 \(n\) 的序列，有以下三种操作：

• 单点加；

• 全局乘；

• 以一定顺序调用其他操作，保证不直接或间接调用自身。

思路分析

首先刚开始我先打了个暴力。(雾)

得到了 45pts 的高分。

然后观察了一下数据范围发现：

• 数据点 \(7,10\) 没有操作 \(3\)；

• 数据点 \(5,6,12,13\) 没有操作 \(1\) 或操作 \(2\)；

往往当我们不会一道题的时候，数据范围总能成为突破口。——aqx

考虑一下如何处理这几个测试点。

首先考虑：对于操作 \(3\)，我们将所有输入该函数 \(i\) 都与其调用的函数 \(g_i\) 连一条有向边，那么可以知道，对于每一个函数属性为 \(T_i\) 的函数，相当于形成了一张 DAG。那么似乎就可以在这张 DAG 上进行 topsort 或是记忆化搜索。这一点在求解下面的问题时，极其重要。

• 当不含操作 \(1\)：

  只有全局乘这一个操作，很容易想到利用线段树懒标记的思想，维护一个 \(lazy\) 标记，表示全局乘了多少，最后直接输出 \(a_i \times lazy\) 即可；

• 当不含操作 \(2\)：

  发现可以在从 \(Q\) 个询问出发，每个询问构建一张 DAG，然后从起点跑一遍 topsort，递推出每个函数的调用次数 \(cnt_i\)，也就求出来了每个函数要调用多少次，然后最后对于每个操作 \(1\)，输出 \(a_{p_i}+add_i \times cnt_i\) 即可。(其中 \(p_i\) 是每次操作 \(1\) 要进行单点乘的下标，\(add_i\) 表示进行一次单点乘要加的值是多少。)

  在这里从每个起点跑一遍，事实上也可以建立一个虚点 \(0\)，然后将 \(0\) 与所有 \(Q\) 个询问的起点连一条有向边。整个题目的条件就变成了一张 DAG。直接以 \(0\) 为起点进行 topsort 即可。

• 当不含操作 \(3\)：

  可以类比线段树 2，我们先举个例子：假如要对一个元素执行以下操作：\(+1,\times 3,+2,\times 2\)。那么假如我们维护两个标记：加法标记 \(add\) 和乘法标记 \(mul\)。

  那么第一次操作 \(+1\)：\(add+1\)，\(mul\) 不变；

  第二次操作 \(\times 3\)：\(add \times 3\)，\(mul \times 3\)；

  第三次操作：\(add+2\)，\(mul\) 不变；

  第四次操作 \(\times 2\)：\(add \times 2\)，\(mul\) 不变。

  可以发现，每次乘操作，会使得 \(mul\) 和 \(add\) 乘上对应值，而每次加操作，只会使得 \(add\) 加上对应值，而不会使得 \(mul\) 发生任何变化。

  那么我们就有了一个较为清晰的思路：

  我们首先可以像线段树 2 一样规定“先乘后除”。

  可以对于每个点 \(i\) 维护一个 \(mul_i\)，一个 \(add_i\)，加法标记就是当前调用的加法属性的函数对应的每次要加的值，乘法标记记录的是当前已经乘上了多大的值。然后维护一个全局乘标记 \(lazy\)。这里可能有点抽象，先不急，往下看：

  那么对于每次加操作，对于 \(a_i\) 首先要乘上 \(lazy/mul_i\)，因为 \(mul_i\) 表示你当前已经乘上了多大的值，而 \(lazy\) 表示的是全局的乘法标记，所以你还需要乘上 \(lazy/mul_i\)。然后再加上加法标记 \(add_i\)。每次这样的操作之后，\(a_i\) 就会变成当前最新值。然后清空 \(mul_i\)。(注意 \(mul_i\) 要清空为 \(1\) 而不是 \(0\))

  对于每次乘操作，直接给全局乘标记乘上对应值即可。

  最后输出每个 \(a_i \times (lazy/mul_i)\) 即可。

那么解决了上述这几个特殊性质的问题之后，我们就会顺利拿到 60pts 的高分。

而同时，上述这些特殊性质，也为我们想出正解提供了极大的帮助。

结合上述的性质我们便可以很容易想出此题正解。

首先对于所有的函数属性为 \(3\) 的操作，将 \(i\) 与所有 \(g_i\) 连一条有向边。然后对于 \(Q\) 个操作构成的操作序列，将虚点 \(0\) 与所有的操作 \(i\) 连一条有向边。

然后对于 \(m\) 个操作，每个操作 \(i\) 记录一个加法标记 \(add_i\)，乘法标记 \(mul_i\) 以及调用次数 \(cnt_i\)。

接下来我们来看一张图：

若 \(4\) 的 \(mul\) 为 \(3\)，\(7\) 的 \(mul\) 为 \(1\)，\(8\) 的 \(mul\) 为 \(2\)，\(6\) 的 \(mul\) 为 \(3\)，那么 \(1\) 的 \(mul\) 就为 \(mul_4 \times mul_5\times mul_6=mul_4\times mul_7\times mul_8\times mul_6=3\times 1\times 2 \times 3=18\)。

我们发现，一个节点的 \(mul\) 值答案等于它各个子节点的 \(mul\) 的乘积。

那么我们可以用一个 topsort 求出 \(1-m\) 中所有数的 \(mul\)。

需要注意的是，这次的 topsort 的反向建图的。(因为是子节点更新父节点嘛。)

然后我们再看一张图：

(选自洛谷)

假如 \(1\) 的操作次数是 \(x\)，那么 \(+2\) 的操作次数应该增加 \(3x\)，\(+1\) 的操作应该增加 \(12x\)。

所以下传 \(cnt\) 时，假设一个点 \(x\) 的操作次数 \(cnt\)，它的儿子是 \(y_1​,y_2​,⋯y_k\)​， 那么 \(y_i\)​ 的 \(cnt\) 就应该增加 \(cnt\) 乘上 \(y_i+1​∼y_k\)​ 的 \(mul\) 之积。

那么只需要正向建图再跑一遍 topsort，求出每个节点的 \(cnt\)，注意枚举一个点的儿子时是倒序枚举。

那么最后只需要将 \(a_i\times mul_0\)，然后对应所有的操作 \(1\) 都让 \(a_{p_i}+add_i\times cnt_i\) 即可。

然后就结束了。

梳理一下整个求解思路：

对于所有的操作 \(3\)，将 \(i\) 个 \(g_i\) 分别正反向建图 \(\rightarrow\) 跑两遍 topsort 求出 \(mul\) 和 \(cnt\) \(\rightarrow\) 求出所有操作 \(1\) 后的 \(a_i\)。

易错点

• 对于所有操作属性为 \(2\) 的点初始化 \(mul\) 为输入的值，其它两种操作属性的点都初始化为 \(1\)。

• \(cnt_0\) 要初始化为 \(1\)；

• 第一次 topsort 要反向建图；

• 第二次 topsort 要倒序枚举每个子节点。

经验

• 一道难题一眼看不出正解时，不妨考虑打暴力，然后再优化暴力；

• 一定要多关注数据范围以及部分分和特殊性质，这些往往能成为你突破和解决问题的关键！

代码实现

//luoguP7077
//正解
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#define int long long 
using namespace std;
const int maxn=1e5+10;
const int mod=998244353;
int n,m;
int in1[maxn],in2[maxn];
int a[maxn],opt[maxn],p[maxn],v[maxn],add[maxn],mul[maxn],cnt[maxn];

basic_string<int>edge1[maxn],edge2[maxn];

inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-48;ch=getchar();}
    return x*f;
 } 

void topsort1()
{
    queue<int>q;
    for(int i=0;i<=m;i++)
    {
        if(in1[i]==0)q.push(i);
    }
    while(!q.empty())
    {
        int now=q.front();
        q.pop();
        for(int nxt:edge1[now])
        {
            (mul[nxt]*=mul[now])%=mod;
            in1[nxt]--;
            if(!in1[nxt])q.push(nxt);
        }
    }
    return ;
}

void topsort2()
{
    queue<int>q;
    for(int i=0;i<=m;i++)
    {
        if(!in2[i])q.push(i);
    }
    while(!q.empty())
    {
        int now=q.front();
        q.pop();
        int Mul=1;
        for(int i=edge2[now].size()-1;i>=0;i--)
        {
            int nxt=edge2[now][i];
            cnt[nxt]=(cnt[nxt]+cnt[now]*Mul%mod)%mod;
            (Mul*=mul[nxt])%=mod;
            in2[nxt]--;
            if(!in2[nxt])q.push(nxt);
        }
    }
    return ;
}

signed main()
{
    n=read();
    for(int i=1;i<=n;i++)a[i]=read();
    m=read();      
    mul[0]=1;                            
    for(int i=1;i<=m;i++)
    {
        opt[i]=read();
        if(opt[i]==1)
        {
            p[i]=read();add[i]=read();
            mul[i]=1;
        }
        else if(opt[i]==2) mul[i]=read();
        else
        {
            v[i]=read();mul[i]=1;
            for(int j=1;j<=v[i];j++)
            {
                int x=read();
                edge2[i]+=x;edge1[x]+=i;
                in2[x]++;in1[i]++;
            }
        }
    }
    int q=read();
    cnt[0]=1;
    for(int i=1;i<=q;i++)
    {
        int x=read();
        int tt=0; 
        edge2[0]+=x;
        edge1[x]+=tt;
        in2[x]++;in1[0]++;
    }
    topsort1();
    topsort2();
    for(int i=1;i<=n;i++)(a[i]*=mul[0])%=mod;
    for(int i=1;i<=m;i++)
    {
        if(opt[i]==1)(a[p[i]]=a[p[i]]+add[i]*cnt[i]%mod)%=mod;
    }
    for(int i=1;i<=n;i++)cout<<a[i]<<" ";
    cout<<'\n';
    return 0; 
}
/*3
1 2 3
3
1 1 1
2 2
3 2 1 2
2
2 3*/