ccf-csp 2018春季真题题解

---

1. 跳一跳
   问题描述
   　　近来，跳一跳这款小游戏风靡全国，受到不少玩家的喜爱。
   　　简化后的跳一跳规则如下：玩家每次从当前方块跳到下一个方块，如果没有跳到下一个方块上则游戏结束。
   　　如果跳到了方块上，但没有跳到方块的中心则获得1分；跳到方块中心时，若上一次的得分为1分或这是本局游戏的第一次跳跃则此次得分为2分，否则此次得分比上一次得分多两分（即连续跳到方块中心时，总得分将+2，+4，+6，+8…）。
   　　现在给出一个人跳一跳的全过程，请你求出他本局游戏的得分（按照题目描述的规则）。
   输入格式
   　　输入包含多个数字，用空格分隔，每个数字都是1，2，0之一，1表示此次跳跃跳到了方块上但是没有跳到中心，2表示此次跳跃跳到了方块上并且跳到了方块中心，0表示此次跳跃没有跳到方块上（此时游戏结束）。
   输出格式
   　　输出一个整数，为本局游戏的得分（在本题的规则下）。
   样例输入
   1 1 2 2 2 1 1 2 2 0
   样例输出
   22
   数据规模和约定
   　　对于所有评测用例，输入的数字不超过30个，保证0正好出现一次且为最后一个数字。

代码：

#include <iostream>

using namespace std;

const int MAXN = 40;
int arr[40];

int main(){
    int a, pre = 0, ans = 0;

    while(cin >> a && a){
        if(a == 1)
            ans += 1, pre = 1;
        else{
            if(pre == 1 || pre == 0)
                pre = 2;
            else
                pre += 2;
            ans += pre;
        }
    }
    cout << ans << endl;
    return 0;
}

---

2. 碰撞的小球
   问题描述
   　　数轴上有一条长度为L（L为偶数)的线段，左端点在原点，右端点在坐标L处。有n个不计体积的小球在线段上，开始时所有的小球都处在偶数坐标上，速度方向向右，速度大小为1单位长度每秒。
   　　当小球到达线段的端点（左端点或右端点）的时候，会立即向相反的方向移动，速度大小仍然为原来大小。
   　　当两个小球撞到一起的时候，两个小球会分别向与自己原来移动的方向相反的方向，以原来的速度大小继续移动。
   　　现在，告诉你线段的长度L，小球数量n，以及n个小球的初始位置，请你计算t秒之后，各个小球的位置。
   提示
   　　因为所有小球的初始位置都为偶数，而且线段的长度为偶数，可以证明，不会有三个小球同时相撞，小球到达线段端点以及小球之间的碰撞时刻均为整数。
   　　同时也可以证明两个小球发生碰撞的位置一定是整数（但不一定是偶数）。
   输入格式
   　　输入的第一行包含三个整数n, L, t，用空格分隔，分别表示小球的个数、线段长度和你需要计算t秒之后小球的位置。
   　　第二行包含n个整数a1, a2, …, an，用空格分隔，表示初始时刻n个小球的位置。
   输出格式
   　　输出一行包含n个整数，用空格分隔，第i个整数代表初始时刻位于ai的小球，在t秒之后的位置。
   样例输入
   3 10 5
   4 6 8
   样例输出
   7 9 9
   样例说明
   　　初始时，三个小球的位置分别为4, 6, 8。
   
   　　一秒后，三个小球的位置分别为5, 7, 9。
   
   　　两秒后，第三个小球碰到墙壁，速度反向，三个小球位置分别为6, 8, 10。
   
   　　三秒后，第二个小球与第三个小球在位置9发生碰撞，速度反向（注意碰撞位置不一定为偶数），三个小球位置分别为7, 9, 9。
   
   　　四秒后，第一个小球与第二个小球在位置8发生碰撞，速度反向，第三个小球碰到墙壁，速度反向，三个小球位置分别为8, 8, 10。
   
   　　五秒后，三个小球的位置分别为7, 9, 9。
   
   样例输入
   10 22 30
   14 12 16 6 10 2 8 20 18 4
   样例输出
   6 6 8 2 4 0 4 12 10 2
   数据规模和约定
   　　对于所有评测用例，1 ≤ n ≤ 100，1 ≤ t ≤ 100，2 ≤ L ≤ 1000，0 < ai < L。L为偶数。
   　　保证所有小球的初始位置互不相同且均为偶数。

