CSP-S2020提高级T3：函数调用

题目链接

[CSP-S2020] 函数调用

题目描述

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

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

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

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

输入格式

第一行一个正整数 $n$，表示数据的个数。
第二行 $n$ 个整数，第 $i$ 个整数表示下标为 $i$ 的数据的初始值为 $a_i$。
第三行一个正整数 $m$，表示数据库应用程序提供的函数个数。函数从 $1\sim m$ 编号。
接下来 $m$ 行中，第 $j$（$1\le j\le m$）行的第一个整数为 $T_j$，表示 $j$ 号函数的类型：

1. 若 $T_j=1$，接下来两个整数 $P_j,V_j$ 分别表示要执行加法的元素的下标及其增加的值；
2. 若 $T_j=2$，接下来一个整数 $V_j$ 表示所有元素所乘的值；
3. 若 $T_j=3$，接下来一个正整数 $C_j$ 表示 $j$ 号函数要调用的函数个数，
   随后 $C_j$ 个整数 $g_1^{(j)},g_2^{(j)},\dots ,g_{C_j}^{(j)}$ 依次表示其所调用的函数的编号。

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

输出格式

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

样例 #1

样例输入 #1

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

样例输出 #1

6 8 12

样例 #2

样例输入 #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 解释】

$1$ 号函数功能为将 $a_1$ 的值加一。$2$ 号函数功能为所有元素乘 $2$。$3$ 号函数将先调用 $1$ 号函数，再调用 $2$ 号函数。

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

再执行 $3$ 号函数时，先调用 $1$ 号函数，所有元素的值变为 $3,4,6$。再调用 $2$ 号函数，所有元素的值变为 $6,8,12$。

【数据范围】

测试点编号	$n,m,Q\le$	$\sum C_j$	其他特殊限制
$1\sim 2$	$1000$	$=m-1$	函数调用关系构成一棵树
$3\sim 4$	$1000$	$\le 100$	无
$5\sim 6$	$20000$	$\le 40000$	不含第 $2$ 类函数或不含第 $1$ 类函数
$7$	$20000$	$=0$	无
$8\sim 9$	$20000$	$=m-1$	函数调用关系构成一棵树
$10\sim 11$	$20000$	$\le 2\times 10^5$	无
$12\sim 13$	$10^5$	$\le 2\times 10^5$	不含第 $2$ 类函数或不含第 $1$ 类函数
$14$	$10^5$	$=0$	无
$15\sim 16$	$10^5$	$=m-1$	函数调用关系构成一棵树
$17\sim 18$	$10^5$	$\le 5\times 10^5$	无
$19\sim 20$	$10^5$	$\le 10^6$	无

对于所有数据：$0\le a_i\le 10^4$， T j ∈ { 1 , 2 , 3 } T_j \in \{1,2,3\} Tj​∈{1,2,3}，$1\le P_j\le n$，$0\le V_j\le 10^4$，$1\le g_k^{(j)}\le m$，$1\le f_i\le m$。

算法思想

根据题目描述，输入一个函数操作的序列，输出执行完输入的函数序列后，数据库中每一个元素的值。

在所有的函数序列中，一共包含$3$种操作类型：

1. 加法操作，对于指定下标的元素增加一个数值值；
2. 乘法操作，给所有元素乘上一个数值；
3. 嵌套调用，以一定顺序调用其它函数。

乘法和加法

对于乘法操作，只需要统计对所有变量所乘的值$V$，在最后给每个元素乘上就可以了。

对于加法操作，会受到后面乘法操作的影响。假设整个数据库中只有一个元素$x$，对它依次执行：$+1、\times 2、+3、\times 4$操作，如下图所示：

那么$+1$的操作实际上就有了一个$2\times 4$的系数，$+3$的操作系数为$4$；那$x$最终会变为$8x+8\times 1+4\times 3$。
也就是说加法操作最终对答案的贡献等于它后面所有乘法操作的乘积$\times$加上的数。

这样就可以从后向前进行函数操作，记录已进行的乘法操作的乘积，就能计算出每次加法操作的所要乘的系数了。

这里所要乘的系数可以理解为加法被执行的次数。

嵌套调用

对于所有操作3，按顺序向它调用的函数连边，会得到一个有向无环图（DAG）。
对于图上的每个点(代表着一种操作)，维护一个mul属性，表示执行这个操作会给每个元素乘上的值。

• 加法操作的mul为$1$
• 乘法操作的mul为它要乘上的数$v$。
• 嵌套操作的mul等于它直接相邻的所有点的mul的乘积，如下图所示$f_i$的mul为$2\times 4=8$
  
  可以对拓扑序列从后向前遍历一次，来求嵌套操作的mul。

