CCF-CSP真题《202309-5 阻击》思路+ c++题解

原创已于 2024-06-07 22:20:04 修改 · 4.2k 阅读

37 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #csp-ccf

于 2023-12-17 21:08:15 首次发布

算法题练习专栏收录该内容

66 篇文章

订阅专栏

文章介绍了一个关于计算在阴阳龙阻击战中如何调整敌军路径，以最大化其总损失的策略问题，涉及路径分析和优化算法的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

想查看其他题的真题及题解的同学可以前往查看：CCF-CSP真题附题解大全

试题编号：

202309-5

试题名称：

阻击

时间限制：

2.0s

内存限制：

512.0MB

问题描述：

问题描述

上回提到，西西艾弗岛下方有一个庞大的遗迹群，栖息着一种名为“阴阳龙”的神兽。然而隔壁的狄迪吉岛盯上了西西艾弗岛，决定发动一场战争，试图从遗迹群中掠夺有价值的宝物。由此，西西艾弗岛不得不陷入一场漫长的阻击战中，史称“阴阳龙阻击战”。

狄迪吉岛拥有胜过西西艾弗岛的科技实力和武装水平，西西艾弗岛很快发现形势不妙：全歼敌军似乎是不可能的，唯一的策略是凭借主场作战的优势和人海战术，尽可能给敌军带来损失，当敌军发现发动进攻的损失明显超过收益时，就会无趣而归。

具体而言，西西艾弗岛共有 n 座城市，有 n−1 条道路连接这些城市，使得所有城市之间均可以通过道路互相到达。容易发现，任意两座城市之间都有唯一一条不经过重复城市的路径。

由于缺乏城市巷战的实力，西西艾弗岛决定将防御重心放在道路上。在每条道路上均派遣了一定的军队防守，当敌军经过时对其发动阻击。虽然由于实力的差距，并不能阻止敌军通过道路，但仍然可以对敌军造成一定的损失。

然而，敌军具有更强的科技，可以趁机对道路附近的遗迹进行探索，并掠夺其中的宝物——这也正是敌军发动战争的意义所在。如此，敌军通过一条道路时，“发掘宝物的收益”w 和“受到阻击的损失”b 两个值是独立的。

西西艾弗岛事先在狄迪吉岛中安插了一系列间谍，得到的情报消息如下：敌军将选择西西艾弗岛的两座城市作为进攻的“起点”和“终点”，并派遣军队在进攻起点城市登陆，沿两座城市间唯一的路径进攻至终点城市。同时，间谍还背负着另外一个重要的使命：影响敌军对于起点和终点城市的决策，使得敌军受到的总损失尽可能大，其中“总损失”定义为敌军经过的每条道路上的“受到阻击的损失”减去“发掘宝物的收益”之和，即总损失是路径上的每条边总损失=∑e是路径上的每条边(be−we)。

此外，遗迹中宝物的价值与所处的环境属性密切相关，而阴阳龙的“现身”会使得环境的阴阳属性发生变化，这会使得敌军通过现身位置处的某一条道路时“发掘宝物的收益”w 发生变化。

这样的“阴阳龙现身”事件共会发生 m 次，你的任务就是帮助间谍计算出在所有事件前及每次事件后，敌军对于起点和终点城市的决策应当怎样改变，以最大化敌军的总损失。

输入格式

从标准输入读入数据。

第 1 行，两个非负整数 n,m，分别表示西西艾弗岛的城市数和“阴阳龙现身”事件数。

接下来 n−1 行，每行 4 个非负整数 ui,vi,wi,bi，表示第 i 条道路连接城市 ui 和 vi，敌军在这条道路上“发掘宝物的收益”为 wi，“受到阻击的损失”为 bi。

接下来 m 行，每行 2 个非负整数 xi,yi，表示一次“阴阳龙现身”事件，使得第 xi 条道路的“发掘宝物的收益”变为 yi。

输出格式

输出到标准输出中。

输出 m+1 行，每行一个非负整数，分别表示在所有事件前及每次事件后，对敌军造成的最大总损失。

