第36次 CCF CSP 计算机软件能力认证 题解（民间版）

目录

• 写在前面
• A 签到，模拟
• B 枚举
• C 模拟，STL
• D DP，单调性优化，最短路
  • DP
  • 赛时做法
• E 笛卡尔树，单调性，DP
• 写在最后

写在前面

你说得对，但是 I AK 36th CSP。

Update on 2024.12.13：代码已替换为赛时 AC 代码。

A 签到，模拟

直接模拟即可。

复制复制
#include <bits/stdc++.h>
#define LL long long
const int kN = 1e6 + 10;
std::map <char, int> ex;
std::map <char, int> ey;
//=============================================================
//=============================================================
//=============================================================
int main() {
    std::ios::sync_with_stdio(0); std::cin.tie(0), std::cout.tie(0);
    ex['l'] = -1, ex['r'] = 1;
    ey['f'] = 1, ey['b'] = -1;
 
    int n, k; std::cin >> n >> k;
    while (k --) {
        int x, y; std::cin >> x >> y;
        std::string s; std::cin >> s;
        for (auto ch: s) {
            int nx = x + ex[ch], ny = y + ey[ch];
            if (nx >= 1 && nx <= n && ny >= 1 && ny <= n) x = nx, y = ny;
        }   
        std::cout << x << " " << y << "\n";
    }
    
    return 0;
}
/*
3 2
1 1 ffrrbbll
3 3 frbl
*/

B 枚举

先不考虑修改操作，记初始时能量的最小值为 $w$，则若 $w$ 合法，显然到达第 $i(0\le i\le n)$ 个位置后，当前的能量将变为：

$$w +(- a_0 + b_1) +(- a_1 + b_2) + \cdots + (-a_{i - 1} + b_i)$$

考虑每次从位置 $i$ 向下一个位置移动时，需要保证当前能量不小于 $a_{i}$，则 $w$ 合法当且仅当满足如下限制：

$$\forall 0\le i\le n,\ \left(w - \sum_{j=0}^{i - 1}a_i + \sum_{j=1}^{i} b_j \right)\ge a_{i}$$

移个项，则可得到 $w$ 的值：

$$w= \max_{0\le i\le n} \left( \sum_{j=0}^{i} a_j - \sum_{j=1}^{i} b_j\right)$$

考虑预处理 $c_i = \sum\limits_{j=0}^{i} a_j - \sum\limits_{j=1}^{i} b_j$，则 $\max c_i$ 即为答案。

然后考虑修改操作对 $c_i$，的影响。考虑代入上式，容易发现修改 $b_p:=0$ 后，$c_0\sim c_{p - 1}$ 不受影响，$c_{p}\sim c_{n}$ 全部加上 $b_{p}$，即有：

$$w(p) = \max\left( \max_{0\le i\le p - 1} c_i, b_p + \max_{p\le i\le n} c_i \right)$$

发现 $\max_{0\le i\le p-1}$ 即 $c_i$ 的前缀最大值，$\max_{p\le i\le n}$ 即 $c_i$ 的后缀最大值，于是考虑预处理 $c_i$ 的前后缀最大值即可根据上式求得所有答案。

总时间复杂度 $O(n)$ 级别。

#include <bits/stdc++.h>
#define LL long long
const int kN = 1e5 + 10;
const int kInf = 1e9;
//=============================================================
int n, a[kN], b[kN], ans[kN];
int c[kN], premax[kN], sufmax[kN];
//=============================================================
//=============================================================
int main() {
    std::ios::sync_with_stdio(0); std::cin.tie(0), std::cout.tie(0);
    std::cin >> n;
    for (int i = 1; i <= n + 1; ++ i) std::cin >> a[i];
    for (int i = 1; i <= n; ++ i) std::cin >> b[i];
 
    premax[0] = sufmax[n + 2] = -kInf;
    for (int i = 1; i <= n + 1; ++ i) {
        c[i] = c[i - 1] + a[i] - b[i - 1];
        premax[i] = std::max(premax[i - 1], c[i]);
    }
    for (int i = n + 1; i; -- i) {
        sufmax[i] = std::max(sufmax[i + 1], c[i]);
    }
 
    for (int i = 1; i <= n; ++ i) {
        ans[i] = std::max(premax[i], sufmax[i + 1] + b[i]);
        std::cout << std::max(ans[i], 0) << " ";
    }
    return 0;
}
/*
3
5 5 5 5
0 100 0
 
3
9 4 6 2
9 4 6
 
*/

C 模拟，STL

会用 STL 就变得很简单的题。