代码：

#include <iostream>

using namespace std;

const int N = 110, M = 1010;

struct node{
    int x, fx;

    node():x{-1}, fx{1} {};
};
node arr[N];
int seats[M];
int n, L, t;

int main(){
    cin >> n >> L >> t;

    for(int i = 1; i <= n; i ++){
        cin >> arr[i].x;
        seats[arr[i].x] = i;
    }

    while(t --){
        for(int i = 1; i <= n; i ++){
            int &x = arr[i].x;
            seats[x] = 0;
            x += arr[i].fx;
            if(x == L || x == 0)
                arr[i].fx = -arr[i].fx;
            if(seats[x])
                arr[i].fx = -arr[i].fx, arr[seats[x]].fx = -arr[seats[x]].fx;
            seats[x] = i;
        }
    }
    for(int i = 1; i <= n; i ++)
        cout << arr[i].x << " ";
    return 0;
}

---

3. URL映射
   问题描述
   　　URL 映射是诸如 Django、Ruby on Rails 等网页框架 (web frameworks) 的一个重要组件。对于从浏览器发来的 HTTP 请求，URL 映射模块会解析请求中的 URL 地址，并将其分派给相应的处理代码。现在，请你来实现一个简单的 URL 映射功能。
   　　本题中 URL 映射功能的配置由若干条 URL 映射规则组成。当一个请求到达时，URL 映射功能会将请求中的 URL 地址按照配置的先后顺序逐一与这些规则进行匹配。当遇到第一条完全匹配的规则时，匹配成功，得到匹配的规则以及匹配的参数。若不能匹配任何一条规则，则匹配失败。
   　　本题输入的 URL 地址是以斜杠 / 作为分隔符的路径，保证以斜杠开头。其他合法字符还包括大小写英文字母、阿拉伯数字、减号 -、下划线 _ 和小数点 .。例如，/person/123/ 是一个合法的 URL 地址，而 /person/123? 则不合法（存在不合法的字符问号 ?）。另外，英文字母区分大小写，因此 /case/ 和 /CAse/ 是不同的 URL 地址。
   　　对于 URL 映射规则，同样是以斜杠开始。除了可以是正常的 URL 地址外，还可以包含参数，有以下 3 种：
   　　字符串 ：用于匹配一段字符串，注意字符串里不能包含斜杠。例如，abcde0123。
   　　整数 ：用于匹配一个不带符号的整数，全部由阿拉伯数字组成。例如，01234。
   　　路径 ：用于匹配一段字符串，字符串可以包含斜杠。例如，abcd/0123/。
   　　以上 3 种参数都必须匹配非空的字符串。简便起见，题目规定规则中 和 前面一定是斜杠，后面要么是斜杠，要么是规则的结束（也就是该参数是规则的最后一部分）。而 的前面一定是斜杠，后面一定是规则的结束。无论是 URL 地址还是规则，都不会出现连续的斜杠。
   输入格式
   　　输入第一行是两个正整数 n 和 m，分别表示 URL 映射的规则条数和待处理的 URL 地址个数，中间用一个空格字符分隔。
   　　第 2 行至第 n+1 行按匹配的先后顺序描述 URL 映射规则的配置信息。第 i+1 行包含两个字符串 pi 和 ri，其中 pi 表示 URL 匹配的规则，ri 表示这条 URL 匹配的名字。两个字符串都非空，且不包含空格字符，两者中间用一个空格字符分隔。
   　　第 n+2 行至第 n+m+1 行描述待处理的 URL 地址。第 n+1+i 行包含一个字符串 qi，表示待处理的 URL 地址，字符串中不包含空格字符。
   输出格式
   　　输入共 m 行，第 i 行表示 qi 的匹配结果。如果匹配成功，设匹配了规则 pj ，则输出对应的 rj。同时，如果规则中有参数，则在同一行内依次输出匹配后的参数。注意整数参数输出时要把前导零去掉。相邻两项之间用一个空格字符分隔。如果匹配失败，则输出 404。
   样例输入
   5 4
   /articles/2003/ special_case_2003
   /articles// year_archive
   /articles/// month_archive
   /articles article_detail
   /static/ static_serve
   /articles/2004/
   /articles/1985/09/aloha/
   /articles/hello/
   /static/js/jquery.js
   样例输出
   year_archive 2004
   article_detail 1985 9 aloha
   404
   static_serve js/jquery.js
   样例说明
   　　对于第 1 个地址 /articles/2004/，无法匹配第 1 条规则，可以匹配第 2 条规则，参数为 2004。
   　　对于第 2 个地址 /articles/1985/09/aloha/，只能匹配第 4 条规则，参数依次为 1985、9（已经去掉前导零）和 aloha。
   　　对于第 3 个地址 /articles/hello/，无法匹配任何一条规则。
   　　对于第 4 个地址 /static/js/jquery.js，可以匹配最后一条规则，参数为 js/jquery.js。
   数据规模和约定
   　　1 ≤ n ≤ 100，1 ≤ m ≤ 100。
   　　所有输入行的长度不超过 100 个字符（不包含换行符）。
   　　保证输入的规则都是合法的。
   　　
   代码：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

