AtCoder Beginner Contest 326

A - 2UP3DOWN (abc326 A)

题目大意

100楼层，一次可以上最多两层，或下最多三层。

给定两楼层，问能否一次到达。

解题思路

比较大小，然后判断其差是是不是在$2$或 $3$内即可。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int x, y;
    cin >> x >> y;
    if (x > y && x - y <= 3)
        cout << "Yes" << '\n';
    else if (x <= y && y - x <= 2)
        cout << "Yes" << '\n';
    else
        cout << "No" << '\n';
 
    return 0;
}
 

---

B - 326-like Numbers (abc326 B)

题目大意

给定一个$n$，问不小于 $n$的形如 $326$的数字是多少。

形如 $326$的数字，即数位有 $3$，且百位 $\times$十位 $=$个位。

解题思路

只有$1000$个数，枚举判断即可。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    auto is_326 = [](int x) {
        auto s = to_string(x);
        return (s[0] - '0') * (s[1] - '0') == (s[2] - '0');
    };
    while (!is_326(n))
        ++n;
    cout << n << '\n';
 
    return 0;
}
 

---

C - Peak (abc326 C)

题目大意

给定一维数轴上的$n$个礼物点，问长度为$M$的左闭右开的区间最多有多少个点。

解题思路

注意到最好情况下，其区间的左端点一定是礼物点。

因此我们可以枚举左端点所在的礼物点，然后看看到右端点时包含了多少个礼物。这个可以先对礼物点排序然后二分找到右端点礼物，作差得到数量。

当然也可以双指针。

ranges::的用法是c++20的特性。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, m;
    cin >> n >> m;
    vector<int> a(n);
    for (auto& i : a)
        cin >> i;
    ranges::sort(a);
    int ans = 0;
    for (int i = 0; i < n; ++i) {
        ans = max(ans, int(ranges::lower_bound(a, a[i] + m) - a.begin() - i));
    }
    cout << ans << '\n';
 
    return 0;
}
 

---

D - ABC Puzzle (abc326 D)

题目大意

给定两个仅包含ABC的长度为$n$的串$a,b$，要求构造一个$n \times n$的矩阵，要求：

• 每行每列包含恰好一个ABC
• 每行最左边的字母组成字符串$a$
• 每列最顶部的字母组成字符串$a$

解题思路

因为$n$只有 $5$，考虑朴素搜索。

每行ABC的排列情况只有$5 \times 4 \times 3 = 60$种， $5$行的总情况为 $60^5 = 7e9$，但如果中间剪枝的话其合法情况数远远小于该数。

具体来说，考虑当前位置 $(x,y)$放什么，我们需要第 $x$行的放置情况 $row[x]$，第 $y$列的放置情况 $col[y]$，以决定该位置能否放该字母（代码里是二进制压缩的状态）。还需要 $left[x]$表示第 $x$行的是否放过字母，以决定是否和字符串 $a$比较，同理也需要 $top[y]$表示第 $y$列是否放过字母，以决定是否和字符串 $b$比较。这里的剪枝可以减去大部份合法情况。

在考虑完一行后，可以看看 $row[x]$是否放了ABC三个字母，没放满则直接剪枝。

