CCF-CSP认证考试 202403-4 十滴水 100分题解

更多 CSP 认证考试题目题解可以前往：CSP-CCF 认证考试真题题解

---

原题链接： 202403-4 十滴水

时间限制： 3.0 秒
空间限制： 512 MiB

题目描述

十滴水是一个非常经典的小游戏。

小 C 正在玩一个一维版本的十滴水游戏。我们通过一个例子描述游戏的基本规则。

游戏在一个 $1\times c$ 的网格上进行，格子用整数 $x(1\le x\le c)$ 编号，编号从左往右依次递增。网格内 $m$ 个格子里有 $1\sim 4$ 滴水，其余格子里没有水。在我们的例子中，$c=m=5$，按照编号顺序，每个格子中分别有 $2,4,4,4,2$ 滴水。

玩家可以进行若干次操作，每次操作中，玩家选择一个有水的格子，将格子的水滴数加一。任何时刻若某个格子的水滴数大于等于 555，这个格子里的水滴就会向两侧爆开。此时，这个格子的水被清空，同时对于左方、右方两个方向同时进行以下操作：找到当前格子在对应方向上最近的有水的格子，如果存在这样的格子，将这个格子的水滴数加一。若在某个时刻，有多个格子的水滴数大于等于 $5$，则最靠左的先爆开。

在我们的例子中，若玩家对第三格进行操作，则其水滴数变为 $5$，故第三格水滴爆开，水被清空，其左侧最近的有水格子（第二格）和右侧最近的有水格子（第四格）的水量增加 $1$，此时每个格子中分别有 $2,5,0,5,2$ 滴水。

此时第二格和第四格的水滴数均大于等于 $5$，按照规则，第二格的水先爆开，爆开后每个格子中分别有 $3,0,0,6,2$ 滴水；最后第四格的水滴爆开，每个格子中分别有 $4,0,0,0,3$ 滴水。

小 C 开始了一局游戏并进行了 $n$ 次操作。小 C 在每次操作后，会等到所有水滴数大于等于 $5$ 的格子里的水滴都爆开再进行下一次操作。

小 C 想知道他的水平有多高，于是他想知道每一次操作后还有多少格子里有水。

保证这 $n$ 次操作都是合法的，即每次操作时操作的格子里都有水。

输入格式

从标准输入读入数据。

输入的第一行三个整数 $c,m,n$ 分别表示网格宽度、有水的格子个数以及操作次数。

接下来 $m$ 行每行两个整数 $x,w$，表示第 $x$ 格有 $w$ 滴水。

接下来 $n$ 行每行一个整数 $p$，表示小 C 对第 $p$ 格做了一次操作。

输出格式

输出到标准输出。

输出 $n$ 行，每行一个整数表示这次操作之后网格上有水的格子数量。

样例1输入

5 5 2
1 2
2 4
3 4
4 4
5 2
3
1

样例1输出

2
1

子任务

对于所有测试数据，

• $1\le c\le 10^9$，$1\le m\le \min (c,3\times 10^5)$，$1\le n\le 4m$；
• $1\le x,p\le c$，$1\le w\le 4$；
• 输入的所有 $x$ 两两不同；
• 对于每个输入的 $p$，保证在对应操作时 $p$ 内有水。

子任务编号	$c\le$	$m\le$	特殊性质	分值
1	$30$	$30$	有	15
2	$3,000$	$3,000$	有	15
3	$3,000$	$3,000$	无	10
4	$10^9$	$3,000$	无	15
5	$3\times 10^5$	$3\times 10^5$	无	15
6	$10^9$	$3\times 10^5$	有	15
7	$10^9$	$3\times 10^5$	无	15

特殊性质：在游戏的任意时刻（包括水滴爆开的连锁反应过程中），只有至多一个格子的水滴数大于等于 $5$。

---

题解

由于 $c$ 很大，直接开数组的话会炸内存，使用 std::map 来进行存储。

对于一次操作：如果没有爆开，就将对应的格子的水滴数 $+1$；如果成功爆开，那么当前位置的水滴数清零，左右两侧最靠近该点的有水的格子的水滴数 $+1$。

考虑连锁反应，对于每一个要爆开的格子，先将其放进小根堆中（有多个格子的水滴数大于等于 $5$ 时，最靠左的先爆开）。每次取小根堆的堆顶元素，从 std::map 中删除该格子，将左右两侧最靠近该点的有水的格子的水滴数 $+1$，并判断是否到达了 $5$ 滴水，到达了就继续放进小根堆中。重复执行到小根堆变空即可。