const int N = 110;

struct node {
    string name;
    vector<string> v;
    bool op{};    //末尾是否有 /

    node() {
        op = false;
    }
};

node arr[N];
int n, m;

void deal(node &a, const string &s) {
    int pos = 1;    //跳过第一个 /
    int len;

    a.op = s.back() == '/';
    while (pos < s.length()) {
        len = 0;
        while (pos + len < s.length() && s[pos + len] != '/')
            ++len;
        a.v.push_back(s.substr(pos, len));
        pos += len + 1;
    }
}

bool check(node &tmp, node &a, vector<string> &ans) {
    //合法性检查
    if (a.v.size() && a.v.back() != "<path>" && a.op != tmp.op)
        return false;
    int pos = 0, i = 0;
    for (; i < tmp.v.size() && pos < a.v.size(); i++, pos++) {
        string &s = tmp.v[i];
        if (a.v[pos] == s) {
            continue;
        } else {
            if (a.v[pos] == "<int>") {
                for (char c : s)
                    if (!isdigit(c))
                        return false;
                //去除前导 0
                int k = 0;
                //保留一位 考虑全部都是0的情况
                while (k + 1 < s.length() && s[k] == '0')
                    ++k;
                ans.push_back(s.substr(k));
            } else if (a.v[pos] == "<str>") {
                ans.push_back(s);
            } else if (a.v[pos] == "<path>") {
                string t;
                for (; i < tmp.v.size(); i++)
                    t += tmp.v[i] + '/';
                if (!tmp.op)
                    t.pop_back();
                ans.push_back(t);
                return true;
            } else {
                return false;
            }
        }
    }
    return i == tmp.v.size() && pos == a.v.size();
}

int main() {
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        string a, b;

        cin >> a >> b;
        arr[i].name = b;
        deal(arr[i], a);
    }

    while (m--) {
        node tmp;
        string s;
        bool op = false;

        cin >> s;
        deal(tmp, s);

        for (int i = 0; i < n && !op; i++) {
            node &a = arr[i];
            vector<string> ans;
            if (check(tmp, a, ans)) {
                cout << a.name << " ";
                for (const string &ss : ans)
                    cout << ss << " ";
                cout << endl;
                op = true;
            }
        }
        if (!op)
            cout << "404" << endl;
    }

    return 0;
}

---