感觉写的很复杂。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    string a, b;
    cin >> n >> a >> b;
    vector<vector<int>> ans(n, vector<int>(n, -1));
    vector<int> top(n, 1);
    vector<int> left(n, 1);
    vector<int> row(n);
    vector<int> col(n);
    auto not_have = [&](int x, int y) { return ((~x >> y) & 1); };
    function<bool(int, int)> dfs = [&](int x, int y) {
        if (x == n) {
            for (auto& i : row)
                if (i != 7)
                    return false;
            for (auto& i : col)
                if (i != 7)
                    return false;
            return true;
        }
 
        for (int i = 0; i < 3; ++i) {
            if (not_have(row[x], i) && not_have(col[y], i)) {
                if (top[y] && b[y] - 'A' != i)
                    continue;
                if (left[x] && a[x] - 'A' != i)
                    continue;
                row[x] |= (1 << i);
                col[y] |= (1 << i);
                ans[x][y] = i;
 
                int ttop = top[y], lleft = left[x];
                top[y] = 0;
                left[x] = 0;
                if (y == n - 1) {
                    if (row[x] == 7 && dfs(x + 1, 0))
                        return true;
                } else {
                    if (dfs(x, y + 1))
                        return true;
                }
                row[x] ^= (1 << i);
                col[y] ^= (1 << i);
                ans[x][y] = -1;
                top[y] = ttop;
                left[x] = lleft;
            }
        }
 
        if (y == n - 1) {
            if (row[x] != 7)
                return false;
 
            if (dfs(x + 1, 0))
                return true;
        } else {
            if (dfs(x, y + 1))
                return true;
        }
 
        return false;
    };
    if (dfs(0, 0)) {
        cout << "Yes" << '\n';
        for (auto& i : ans) {
            for (auto& j : i) {
                if (j == -1)
                    cout << '.';
                else
                    cout << char(j + 'A');
            }
            cout << '\n';
        }
    } else
        cout << "No" << '\n';
 
    return 0;
}
 

---

E - Revenge of "The Salary of AtCoder Inc." (abc326 E)

题目大意

给定包含$n$个数字的数组 $a$，以及一个等概率的 $n$面骰子。进行以下游戏：

初始$x=0$，投掷一次骰子，得到 $y$

• 如果$x < y$，则获得 $a_y$元，同时令 $x=y$
• 否则游戏结束

问期望获得的钱数。

解题思路

期望题，根据定义，一个状态的期望，它是所有后继状态的期望的加权平均，这里的权重是概率。

当前状态是$x$，则设$dp[x]$表示当前掷出的值为 $x$，继续游戏至游戏结束，这期间获得的期望钱数。

很显然初始条件 $dp[n] = 0$，即 $x=n$时，无论怎么骰，始终有 $y \leq n$，游戏总是会结束。

考虑一般情况，当前状态是$x$，考虑投掷一次骰子的后继状态：

• 有$\frac{x}{n}$的概率投掷出$y \leq x$，此时游戏结束，后继状态的期望收入为 $0$。
• 有$\frac{1}{n}$的概率投掷出$y = x + 1$，此时进入后继状态$dp[x+1]$，获得收益$a_{x+1}$
• 有$\frac{1}{n}$的概率投掷出$y = x + 2$，此时进入后继状态$dp[x+2]$，获得收益$a_{x+2}$
• 有$\frac{1}{n}$的概率投掷出$y = x + 3$，此时进入后继状态$dp[x+3]$，获得收益$a_{x+3}$
• ...
• 有$\frac{1}{n}$的概率投掷出$y = n$，此时进入后继状态$dp[n]$，获得收益$a_{n}$

由此可以写出转移式子：

$$dp[x] = \frac{x}{n} \times 0 + \sum_{i=x+1}^{n}\frac{1}{n} (dp[i] + a[i]) = \frac{1}{n}\sum_{i=x+1}^{n}(dp[i] + a[i])$$

这是一个后缀和，求$dp$的时候维护一下就可以了。观察到$dp$数组和后缀和的关系，代码里直接把$dp$数组省掉了。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
const int mo = 998244353;
 
long long qpower(long long a, long long b) {
    long long qwq = 1;
    while (b) {
        if (b & 1)
            qwq = qwq * a % mo;
        a = a * a % mo;
        b >>= 1;
    }
    return qwq;
}
 
long long inv(long long x) { return qpower(x, mo - 2); }
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<int> a(n);
    for (auto& i : a)
        cin >> i;
    int presum = 0, invn = inv(n);
    for (int i = n - 1; i >= 0; --i) {
        presum = (0ll + presum + 1ll * presum * invn % mo + a[i]) % mo;
    }
    cout << 1ll * presum * invn % mo << '\n';
 
    return 0;
}
 

---

F - Robot Rotation (abc326 F)