时间复杂度：$\mathcal{O}((m+n)\log m)$。

参考代码

/*
    Created by Pujx on 2024/5/8.
*/
#pragma GCC optimize(2, 3, "Ofast", "inline")
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
//#define int long long
//#define double long double
using i64 = long long;
using ui64 = unsigned long long;
using i128 = __int128;
#define inf (int)0x3f3f3f3f3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define yn(x) cout << (x ? "yes" : "no") << endl
#define Yn(x) cout << (x ? "Yes" : "No") << endl
#define YN(x) cout << (x ? "YES" : "NO") << endl
#define mem(x, i) memset(x, i, sizeof(x))
#define cinarr(a, n) for (int _ = 1; _ <= n; _++) cin >> a[_]
#define cinstl(a) for (auto& _ : a) cin >> _
#define coutarr(a, n) for (int _ = 1; _ <= n; _++) cout << a[_] << " \n"[_ == n]
#define coutstl(a) for (const auto& _ : a) cout << _ << ' '; cout << endl
#define all(x) (x).begin(), (x).end()
#define md(x) (((x) % mod + mod) % mod)
#define ls (s << 1)
#define rs (s << 1 | 1)
#define ft first
#define se second
#define pii pair<int, int>
#ifdef DEBUG
    #include "debug.h"
#else
    #define dbg(...) void(0)
#endif

const int N = 2e5 + 5;
//const int M = 1e5 + 5;
const int mod = 998244353;
//const int mod = 1e9 + 7;
//template <typename T> T ksm(T a, i64 b) { T ans = 1; for (; b; a = 1ll * a * a, b >>= 1) if (b & 1) ans = 1ll * ans * a; return ans; }
//template <typename T> T ksm(T a, i64 b, T m = mod) { T ans = 1; for (; b; a = 1ll * a * a % m, b >>= 1) if (b & 1) ans = 1ll * ans * a % m; return ans; }

int a[N];
int n, m, t, k, q;

void work() {
    map<int, int> mp;
    cin >> n >> m >> k;
    for (int i = 1; i <= m; i++) {
        int x, w;
        cin >> x >> w;
        mp[x] = w;
    }
    priority_queue<int, vector<int>, greater<int>> pq;
    for (int i = 1; i <= k; i++) {
        int p; cin >> p;
        mp[p]++;
        if (mp[p] == 5) pq.push(p);
        while (!pq.empty()) {
            int u = pq.top(); pq.pop();
            mp.erase(u);
            auto it = mp.lower_bound(u);
            if (it != mp.begin()) {
                (--it)->second++;
                if (it->second == 5) pq.push(it->first);
            }
            it = mp.upper_bound(u);
            if (it != mp.end()) {
                it->second++;
                if (it->second == 5) pq.push(it->first);
            }
        }
        cout << mp.size() << endl;
    }
}

signed main() {
#ifdef LOCAL
    freopen("C:\\Users\\admin\\CLionProjects\\Practice\\data.in", "r", stdin);
    freopen("C:\\Users\\admin\\CLionProjects\\Practice\\data.out", "w", stdout);
#endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int Case = 1;
    //cin >> Case;
    while (Case--) work();
    return 0;
}
/*
     _____   _   _       _  __    __
    |  _  \ | | | |     | | \ \  / /
    | |_| | | | | |     | |  \ \/ /
    |  ___/ | | | |  _  | |   }  {
    | |     | |_| | | |_| |  / /\ \
    |_|     \_____/ \_____/ /_/  \_\
*/

关于代码的亿点点说明：

1. 代码的主体部分位于 void work() 函数中，另外会有部分变量申明、结构体定义、函数定义在上方。
2. #pragma ... 是用来开启 O2、O3 等优化加快代码速度。
3. 中间一大堆 #define ... 是我习惯上的一些宏定义，用来加快代码编写的速度。
4. "debug.h" 头文件是我用于调试输出的代码，没有这个头文件也可以正常运行（前提是没定义 DEBUG 宏），在程序中如果看到 dbg(...) 是我中途调试的输出的语句，可能没删干净，但是没有提交上去没有任何影响。
5. ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); 这三句话是用于解除流同步，加快输入 cin 输出 cout 速度（这个输入输出流的速度很慢）。在小数据量无所谓，但是在比较大的读入时建议加这句话，避免读入输出超时。如果记不下来可以换用 scanf 和 printf，但使用了这句话后，cin 和 scanf、cout 和 printf 不能混用。
6. 将 main 函数和 work 函数分开写纯属个人习惯，主要是为了多组数据。