补题链接：Here

A - Takoyaki

很容易看出 \(\frac{N + X - 1}{X} \times T\)

B - Multiple of 9

给定一个很大的整数，问其是否是 \(9\) 的倍数

累加各个位数，然后判断取余结果

C - Step

给定一个数组，每次操作可以给一个数增加 \(1\) ，问最少多少次操作可以将数组变为不下降序列？

贪心地将当前数字加大到左边的最大值即可，如果当前数字大于最大值，则更新最大值。

D - Wizard in Maze

题意：有一个巫师在迷宫中，要从起点到终点。有两种走法：一是直接沿着路走，二是使用魔法，跳到以当前格子为中心的 \(5\times5\) 方阵中任意一个没有障碍的格子上。问最少用几次魔法，可以到终点？如果无解，输出 \(−1\)。

思路：经典 01 BFS，沿着路走的代价为 \(0\)，而使用魔法的代价为 \(1\)。使用标准的 0-1BFS，也即双端队列来处理即可。

#include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int inf  = 0x3f3f3f3f;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
int h, w, sx, sy, ex, ey;
int main() {
    ios_base::sync_with_stdio(false), cin.tie(0);
    cin >> h >> w >> sx >> sy >> ex >> ey;
    sx--, sy--, ex--, ey--;
    vector<string> a(h);
    for (int i = 0; i < h; ++i) cin >> a[i];
    vector<vector<int>> dist(h, vector<int>(w, inf));
    vector<vector<bool>> vis(h, vector<bool>(w, false));
    deque<pair<int, int>> q;
    q.push_back({sx, sy});
    dist[sx][sy] = 0;
    while (q.size()) {
        auto f = q.front();
        q.pop_front();
        int ci = f.first, cj = f.second;
        if (ci == ex && cj == ey) {
            cout << dist[ci][cj] << "\n";
            return 0;
        }
        if (vis[ci][cj]) continue;
        vis[ci][cj] = true;
        for (int k = 0; k < 4; ++k) {
            int ni = ci + dy[k], nj = cj + dx[k];
            if (ni < 0 || ni >= h || nj < 0 || nj >= w ||
                dist[ni][nj] <= dist[ci][cj] || a[ni][nj] == '#')
                continue;
            dist[ni][nj] = dist[ci][cj];
            q.push_front({ni, nj});
        }
        for (int ni = ci - 2; ni <= ci + 2; ++ni)
            for (int nj = cj - 2; nj <= cj + 2; ++nj) {
                if (ni < 0 || ni >= h || nj < 0 || nj >= w || a[ni][nj] == '#' ||
                    dist[ni][nj] <= dist[ci][cj] + 1)
                    continue;
                dist[ni][nj] = dist[ci][cj] + 1;
                q.push_back({ni, nj});
            }
    }
    cout << -1 << "\n";
    return 0;
}

E - Bomber

有一个 \(H\times W\) 的大方阵，其中若干位置有目标物。可以设置一个炮台，炮台可以攻击同一行和同一列的所有目标。问炮台最多能攻击多少个目标？

思路：\(1 \le H,W\le 3e5\) 可想而知暴力会 TLE，

我们可以在读入的时候就维护好每行每列的目标个数，然后找到最大值的行列（可能有多个）

然后一次遍历这些点。

注意可能刚好炮塔落点的位置上有目标，然后就会重复计算一次

// Murabito-B 21/04/07
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main() {
    ios_base::sync_with_stdio(false), cin.tie(0);
    int h, w, m;
    cin >> h >> w >> m;
    vector<int> hc(h + 1), wc(w + 1);
    vector<pair<int, int>> p(m);
    for (int i = 0; i < m; ++i) {
        cin >> p[i].first >> p[i].second;
        hc[p[i].first]++, wc[p[i].second]++;
    }
    int hm = *max_element(hc.begin(), hc.end());
    int wm = *max_element(wc.begin(), wc.end());
    vector<int> vh, vw;
    for (int i = 1; i <= h; ++i)
        if (hc[i] == hm) vh.emplace_back(i);
    for (int i = 1; i <= w; ++i)
        if (wc[i] == wm) vw.emplace_back(i);
    int sh = vh.size(), sw = vw.size();
    if (sh * sw > m) {
        cout << hm + wm;
        return 0;
    }
    set<pair<int, int>> s(p.begin(), p.end());
    for (int i : vh)
        for (int j : vw)
            if (!s.count({i, j})) {
                cout << hm + wm;
                return 0;
            }
    cout << hm + wm - 1;
    return 0;
}

F - Brave CHAIN

待补。。。