题目大意

二维平面，机器人初始 $(0,0)$，面向$x$轴正方向。给定$n$次移动的距离数组$d$，每次移动前，你需要指定机器人顺时针或逆时针转 $90$度，随后移动。

问能否移动到达目标点 $(x,y)$，能移动到则给出一个可行的旋转序列。

解题思路

注意到$n$只有$80$，且每次必须旋转机器人，这意味着机器人有一半是上下移动，一半是左右移动，最多 $40$次。

横纵坐标的移动我们是可以分开考虑的，因此我们就分别考虑横坐标移动的 $40$次操作和纵坐标移动的 $40$次操作。

而操作，事实上就是决定移动距离的正负性。注意到 $40$其实是个很微妙的性质，它的一半 $20$是可以承受指数的复杂度的。即采用折半搜索的策略。

即对于这 $40$次操作，我们要对它们赋予正负号，看它们的和能否成为 目标移动距离$x$(或 $y$)。

我们可以分别对前$20$个数和后$20个数$，花 $O(2^{20})$枚举它们的正负号，记录它们的和。

然后再把这两部份的结果合并：能否从左右两边的结果各挑一个数，它们的和$=x$。这是一个非常简单的子问题，对两边排序后一个双指针就可以解决了。这里的时间复杂度是 $O(2^{20} \log)$。

分别对$x,y$方向进行一次折半搜索，就可以搜到结果了。

由于要输出方案，因此我们得记录该结果的每一项的正负号，下面代码是通过二进制压缩的形式记录的，最后还要通过每一项的正负号，以及当前机器人的朝向决定向左向右转。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, x, y;
    cin >> n >> x >> y;
    array<vector<int>, 2> a;
    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        a[i & 1].push_back(x);
    }
    auto dfs = [&](auto self, const vector<int>& a, int pos, int sum, int sol,
                   int l, int r, vector<array<int, 2>>& tmp) {
        if (pos + l == r) {
            tmp.push_back({sum, sol});
            return;
        }
        self(self, a, pos + 1, sum + a[pos + l], sol, l, r, tmp);
        self(self, a, pos + 1, sum - a[pos + l], (sol | (1 << pos)), l, r, tmp);
    };
    auto solve = [&](const vector<int>& a, int val) {
        int mid = a.size() / 2;
        vector<array<int, 2>> l, r;
        dfs(dfs, a, 0, 0, 0, 0, mid, l);
        dfs(dfs, a, 0, 0, 0, mid, a.size(), r);
        vector<int> lid(l.size()), rid(r.size());
        iota(lid.begin(), lid.end(), 0);
        iota(rid.begin(), rid.end(), 0);
        ranges::sort(lid, [&](int x, int y) { return l[x][0] < l[y][0]; });
        ranges::sort(rid, [&](int x, int y) { return r[x][0] > r[y][0]; });
        auto lp = lid.begin(), rp = rid.begin();
        while (lp != lid.end() && rp != rid.end()) {
            if (l[*lp][0] + r[*rp][0] == val) {
                return l[*lp][1] + ((1ll * r[*rp][1]) << mid);
            } else if (l[*lp][0] + r[*rp][0] < val) {
                lp = next(lp);
            } else if (l[*lp][0] + r[*rp][0] > val) {
                rp = next(rp);
            }
        }
        return -1ll;
    };
    auto dy = solve(a[0], y); // 0 => +, 1 => -
    auto dx = solve(a[1], x);
    if (dy == -1 || dx == -1)
        cout << "No" << '\n';
    else {
        cout << "Yes" << '\n';
        vector<int> ans;
        for (int i = 0; i <= n / 2; ++i) {
            ans.push_back((dy >> i) & 1);
            if (i < n / 2)
                ans.push_back((dx >> i) & 1);
        }
        int dir = 0;
        for (int i = 0; i < n; ++i) {
            cout << "LR"[ans[i] ^ dir ^ (i & 1)];
            dir = ans[i];
        }
        cout << '\n';
 
    }
 
    return 0;
}
 