某个内存块对应的缓存块是唯一的，则发现需要支持的操作本质上只有如下几种：

1. 查询某个内存块，是否在某个缓存块中；
2. 查询某个缓存块中，最早被操作的内存块；
3. 向缓存块中插入、删除内存块
4. 查询并修改：某个内存块的被操作时间；
5. 查询并修改：某个内存块是否被修改过且未保存；

操作 4,5 很容易通过 map 实现，开两个 map 分别维护每个内存块的最近操作时间以及是否被修改过即可；操作 1,2,3 很容易通过 set 实现，仅需对每个缓存块开两个 set：

• set<int>：存缓存块中所有内存块的编号；
• set <pair <int, int> > ：存缓存块中所有内存块的修改时间以及编号，其中 pair 的第一关键字为内存块修改时间，第二关键字为内存块编号。

则完成操作 1,2 仅需：

• 操作 1：调用 set.count() 查询某个内存块是否在对应的缓存块中即可；
• 操作 2：调用 set.begin() 查询缓存块中被操作时间最小的内存块即可；
• 操作 3，4：直接在 set 中 insert 和 erase 即可。

单次操作时间复杂度 $O(\log n)$ 级别，总时间复杂度 $O(q\log n)$ 级别。

#include <bits/stdc++.h>
#define LL long long
#define pr std::pair
#define mp std::make_pair
const int kN = 1e5 + 10;
//=============================================================
int n, N, q, nowtime;
 
std::map<int, int> tim, modified;
std::set<int> have[kN];
std::set<pr <int, int> > lru[kN];
//=============================================================
void pop(int id_) {
    if (have[id_].size() < n) return ;
    auto it = lru[id_].begin();
    if (modified[it->second]) {
        std::cout << 1 << " " << it->second << "\n";
        modified[it->second] = 0;
    }
    have[id_].erase(it->second);
    lru[id_].erase(it);
}
void insert(int id_, int pos_) {
    have[id_].insert(pos_);
    tim[pos_] = nowtime;
    lru[id_].insert(mp(nowtime, pos_));
 
    std::cout << 0 << " " << pos_ << "\n";
}
void solve(int pos_) {
    ++ nowtime;
    int id = (pos_ / n) % N;
 
    if (have[id].count(pos_)) {
        lru[id].erase(lru[id].find(mp(tim[pos_], pos_)));
        tim[pos_] = nowtime;
        lru[id].insert(mp(nowtime, pos_));
        return ;
    }
 
    if (have[id].size() == n) pop(id);
    insert(id, pos_);
}
//=============================================================
int main() {
    std::ios::sync_with_stdio(0); std::cin.tie(0), std::cout.tie(0);
    std::cin >> n >> N >> q;
    while (q --) {
        int o, a; std::cin >> o >> a;
        solve(a);
        if (o == 1) modified[a] = 1;
    }
    return 0;
}
/*
4 8 8
0 0
0 1
1 2
0 1
1 0
0 32
1 33
0 34
*/

D DP，单调性优化，最短路

DP

考虑暴力 DP，设 $f_{i}$ 表示到达位置 $i$ 所需的最小步数，初始化 $f_{1} = 0$，则有显然的转移：

$$f_{i} + 1 \rightarrow f_{j} \left(j \in\left[i-a_i+1, i - \min(a_i + k_{i - a_i}, n) \right]\right)$$

答案即 $f_{n}$，然而发现上述转移成环了，即会导致某些状态的重复更新，无法直接做，于是寄。

但是容易发现，如果出现成环的转移，这些转移一定是不优的，步数一定不小于第一次更新该状态的步数，则容易发现关键的性质：

• 转移到 $f_j$ 的最优决策 $f_i$，一定满足 $i<j$；
• 进一步地发现 $f_i$ 一定是单调不降的；
• 则对于某个状态，能转移到它的最左侧的转移，一定是最优决策，即每个状态只会被转移一次。

于是考虑在 DP 时记 $R$ 为能转移到的最靠右的位置，然后枚举 $1\sim n$ 并考虑向后转移，每次仅转移位置大于 $R$ 的状态并更新 $R$ 即可。$R$ 至多增加 $n$ 次，转移次数至多为 $O(n)$ 级别，则总时间复杂度为 $O(n)$ 级别。

#include <bits/stdc++.h>
#define LL long long
const int kN = 2e5 + 10;
 
int n, a[kN], k[kN], f[kN];
 