4. 棋局评估
   问题描述
   　　Alice和Bob正在玩井字棋游戏。
   　　井字棋游戏的规则很简单：两人轮流往3*3的棋盘中放棋子，Alice放的是“X”，Bob放的是“O”，Alice执先。当同一种棋子占据一行、一列或一条对角线的三个格子时，游戏结束，该种棋子的持有者获胜。当棋盘被填满的时候，游戏结束，双方平手。
   　　Alice设计了一种对棋局评分的方法：
   　　- 对于Alice已经获胜的局面，评估得分为(棋盘上的空格子数+1)；
   　　- 对于Bob已经获胜的局面，评估得分为 -(棋盘上的空格子数+1)；
   　　- 对于平局的局面，评估得分为0；
   
   　　例如上图中的局面，Alice已经获胜，同时棋盘上有2个空格，所以局面得分为2+1=3。
   　　由于Alice并不喜欢计算，所以他请教擅长编程的你，如果两人都以最优策略行棋，那么当前局面的最终得分会是多少？
   输入格式
   　　输入的第一行包含一个正整数T，表示数据的组数。
   　　每组数据输入有3行，每行有3个整数，用空格分隔，分别表示棋盘每个格子的状态。0表示格子为空，1表示格子中为“X”，2表示格子中为“O”。保证不会出现其他状态。
   　　保证输入的局面合法。(即保证输入的局面可以通过行棋到达，且保证没有双方同时获胜的情况)
   　　保证输入的局面轮到Alice行棋。
   输出格式
   　　对于每组数据，输出一行一个整数，表示当前局面的得分。
   样例输入
   3
   1 2 1
   2 1 2
   0 0 0
   2 1 1
   0 2 1
   0 0 2
   0 0 0
   0 0 0
   0 0 0
   样例输出
   3
   -4
   0
   样例说明
   　　第一组数据：
   　　Alice将棋子放在左下角(或右下角)后，可以到达问题描述中的局面，得分为3。
   　　3为Alice行棋后能到达的局面中得分的最大值。
   　　第二组数据：
   
   　　Bob已经获胜(如图)，此局面得分为-(3+1)=-4。
   　　第三组数据：
   　　井字棋中若双方都采用最优策略，游戏平局，最终得分为0。
   数据规模和约定
   　　对于所有评测用例，1 ≤ T ≤ 5。

代码：

#include <iostream>

using namespace std;
int arr[3][3];

inline int cal() {
    int cnt = 0;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            if (arr[i][j] == 0)
                ++cnt;
    return cnt;
}

//op为1代表先手
int dfs(int p) {
    //判断是否获胜
    int q = 3 - p;
    bool op = false;
    for (int i = 0; i < 3; i++) {
        bool t = true;
        for (int j = 0; j < 3; j++)
            if (arr[i][j] != q)
                t = false;
        if (t)
            op = true;
    }
    for (int i = 0; i < 3; i++) {
        bool t = true;
        for (int j = 0; j < 3; j++)
            if (arr[j][i] != q)
                t = false;
        if (t)
            op = true;
    }
    op |= (arr[0][0] == q && arr[1][1] == q && arr[2][2] == q) || (arr[2][0] == q && arr[1][1] == q && arr[0][2] == q);

    if (op) {
        int t = cal() + 1;
        //考虑到上一个对手
        return q == 1 ? t : -t;
    }

    //填满了
    if (cal() == 0)
        return 0;

    int a = -10, b = 10;
    //回溯dfs
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (arr[i][j])
                continue;
            arr[i][j] = p;
            int t = dfs(3 - p);
            a = max(a, t);
            b = min(b, t);
            arr[i][j] = 0;
        }
    }
    if (p == 1)
        return a;
    else
        return b;
}

int main() {
    int T;

    cin >> T;
    while (T--) {
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++)
                cin >> arr[i][j];
        cout << dfs(1) << endl;
    }
    return 0;
}

---

5. 二次求和
   问题描述
   　　给一棵 n 个节点的树，用 1 到 n 的整数表示。每个节点上有一个整数权值 ai。再给出两个整数 L,R。现在有 m 个操作，每个操作这样描述：
   　　给定树上两个节点 u,v 和一个整数 d，表示将树上 u 到 v 唯一的简单路径上每个点的权值 ai 都加上 d。之后求树上所有节点个数大于等于 L 小于等于 R 的简单路径的节点权值和之和。注意这里有两次求和：对于一条节点个数大于等于 L 小于等于 R 的简单路径，求出它所有节点的权值之和；然后对所有这样的路径，对它们的权值和再进行求和。因为答案很大，只用输出对Q=1,000,000,007 取余的结果即可。
   输入格式
   　　从标准输入读入数据。
   　　包含多组数据。数据的第一行包含一个正整数 T，表示数据组数。保证 T=10。
   　　每组数据的第一行包含 4 个非负整数 n,m,L,R，分别表示节点个数、操作个数和询问相关的两个参数。保证 1≤L≤R≤n。
   　　第二行包含 n 个整数，表示 ai。保证 0≤ai<Q。
   　　第三行包含 n-1 个整数，描述树的形态，其中第 i 个数 fi 表示节点 i+1 与节点 fi 之间有一条边，保证 1≤fi≤i<n。能够证明，这样能够保证给出的是一棵树。
   　　接下来 m 行，每行包含三个整数 u,v,d，描述一个操作即将树上 u 到 v 唯一的简单路径上每个点的权值 ai 都加上 d，之后询问满足条件的两次求和的结果。保证 1≤u,v≤n，0≤d<Q。
   　　保证上述同一行所有的数之间，均用一个空格隔开。
   输出格式
   　　输出到标准输出。
   　　输出 m 行每行一个整数，表示两次求和的结果对 Q=1000000007 求余的结果。
   　　子任务
   　　共有 10 个测试点，各测试点特点如下：
   　　测试点1：n=10，m=10。
   　　测试点2：n=50，m=50。
   　　测试点3：n=300，m=300。
   　　测试点4：n=2000，m=2000。
   　　测试点5：n=2000，m=100000。
   　　测试点6：n=100000，m=100000。保证 fi=i。
   　　测试点7：n=100000，m=100000。保证 fi=⌊(i+1)/2⌋，其中 ⌊⋅⌋ 表示向下取整，即给定的树是完全二叉树。
   　　测试点8：n=100000，m=100000。保证对于同一组数据，相同的 fi 至多出现 2 次，即给定的树是二叉树。
   　　测试点9：n=100000，m=100000。
   　　测试点10：n=100000，m=100000。
   　　上述约束对同一测试点中的每组数据都有效。