---

G - Unlock Achievement (abc326 G)

题目大意

给定$n$个技能和 $m$个成就。对于第 $i$个技能，升一级花费 $c_i$。

达成第 $i$个成就， 有$a_i$的奖励，达成条件为，对于每个技能要达到指定等级或以上。

问最大的收益，即奖励$-$花费的最大值。

解题思路

考虑只有一个技能和一个成就，那我们选择是否完成这个成就，就看其技能升级的成本和成就的奖励的大小。

当考虑多个一个技能和多个成就时，成本和奖励之间的衡量就没那么单纯：我可能完成了一个成就，而当我升级一次技能，又能立刻完成另一个成就——即不用从零等级技能考虑。这种有泛泛的，复杂关系决策的，网络流可能会比较在行。

成就只有达成与未达成两种状态，而技能有5种状态，但如果根据完成成就的条件——某技能等级于x或以上，将技能拆分成这$5$种情况，那么这些情况同样也只有 达成与未达成两种状态。

接下来要做的就是规定每个成就和每个技能状态，是达成或不达成，其中会有一些代价，这种二分类问题的最小化代价，可以转换成最小割问题。而最小割的问题可以转换成最大流求解。

考虑一张图，有源点$S$和汇点$T$，其余点就是上述所说的状态，即每个成就表示成一个点，每个技能拆分成5个点，分别表示该技能等级达到i级或以上。

一个割会将这张图分成两部分，一部分与$S$相连，一部分与$T$相连。可以规定与$S$相连的点表示状态 未达成，与$T$相连的点表示达成。

由于最小割是最小化代价，而成就奖励要最大化，这里需要转换一下，先假设完成了所有成就，那我们的决策就是决定成就是否不完成，即最小化未达成成就的代价。

考虑如何连边以及边权（容量）设定，注意到网络流里，当一条边的容量满了，意味着这条边被割去了，即不与$S$（或 $T$）相连，换句话说边权就是不成为某一类的代价。

对于成就这一状态，它不成为达成状态的代价就是a_i，即如果我选择不达成该成就，即与$T$的边断开，则我将失去其奖励 $a_i$。因此每个成就与汇点$T$连一条容量为 $a_i$的边。

对于 技能，它有5个状态，（以下等级1表示技能等级达到1或以上）除了等级1状态外，源点$S$与其他状态 连一条容量为$c_i$的边，即升级一次的代价。比如 等级2状态，我花费$c_i$升级一次至等级 $2$，那该状态就是 达成的，它不成为未达成这一状态了。

当然这里需要避免一种情况，就是等级3达成了，但等级2未达成。我们需要从等级2连一条边到等级3，其容量为无穷大。这样子，尽管$S \to 3 \to ... \to T$的边割去了，还存在 $S \to 2 \to 3 \to ... \to T$ 的路径，要割去这条路径，只能把$S \to 2$也割去，这样子 等级2也达成了。因为$2 \to 3$是无穷大的，所以这条边不会被割去，它只能割$S \to 2$，因为其代价更小。这意味着技能等级之间的依赖关系不能被割去。

还有一种避免的情况就是，成就要求的技能等级都达成了，但成就未达成，这需要连一条从对应的技能状态到该成就的容量为 无穷大的边，这意味着技能和成就之间的关系不能被割去。

建好图后，跑一遍最大流得最小割，用成就总奖励减去最小割即为答案。

神奇的代码

#include <bits/stdc++.h>
using namespace std;
using LL = long long;
 