int main() {
  std::ios::sync_with_stdio(0), std::cin.tie(0), std::cout.tie(0);
  std::cin >> n;
  for (int i = 1; i <= n; ++ i) std::cin >> a[i], f[i] = -1;
  for (int i = 1; i <= n; ++ i) std::cin >> k[i];
  
  int R = 1;
  f[1] = 0;
  for (int i = 1; i <= n; ++ i) {
    if (f[i] == -1) break;
 
    for (int j = std::max(R + 1, i - a[i] + 1); 
             j <= std::min(n, i - a[i] + k[i - a[i]]); 
            ++ j) {
      f[j] = f[i] + 1;
      R = j;
    }
  }
  
  std::cout << f[n] << "\n";
  return 0;
}

赛时做法

赛时的一个比较天才的最短路做法，考虑分层图最短路，建三层数量为 $n$ 的节点：

• 第一层：节点 $i$ 代表从位置 $i$ 出发；
• 第二层：节点 $i$ 代表到达位置 $i$；
• 第三层：用于描述每个位置向之后的位置的区间转移。

然后有如下连边：

• 第一层 $i$ 向第三层 $i+k_i$ 连边；
• 第二层 $i$ 向第一层 $i-a_i$ 连边；
• 第三层 $i$ 向第二层 $i$ 连边。
• 第三层 $i$ 向第三层 $i-1$ 连边；

求得第一层节点 1 到达第一层节点 $n$ 的最短路即为答案。

前两层点的正确性容易理解，为什么第三层每个点向前一个点连边，就能解决区间转移问题？同样考虑上述“每个位置仅会被更新一次”的单调性性质，则上述第三层转移仅会更新之前从未被到达过的位置，并不会更新被到达的位置的最短路。

上图中点和边数量均为 $O(n)$ 级别，Dijkstra 实现，总时间复杂度 $O(n\log n)$ 级别。

#include <bits/stdc++.h>
#define LL long long
#define pr std::pair
#define mp std::make_pair
const int kN = 3e5 + 10;
const int kInf = 1e9;
//=============================================================
int n, a[kN], k[kN], dis[kN];
bool vis[kN];
std::vector<pr <int, int> > edge[kN];
//=============================================================
//=============================================================
int main() {
    std::ios::sync_with_stdio(0); std::cin.tie(0), std::cout.tie(0);
    std::cin >> n;
    for (int i = 1; i <= n; ++ i) std::cin >> a[i];
    for (int i = 1; i <= n; ++ i) std::cin >> k[i];
 
    for (int i = 1; i <= n; ++ i) {
        edge[i].push_back(mp(2 * n + std::min(i + k[i], n), 1));
        edge[n + i].push_back(mp(i - a[i], 0));
        if (i > 1) edge[2 * n + i].push_back(mp(2 * n + i - 1, 0));
        edge[2 * n + i].push_back(mp(n + i, 0));
    }
    std::priority_queue <pr <int, int> > q;
    for (int i = 1; i <= 3 * n; ++ i) dis[i] = kInf, vis[i] = 0;
    q.push(mp(0, 1));
    dis[1] = 0;
 
    while (!q.empty()) {
        auto [d, u] = q.top(); q.pop();
        if (vis[u]) continue;
 
        for (auto [v, w]: edge[u]) {
            if (dis[v] > dis[u] + w) {
                dis[v] = dis[u] + w;
                q.push(mp(-dis[v], v));
            }
        }
    }
 
    std::cout << (dis[n] == kInf ? -1 : dis[n]) << "\n";
    return 0;
}
/*
10
0 1 1 1 1 3 1 0 3 0
2 4 5 4 1 4 1 3 5 3
 
5
0 1 2 3 0
3 4 4 10 15
*/

E 笛卡尔树，单调性，DP

想到笛卡尔树其实就秒了，但是要怎么才能想到呢？

发现 $q\le 20$ 太小了，$n\le 2\times 10^6$ 又太大了，猜测总时间复杂度是 $O(nq)$ 的，即每次询问实际上是完全独立的，都可以直接大力修改并套用 $O(n)$ 的解法。

考虑初始位置位于间隔 $(i - 1, i)$，记初始力量的最小值为 $w$，则显然有 $w\ge \min(a_{i - 1}, a_i)$，即保证至少打败相邻的怪物中较弱的。

考虑记该怪物左侧第一个 $a$ 大于它的怪物为 $L$，右侧第一个为 $R$，则打败该怪物后，力量将增加 $\sum_{L <j < R} b_j$，然后仅需再考虑如何打败 $L, R$ 这两个怪物中较弱的一个即可，则此时应有：$w + \sum_{L<j<R} b_j\ge \min(a_{L}, a_{R})$……不断重复上述过程，直至将所有怪物全部打败即可。