样例输入

5 3
1 2 6 4
2 3 2 1
3 4 5 3
3 5 8 5
3 2
4 3
1 1

样例输出

0
1
3
4

样例说明

在最初，由于敌人攻打每一条道路都会有正收益，因此间谍最好的策略就是将进攻起点和终点选为同一座城市，这样敌军的总损失为 0。

第 1 次事件后，间谍可以将进攻起点和终点分别选在城市 3 和 4，这样敌军的总损失为 3−2=1。

第 2 次事件后，间谍可以将进攻起点和终点分别选在城市 4 和 5，这样敌军的总损失为 (3−2)+(5−3)=3。

第 3 次事件后，间谍可以将进攻起点和终点分别选在城市 1 和 5，这样敌军的总损失为 (4−1)+(1−2)+(5−3)=4。

评测用例规模与约定

对于所有测试数据保证：2≤n≤105,0≤m≤105,1≤ui,vi≤n,1≤xi≤n−1,0≤wi,bi,yi≤109。

测试点编号	n≤	m≤	特殊性质
1	20	20	无
2	300	300	无
3∼4	3000	3000	A
5∼6	3000	3000	B
7∼9	3000	3000	无
10	105	0	A
11	105	0	B
12	105	0	无
13∼15	105	105	A
16∼18	105	105	B
19∼21	105	105	C
22∼25	105	105	无

特殊性质 A：ui=i,vi=i+1。

特殊性质 B：0≤wi,yi≤10^8≤bi。

特殊性质 C：保证任意两座城市均可在经过不超过 100 条道路的前提下互相到达。

真题来源：阻击

感兴趣的同学可以如此编码进去进行练习提交

c++题解：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
 
const int N = 1e5 + 8;
 
class segment{
    #define lson root << 1
    #define rson root << 1 | 1
    LL ans[N << 2];
    LL lsum[N << 2];
    LL rsum[N << 2];
    LL sum[N << 2];
 
    public:
    void popup(int root){
        ans[root] = max({ans[lson], ans[rson], rsum[lson] + lsum[rson]});
        lsum[root] = max(lsum[lson], sum[lson] + lsum[rson]);
        rsum[root] = max(rsum[rson], sum[rson] + rsum[lson]);
        sum[root] = sum[lson] + sum[rson];
    }
 
    void build(int root, int l, int r, vector<int>& a){
        if (l == r){
            ans[root] = (a[l] >= 0 ? a[l] : 0);
            lsum[root] = (a[l] >= 0 ? a[l] : 0);
            rsum[root] = (a[l] >= 0 ? a[l] : 0);
            sum[root] = a[l];
            return;
        }
        int mid = (l + r) >> 1;
        build(lson, l, mid, a);
        build(rson, mid + 1, r, a);
        popup(root);
    }
 
    void update(int root, int l, int r, int pos, int val){
        if (l == r){
            ans[root] = (val >= 0 ? val : 0);
            lsum[root] = (val >= 0 ? val : 0);
            rsum[root] = (val >= 0 ? val : 0);
            sum[root] = val;
            return;
        }
        int mid = (l + r) >> 1;
        if (pos <= mid)
            update(lson, l, mid, pos, val);
        else 
            update(rson, mid + 1, r, pos, val);
        popup(root);
    }
 
