3025: 函数调用（CSP-S 2020 T3）

题目描述

函数是各种编程语言中一项重要的概念，借助函数，我们总可以将复杂的任务分解成一个个相对简单的子任务，直到细化为十分简单的基础操作，从而使代码的组织更加严密、更加有条理。然而，过多的函数调用也会导致额外的开销，影响程序的运行效率。

某数据库应用程序提供了若干函数用以维护数据。已知这些函数的功能可分为三类：

1. 将数据中的指定元素加上一个值；
2. 将数据中的每一个元素乘以一个相同值；
3. 依次执行若干次函数调用，保证不会出现递归（即不会直接或间接地调用本身）。

在使用该数据库应用时，用户可一次性输入要调用的函数序列（一个函数可能被调用多次），在依次执行完序列中的函数后，系统中的数据被加以更新。某一天，小 A 在应用该数据库程序处理数据时遇到了困难：由于频繁而低效的函数调用，系统在执行操作时进入了无响应的状态，他只好强制结束了数据库程序。为了计算出正确数据，小 A 查阅了软件的文档，了解到每个函数的具体功能信息，现在他想请你根据这些信息帮他计算出更新后的数据应该是多少。

输入

第一行一个正整数 n�，表示数据的个数。
第二行 n� 个整数，第 i� 个整数表示下标为 i� 的数据的初始值为 ai��。
第三行一个正整数 m�，表示数据库应用程序提供的函数个数。函数从 1∼m1∼� 编号。
接下来 m� 行中，第 j�（1≤j≤m1≤�≤�）行的第一个整数为 Tj��，表示 j� 号函数的类型：

1. 若 Tj=1��=1，接下来两个整数 Pj,Vj��,�� 分别表示要执行加法的元素的下标及其增加的值；
2. 若 Tj=2��=2，接下来一个整数 Vj�� 表示所有元素所乘的值；
3. 若 Tj=3��=3，接下来一个正整数 Cj�� 表示 j� 号函数要调用的函数个数，
   随后 Cj�� 个整数 $g^{(j)}_1, g^{(j)}2, \ldots , g^{(j)}{C_j}$ 依次表示其所调用的函数的编号。

第 m+4�+4 行一个正整数 Q�，表示输入的函数操作序列长度。
第 m+5�+5 行 Q� 个整数 fi��，第 i� 个整数表示第 i� 个执行的函数的编号。

输出

一行 n� 个用空格隔开的整数，按照下标 1∼n1∼� 的顺序，分别输出在执行完输入的函数序列后，数据库中每一个元素的值。答案对 998244353998244353 取模。

样例输入 复制

3
1 2 3
3
1 1 1
2 2
3 2 1 2
2
2 3

样例输出 复制

6 8 12

提示

样例输入2

10
1 2 3 4 5 6 7 8 9 10
8
3 2 2 3
3 2 4 5
3 2 5 8
2 2
3 2 6 7
1 2 5
1 7 6
2 3
3
1 2 3

样例输出2

36 282 108 144 180 216 504 288 324 360

【样例 #1 解释】

11 号函数功能为将 a1�1 的值加一。22 号函数功能为所有元素乘 22。33 号函数将先调用 11 号函数，再调用 22 号函数。

最终的函数序列先执行 22 号函数，所有元素的值变为 2,4,62,4,6。

再执行 33 号函数时，先调用 11 号函数，所有元素的值变为 3,4,63,4,6。再调用 22 号函数，所有元素的值变为 6,8,126,8,12。

【数据范围】

测试点编号	n,m,Q≤�,�,�≤	∑Cj∑��	其他特殊限制
1∼21∼2	10001000	=m−1=�−1	函数调用关系构成一棵树
3∼43∼4	10001000	≤100≤100	无
5∼65∼6	2000020000	≤40000≤40000	不含第 22 类函数或不含第 11 类函数
77	2000020000	=0=0	无
8∼98∼9	2000020000	=m−1=�−1	函数调用关系构成一棵树
10∼1110∼11	2000020000	≤2×105≤2×105	无
12∼1312∼13	105105	≤2×105≤2×105	不含第 22 类函数或不含第 11 类函数
1414	105105	=0=0	无
15∼1615∼16	105105	=m−1=�−1	函数调用关系构成一棵树
17∼1817∼18	105105	≤5×105≤5×105	无
19∼2019∼20	105105	≤106≤106	无

对于所有数据：0≤ai≤1040≤��≤104，Tj∈1,2,3��∈1,2,3，1≤Pj≤n1≤��≤�，0≤Vj≤1040≤��≤104，1≤g(j)k≤m1≤��(�)≤�，1≤fi≤m1≤��≤�。

提交

#include<bits/stdc++.h>
using namespace std;
  
#define rep(i,a,b) for(int i=a,i##end=b;i<=i##end;++i)
#define drep(i,a,b) for(int i=a,i##end=b;i>=i##end;--i)
  
char IO;
int rd(){ 
    int s=0,f=0;
    while(!isdigit(IO=getchar())) if(IO=='-') f=1;
    do s=(s<<1)+(s<<3)+(IO^'0');
    while(isdigit(IO=getchar()));
    return f?-s:s;
}
  
const int N=1e5+10,P=998244353;
  
int n,m;
int A[N],T[N],H[N]; 
// A为原数组，T为乘法积，H为函数调用权值
int O[N],X[N],Y[N];
int B[N*11],C,L[N],R[N],ind[N];
int Q[N],QL,QR;
  
int main() {
    //freopen("call.in","r",stdin),freopen("call.out","w",stdout);
    rep(i,1,n=rd()) A[i]=rd();
    m=rd()+1; // 令m+1号为主函数
    rep(i,1,m) {
        O[i]=i<m?rd():3,T[i]=1;
        if(O[i]==1) X[i]=rd(),Y[i]=rd();
        else if(O[i]==2) T[i]=rd();
        else {
            L[i]=C+1,R[i]=C+=rd();
            rep(j,L[i],R[i]) ind[B[j]=rd()]++;
        }
    }
    rep(i,QL=1,m) if(!ind[i]) Q[++QR]=i;
    while(QL<=QR) {
        int u=Q[QL++];
        if(O[u]==3) rep(j,L[u],R[u]) if(--ind[B[j]]==0) Q[++QR]=B[j];
    }
    drep(k,m,1){
        int u=Q[k];
        if(O[u]==3) rep(j,L[u],R[u]) T[u]=1ll*T[u]*T[B[j]]%P;
    }
      
    rep(i,H[m]=1,n) A[i]=1ll*A[i]*T[m]%P;
    rep(k,1,m) {
        int u=Q[k],x=1;
        drep(j,R[u],L[u]){
            int v=B[j];
            H[v]=(H[v]+1ll*x*H[u])%P;
            x=1ll*x*T[v]%P;
        }
        if(O[u]==1) A[X[u]]=(A[X[u]]+1ll*H[u]*Y[u])%P;
    }
    rep(i,1,n) printf("%d ",A[i]); puts("");
}