template <typename T> class flow_graph {
  public:
    static constexpr T eps = (T)1e-9;
 
    struct edge {
        int from;
        int to;
        T c;
        T f;
    };
 
    vector<vector<int>> g;
    vector<edge> edges;
    int n;
    int st;
    int fin;
    T flow;
 
    flow_graph(int _n, int _st, int _fin) : n(_n), st(_st), fin(_fin) {
        assert(0 <= st && st < n && 0 <= fin && fin < n && st != fin);
        g.resize(n);
        flow = 0;
    }
 
    void clear_flow() {
        for (const edge& e : edges) {
            e.f = 0;
        }
        flow = 0;
    }
 
    int add(int from, int to, T forward_cap, T backward_cap) {
        assert(0 <= from && from < n && 0 <= to && to < n);
        int id = (int)edges.size();
        g[from].push_back(id);
        edges.push_back({from, to, forward_cap, 0});
        g[to].push_back(id + 1);
        edges.push_back({to, from, backward_cap, 0});
        return id;
    }
};
 
template <typename T> class dinic {
  public:
    flow_graph<T>& g;
 
    vector<int> ptr;
    vector<int> d;
    vector<int> q;
 
    dinic(flow_graph<T>& _g) : g(_g) {
        ptr.resize(g.n);
        d.resize(g.n);
        q.resize(g.n);
    }
 
    bool expath() {
        fill(d.begin(), d.end(), -1);
        q[0] = g.fin;
        d[g.fin] = 0;
        int beg = 0, end = 1;
        while (beg < end) {
            int i = q[beg++];
            for (int id : g.g[i]) {
                const auto& e = g.edges[id];
                const auto& back = g.edges[id ^ 1];
                if (back.c - back.f > g.eps && d[e.to] == -1) {
                    d[e.to] = d[i] + 1;
                    if (e.to == g.st) {
                        return true;
                    }
                    q[end++] = e.to;
                }
            }
        }
        return false;
    }
 
    T dfs(int v, T w) {
        if (v == g.fin) {
            return w;
        }
        int& j = ptr[v];
        while (j >= 0) {
            int id = g.g[v][j];
            const auto& e = g.edges[id];
            if (e.c - e.f > g.eps && d[e.to] == d[v] - 1) {
                T t = dfs(e.to, min(e.c - e.f, w));
                if (t > g.eps) {
                    g.edges[id].f += t;
                    g.edges[id ^ 1].f -= t;
                    return t;
                }
            }
            j--;
        }
        return 0;
    }
 
    T max_flow() {
        while (expath()) {
            for (int i = 0; i < g.n; i++) {
                ptr[i] = (int)g.g[i].size() - 1;
            }
            T big_add = 0;
            while (true) {
                T add = dfs(g.st, numeric_limits<T>::max());
                if (add <= g.eps) {
                    break;
                }
                big_add += add;
            }
            if (big_add <= g.eps) {
                break;
            }
            g.flow += big_add;
        }
        return g.flow;
    }
 
    vector<int> min_cut() {
        max_flow();
        vector<int> ret(g.n);
        for (int i = 0; i < g.n; i++) {
            ret[i] = (d[i] != -1);
        }
        return ret;
    }
};
 
const int inf = 1e9 + 7;
 
int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, m;
    cin >> n >> m;
    vector<int> c(n), a(m);
    for (auto& i : c)
        cin >> i;
    for (auto& i : a)
        cin >> i;
    int st = 0, pst = st + 1, ast = pst + n * 5, ed = ast + m, num = ed + 1;
    flow_graph<int> g(num, st, ed);
    for (int i = 0; i < n; ++i) {
        int l = i * 5, r = l + 5;
        for (int j = l; j < r; ++j) {
            int pj = pst + j;
            if (j == l) {
                g.add(pj, ed, inf, 0);
            } else {
                g.add(st, pj, c[i], 0);
                g.add(pj - 1, pj, inf, 0);
            }
        }
    }
    for (int i = 0; i < m; ++i) {
        int ai = ast + i;
        g.add(ai, ed, a[i], 0);
    }
    for (int i = 0; i < m; ++i)
        for (int j = 0; j < n; ++j) {
            int x;
            cin >> x;
            --x;
            int ai = ast + i, pj = pst + j * 5 + x;
            g.add(pj, ai, inf, 0);
        }
    dinic solver(g);
    int ans = accumulate(a.begin(), a.end(), 0) - solver.max_flow();
    cout << ans << '\n';
 
    return 0;
}
 

---