代码：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;
const int N = 100010, M = N * 2, MOD = 1e9 + 7;

int n, m, L, R;
int w[N];
int h[N], father[N], e[M], ne[M], idx;
int depth[N], fa[N][17];
int path[N], d[N], que[N];
int pos[N], root[N];
bool st[N];
int tr[N];
struct Node
{
    int d, w, id;
    bool operator< (const Node& t) const
    {
        return d < t.d;
    }
}q[N], p[N];

inline void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

inline int lowbit(int x)
{
    return x & -x;
}

inline void update(int x, int v, int k)
{
    for (int i = x; i <= k; i += lowbit(i)) tr[i] = (tr[i] + v) % MOD;
}

inline int query(int x, int k)
{
    x = min(x, k);
    int res = 0;
    for (int i = x; i > 0; i -= lowbit(i)) res = (res + tr[i]) % MOD;
    return res;
}

void bfs()
{
    memset(depth, 0x3f, sizeof depth);
    depth[0] = 0, depth[1] = 1;
    int hh = 0, tt = 0;
    que[0] = 1;
    while (hh <= tt)
    {
        int t = que[hh ++ ];
        for (int i = h[t]; ~i; i = ne[i])
        {
            int j = e[i];
            if (depth[j] > depth[t] + 1)
            {
                depth[j] = depth[t] + 1;
                que[ ++ tt] = j;
                fa[j][0] = t;
                for (int k = 1; k <= 16; k ++ )
                    fa[j][k] = fa[fa[j][k - 1]][k - 1];
            }
        }
    }
}

inline int lca(int a, int b)
{
    if (depth[a] < depth[b]) swap(a, b);
    for (int k = 16; k >= 0; k -- )
        if (depth[fa[a][k]] >= depth[b])
            a = fa[a][k];
    if (a == b) return a;
    for (int k = 16; k >= 0; k -- )
        if (fa[a][k] != fa[b][k])
        {
            a = fa[a][k];
            b = fa[b][k];
        }
    return fa[a][0];
}

void dfs(int u, int fa)
{
    d[u] = (d[fa] + path[u]) % MOD;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j == fa) continue;
        dfs(j, u);
    }
}

int get_size(int u, int fa)
{
    if (st[u]) return 0;
    int res = 1;
    for (int i = h[u]; ~i; i = ne[i])
        if (e[i] != fa)
            res += get_size(e[i], u);
    return res;
}

int get_wc(int u, int fa, int tot, int& wc)
{
    if (st[u]) return 0;
    int sum = 1, ms = 0;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j == fa) continue;
        int t = get_wc(j, u, tot, wc);
        ms = max(ms, t);
        sum += t;
    }
    ms = max(ms, tot - sum);
    if (ms <= tot / 2) wc = u;
    return sum;
}

void get_dist(int u, int fa, int dist, int sum, int& qt)
{
    if (st[u]) return;
    q[ ++ qt] = {dist, sum, u};
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j != fa)
            get_dist(j, u, dist + 1, (sum + w[j]) % MOD, qt);
    }
}