    LL query(int root){
        return ans[root];
    }
}seg;
 
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, m;
    cin >> n >> m;
    vector<vector<int>> G(n);
    vector<array<int, 4>> edge;
    for(int i = 1; i < n; ++ i){    
        int u, v, w, b;
        cin >> u >> v >> w >> b;
        -- u, -- v;
        G[u].push_back(edge.size());
        G[v].push_back(edge.size());
        edge.push_back({u, v, w, b});
    }
    vector<LL> maxd(n, 0);
    LL ans = 0;
    function<void(int, int)> dfs = [&](int u, int fa){
        for(auto &i : G[u]){
            int v = edge[i][0] ^ edge[i][1] ^ u;
            if (v == fa)
                continue;
            int d = edge[i][3] - edge[i][2];
            dfs(v, u);
            ans = max(ans, maxd[u] + maxd[v] + d);
            maxd[u] = max(maxd[u], maxd[v] + d);
        }
    };
    dfs(1, 1);
    cout << ans << '\n';
    if (m < 100000){
        for(int i = 1; i <= m; ++ i){
            int x, y;
            cin >> x >> y;
            -- x;
            edge[x][2] = y;
            ans = 0;
            fill(maxd.begin(), maxd.end(), 0);
            dfs(1, 1);
            cout << ans << '\n';
        }
    }else{
        int ok1 = true;
        for(int i = 0; i < n - 1; ++ i){
            ok1 &= (edge[i][0] == i && edge[i][1] == i + 1);
        }
        if (ok1){
            // A
            vector<int> a(n);
            for(int i = 1; i < n; ++ i){
                a[i] = edge[i - 1][3] - edge[i - 1][2];
            }
            seg.build(1, 1, n - 1, a);
            for(int i = 1; i <= m; ++ i){
                int x, y;
                cin >> x >> y;
                -- x;
                edge[x][2] = y;
                seg.update(1, 1, n - 1, x + 1, edge[x][3] - edge[x][2]);
                cout << seg.query(1) << '\n';
            }
        }else{
            // C
            vector<set<array<LL, 2>>> anss(n), maxs(n);
            vector<unordered_map<int, LL>> anss_id(n), maxs_id(n);
            vector<int> deep(n), f(n);
            function<void(int, int)> dfs2 = [&](int u, int fa){
                f[u] = fa;
                int leave = true;
                for(auto &i : G[u]){
                    int v = edge[i][0] ^ edge[i][1] ^ u;
                    if (v == fa)
                        continue; 
                    leave = false;
                    deep[v] = deep[u] + 1;
                    dfs2(v, u); 
                    int d = edge[i][3] - edge[i][2];
 
                    LL ans_val = (*anss[v].rbegin())[0];
                    anss[u].insert({ans_val, v});
                    anss_id[u][v] = ans_val;
 
 
                    LL maxs_val = (*maxs[v].rbegin())[0] + d;
                    maxs[u].insert({maxs_val, v});
                    maxs_id[u][v] = maxs_val;
                }             
                anss[u].insert({0, -1});
                maxs[u].insert({0, -1});
 
                if (maxs[u].size() > 1){
                    auto c1 = maxs[u].rbegin();
                    auto c2 = next(c1);
                    anss[u].insert({(*c1)[0] + (*c2)[0], -2});
                    anss_id[u][-2] = (*c1)[0] + (*c2)[0];
                }
            };
            dfs2(0, -1);
            for(int i = 0; i < m; ++ i){
                int x, y;
                cin >> x >> y;
                -- x;
                edge[x][2] = y;
                int d = edge[x][3] - edge[x][2];
                ans = 0;
                int cur = (deep[edge[x][0]] < deep[edge[x][1]] ? edge[x][0] : edge[x][1]);
                int son = cur ^ edge[x][0] ^ edge[x][1];
                while(cur != -1){
                    maxs[cur].erase({maxs_id[cur][son], son});
                    maxs_id[cur][son] = (*maxs[son].rbegin())[0] + d;
                    maxs[cur].insert({maxs_id[cur][son], son});
 
                    anss[cur].erase({anss_id[cur][son], son});
                    anss_id[cur][son] = (*anss[son].rbegin())[0];
                    anss[cur].insert({anss_id[cur][son], son});
 
                    anss[cur].erase({anss_id[cur][-2], -2});
                    if (maxs[cur].size() > 1){
                        auto c1 = maxs[cur].rbegin();
                        auto c2 = next(c1);
                        anss_id[cur][-2] = (*c1)[0] + (*c2)[0];
                        anss[cur].insert({anss_id[cur][-2], -2});
                    }
 
                    son = cur;
                    cur = f[cur];
                }
                ans = max(0ll, (*anss[0].rbegin())[0]);
                
                cout << ans << '\n';
            }
 
        }
    }
    return 0;
}

运行结果：