但是有些嵌套操作既包含加法又包含乘法，该如何计算其中的加法操作所要乘的系数呢？如下图所示

可以发现，$f_1$的所要乘的系数（加法被执行的次数）跟两部分有关：

• 嵌套函数$f_i$的执行次数
  对每个点再维护一个sum属性，表示加法或嵌套函数被执行的次数。然后从后向前遍历操作序列，就可以求得$f_i$的执行次数，
• $f_1$后面所有乘法操作的乘积，例如$f_2$,$f_4$
  可以倒序枚举$f_i$的所有邻接点，从后向前统计出$f_2$和$f_4$的mul。

那么，$f_1.sum=f_i.sum\times f_2.mul\times f_4.mul$

最后，让数组的每个元素乘上所有$Q$ 次操作的mul，再遍历所有加法操作计算应该加多少即可。

代码实现

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e5 + 5, M = 1e6 + 5, mod = 998244353;
struct F
{
    //mul表示执行函数时所有变量需要乘的值是多少
    //sum表示函数一共的执行次数
    int t, p, v, mul, sum;
}f[N];
int n, m, Q, a[N], d[N], q[N], g[N];
int h[N], e[M], ne[M], idx;
void add(int a, int b)  // 添加一条边a->b
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
void topsort()
{
    int hh = 0, tt = -1;
    for (int i = 1; i <= m; i ++ )
        if (!d[i]) // d[i] 存储点i的入度
            q[ ++ tt] = i;
    while (hh <= tt)
    {
        int t = q[hh ++ ];
        for (int i = h[t]; ~ i; i = ne[i])
        {
            int j = e[i];
            if (-- d[j] == 0)
                q[ ++ tt] = j;
        }
    }
}
void get_mul()
{
    for(int i = m - 1; i >= 0; i --) //从后向前遍历拓扑序列
    {
        int u = q[i]; //u函数的mul等于其子函数mul的乘积
        for(int j = h[u]; ~ j; j = ne[j])
        {
            int v = e[j];
            f[u].mul = (LL)f[u].mul * f[v].mul % mod; 
        }
    }
}
void get_sum()
{
    for(int i = 0; i < m; i ++)//从前向后遍历拓扑序列
    {
        int u = q[i], sum = f[u].sum;
        for(int j = h[u]; ~ j; j = ne[j])
        {
            int v = e[j];
            //u的子函数的执行次数包含两部分
            f[v].sum = (f[v].sum + sum) % mod; //u的执行次数
            sum = (LL) sum * f[v].mul % mod; //v后面累积乘的值
        }
    }
}

int main()
{
    scanf("%d", &n);
    for(int i = 1; i <= n; i ++) scanf("%d", &a[i]);
    scanf("%d", &m);
    memset(h, -1, sizeof h);
    for(int i = 1; i <= m; i ++)
    {
        scanf("%d", &f[i].t);
        if(f[i].t == 1) scanf("%d%d", &f[i].p, &f[i].v);
        else if(f[i].t == 2) scanf("%d", &f[i].v);
        else //嵌套函数
        {
            int c, v;
            scanf("%d", &c);
            while(c --) { scanf("%d", &v); d[v] ++; add(i, v); }
        }
    }
    for(int i = 1; i <= m; i ++) //初始化函数的mul属性
        if(f[i].t == 2) f[i].mul = f[i].v; //乘法的mul为v
        else f[i].mul = 1; //加法或者嵌套函数的mul为1
    
    topsort(); //拓扑排序
    get_mul(); //根据拓扑序列计算乘法的贡献
    
    scanf("%d", &Q);
    for(int i = 1; i <= Q; i ++) scanf("%d", &g[i]);//输入调用序列
    
    int sum = 1; //计算所有乘法累积所乘的值
    for(int i = Q; i > 0; i --) //从后向前遍历调用序列
    {
        int u = g[i];
        f[u].sum = (f[u].sum + sum) % mod; //累加乘法对加法的影响
        sum = (LL)sum * f[u].mul % mod; //累积所乘的值
    }
    get_sum(); //根据拓扑序列，计算加法的贡献
    
    for(int i = 1; i <= n; i ++) //计算乘法操作最终对每个元素的影响
        a[i] = (LL)a[i] * sum % mod; 
    
    for(int i = 1; i <= m; i ++) //计算加法操作最终对每个元素的影响
        if(f[i].t == 1)
            a[f[i].p] = (a[f[i].p] + (LL)f[i].v * f[i].sum) % mod;
    
    for(int i = 1; i <= n; i ++)
        printf("%d ", a[i]);

    return 0;
}