inline int get(Node a[], int k, int limit, int wu, int& pu)
{
    sort(a + 1, a + k + 1);
    static int sum[N];
    int res = 0;
    for (int i = 1; i <= k; i ++ ) sum[i] = (sum[i - 1] + a[i].w) % MOD;
    for (int i = 1, j = k; i < j; i ++ )
    {
        while (j > i && a[j].d + a[i].d - 1 > limit) j -- ;
        if (j > i && a[j].d + a[i].d - 1 <= limit)
        {
            res = (res + (LL)sum[j] - sum[i] + (LL)(j - i) * a[i].w - (LL)wu * (j - i)) % MOD;
            pu = (pu + j - i) % MOD;
        }
    }
    return res;
}

int dfs_path(int u, int fa, int dist, int maxd)
{
    if (st[u]) return 0;
    int res = (query(R + 1 - dist, maxd) - query(L - dist, maxd)) % MOD;
    if (dist >= L && dist <= R) res = (res + 1) % MOD;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j != fa)
            res = (res + dfs_path(j, u, dist + 1, maxd)) % MOD;
    }
    path[u] = (path[u] + res) % MOD;
    return res;
}

int calc(int u)
{
    if (st[u]) return 0;
    get_wc(u, -1, get_size(u, -1), u);
    st[u] = true;

    int res = 0, pt = 0;
    if (L <= 1 && R >= 1) res = w[u], path[u] = (path[u] + 1) % MOD;
    int cnt = 0, maxd = 0;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i], qt = 0;
        if (st[j]) continue;
        get_dist(j, -1, 2, (w[u] + w[j]) % MOD, qt);
        int pR = 0, pL = 0;
        res = (res - (LL)(get(q, qt, R, w[u], pR) - get(q, qt, L - 1, w[u], pL))) % MOD;
        path[u] = (path[u] - (LL)(pR - pL)) % MOD;
        pos[ ++ cnt] = pt + 1;  // 每一段开头
        root[cnt] = j;  // 每一段的根节点
        for (int k = 1; k <= qt; k ++ )
        {
            if (q[k].d >= L && q[k].d <= R)
            {
                res = (res + q[k].w) % MOD;
                path[u] = (path[u] + 1) % MOD;  // 只计算从u到当前点的
            }
            p[ ++ pt] = q[k];
            maxd = max(maxd, q[k].d);
        }
    }

    pos[cnt + 1] = pt + 1;  // 哨兵

    for (int i = 1; i <= maxd; i ++ ) tr[i] = 0;
    for (int i = 1; i <= pt; i ++ ) update(p[i].d, 1, maxd);  // 插入树状数组中
    for (int i = 1; i <= cnt; i ++ )
    {
        int l = pos[i], r = pos[i + 1] - 1;
        for (int j = l; j <= r; j ++ ) update(p[j].d, -1, maxd);  // 将当前子树中的节点删掉
        dfs_path(root[i], u, 2, maxd);
        for (int j = l; j <= r; j ++ ) update(p[j].d, 1, maxd);  // 将当前子树中的节点添加回来
    }

    int pR = 0, pL = 0;
    res = (res + (LL)get(p, pt, R, w[u], pR) - get(p, pt, L - 1, w[u], pL)) % MOD;
    path[u] = (path[u] + (LL)pR - pL) % MOD;

    for (int i = h[u]; ~i; i = ne[i]) res = (res + calc(e[i])) % MOD;
    return res;
}

int main()
{
    int T;
    scanf("%d", &T);
    while (T -- )
    {
        scanf("%d%d%d%d", &n, &m, &L, &R);
        memset(h, -1, sizeof h), idx = 0;
        memset(path, 0, sizeof path);
        for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
        for (int i = 2; i <= n; i ++ )
        {
            int p;
            scanf("%d", &p);
            add(i, p), add(p, i);
            father[i] = p;
        }
        memset(st, 0, sizeof st);
        int res = calc(1);

        dfs(1, 0);
        bfs();
        while (m -- )
        {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            int p = lca(a, b);
            int sum = (d[a] + (LL)d[b] - d[p] * 2 + path[p]) * c % MOD;
            res = ((res + sum) % MOD + MOD) % MOD;
            printf("%d\n", res);
        }
    }

    return 0;
}

作者：yxc
链接：https://www.acwing.com/activity/content/code/content/957323/

---

更多历年题解戳这里：ccf-csp 历年真题题解