发现上述不断寻找“最近的最弱怪物，并增加力量”的过程，就是在笛卡尔树上，以相邻的较弱怪物为起点，不断跳父亲直至根，到达某个节点 $u$ 后获得的力量值即为子树 $u$ 中所有节点 $v$ 的 $\sum b_v$。记先后跳到的节点为 $u_1, u_2, \cdots, u_k$ 则若初始力量 $w(u_1)$ 合法，则有：

$$\begin{cases} w(u_1) \ge a_{u_1}\\ \forall 1\le i< k,\ w(u_1) + \sum_{v\in \operatorname{subtree}(u_i)} b_v \ge a_{\operatorname{fa}_{u_i}} \end{cases}$$

同样移项后，有：

$$w(u_1) = \max\left\{a_{u_1}, \max_{1\le i< k} \left(a_{\operatorname{fa}_{u_i}} - \sum_{v\in \operatorname{subtree}(u_i)} b_v\right) \right\}$$

建立笛卡尔树后，考虑进行两次 dfs，第一次 dfs 预处理 $\sum\limits_{v\in \operatorname{subtree}(u)} b_v$，第二次 dfs 预处理从笛卡尔树根到所有节点的上式即可。

求答案时考虑枚举所有相邻两个怪物，记两者中较弱怪物为起点 $u_1$，其答案即为 $w(u_1)$；对于多组询问，每组询问大力修改后独立处理即可，总时间复杂度 $O(nq)$ 级别。

#include <bits/stdc++.h>
#define LL long long
const int kN = 2e6 + 10;
const int kInf = 1e9 + 2077;
//=============================================================
int n, a[kN], b[kN], aa[kN], bb[kN];
LL sumb[kN], ans[kN];
int rt, son[kN][2], top, st[kN], fa[kN];
//=============================================================
void build() {
    st[top = 0] = 0;
    for (int i = 1; i <= n; ++ i) {
        while (top && aa[st[top]] < aa[i]) -- top;
        son[i][0] = son[st[top]][1], son[st[top]][1] = i;
        st[++ top] = i;
    }
    rt = st[1];
}
void dfs1(int u_, int fa_) {
    sumb[u_] = bb[u_];
    fa[u_] = fa_;
    if (son[u_][0]) dfs1(son[u_][0], u_), sumb[u_] += sumb[son[u_][0]];
    if (son[u_][1]) dfs1(son[u_][1], u_), sumb[u_] += sumb[son[u_][1]];
}
void dfs2(int u_, int fa_, LL maxd_) {
    ans[u_] = std::max(1ll * aa[u_], maxd_);
    
    if (son[u_][0]) dfs2(son[u_][0], u_, std::max(maxd_, 1ll * aa[u_] - sumb[son[u_][0]]));
    if (son[u_][1]) dfs2(son[u_][1], u_, std::max(maxd_, 1ll * aa[u_] - sumb[son[u_][1]]));
}
//=============================================================
int main() {
    std::ios::sync_with_stdio(0); std::cin.tie(0), std::cout.tie(0);
    std::cin >> n;
    a[0] = a[n + 1] = kInf;
    for (int i = 1; i <= n; ++ i) std::cin >> a[i];
    for (int i = 1; i <= n; ++ i) std::cin >> b[i];
 
    int q; std::cin >> q;
    while (q --) {
        int k; std::cin >> k;
        for (int i = 0; i <= n + 1; ++ i) {
            aa[i] = a[i], bb[i] = b[i], sumb[i] = 0;
            son[i][0] = son[i][1] = fa[i] = 0;
            ans[i] = 0;
        }
        while (k --) {
            int p, x, y; std::cin >> p >> x >> y;
            aa[p] = x, bb[p] = y;
        }
        build(), dfs1(rt, 0);
        dfs2(rt, 0, 0);
 
        LL out = 0;
        // for (int i = 1; i <= n; ++ i) std::cout << sumb[i] << " ";
        // for (int i = 1; i <= n; ++ i) std::cout << ans[i] << " ";
        for (int i = 2; i <= n; ++ i) {
            int p = (aa[i - 1] < aa[i] ? i - 1 : i);
            out ^= ans[p];
        }
        std::cout << out << "\n";
    }
    return 0;
}
/*
6
4 9 3 1 7 7
4 2 1 3 1 4
2
2
3 8 1
5 4 3
0
 
6
1 2 3 4 5 6
0 2 0 0 1 0
1
0
*/

写在最后

Update on 2024.12.13：代码已替换为赛时 AC 代码。

Update on 2025.01.26：稿子已提交，要上电视啦~

唉唉退役了什么也没学到了，直接进入夹带私货环节：