1. Toy模板网首页
  2. > Toy博客

AtCoder Beginner Contest 327

8月前 作者：~Lanly~ 分类：Toy博客 阅读(34) 违法举报

这篇具有很好参考价值的文章主要介绍了AtCoder Beginner Contest 327。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

2023.11.08 update: 更新了G

A - ab (abc327 A)

题目大意

给定一个字符串\(s\)，问是否包含 ab或ba。

解题思路

遍历判断即可。

神奇的代码
#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 s;
    cin >> n >> s;
    bool ok = false;
    for (int i = 1; i < n; ++i) {
        ok |= (s[i] == 'a' && s[i - 1] == 'b');
        ok |= (s[i - 1] == 'a' && s[i] == 'b');
    }
    if (ok)
        cout << "Yes" << '\n';
    else
        cout << "No" << '\n';

    return 0;
}

B - A^A (abc327 B)

题目大意

给定\(b\)，问是否存在 \(a\)使得 \(a^a = b\)。

解题思路

由于指数爆炸的缘故，\(a\)的范围不会很大，枚举\(a\)，看\(b \% a\)是否为 \(0\)，然后用\(b\)不断除以 \(a\) ，看最后除的次数是否等于\(a\)。

神奇的代码
#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);
    LL b;
    cin >> b;
    int ans = -1;
    for (int i = 2; i <= 20; ++i) {
        if (b % i != 0)
            continue;
        LL x = b;
        int cnt = 0;
        while (x > 1) {
            x /= i;
            ++cnt;
        }
        if (cnt == i) {
            ans = i;
            break;
        }
    }
    if (b == 1)
        ans = 1;
    cout << ans << '\n';

    return 0;
}

C - Number Place (abc327 C)

题目大意

给定一个\(9 \times 9\)的网格，问是否符合数独局面。

数独局面，即每行 \(1-9\)，每列 \(1-9\)，每个 \(3 \times 3\)的格子有 \(1-9\)。

解题思路

按照条件，逐行、逐列、逐格子分别判断即可。

神奇的代码
#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);
    array<array<int, 9>, 9> a;
    for (auto& i : a)
        for (auto& j : i)
            cin >> j;
    auto ok = [&]() {
        for (auto& i : a) {
            if (set<int>(i.begin(), i.end()).size() != 9)
                return false;
        }
        for (int i = 0; i < 9; ++i) {
            set<int> cnt;
            for (int j = 0; j < 9; ++j) {
                cnt.insert(a[j][i]);
            }
            if (cnt.size() != 9)
                return false;
        }
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < 3; ++j) {
                set<int> cnt;
                for (int x = 0; x < 3; ++x)
                    for (int y = 0; y < 3; ++y) {
                        cnt.insert(a[i * 3 + x][j * 3 + y]);
                    }
                if (cnt.size() != 9)
                    return false;
            }
        }
        return true;
    };
    if (ok())
        cout << "Yes" << '\n';
    else
        cout << "No" << '\n';

    return 0;
}

D - Good Tuple Problem (abc327 D)

题目大意

给定两个数组长度为\(m\)，仅包含\(1-n\)的\(a,b\)，问它们是否是一对好数组。

若两个数组是一对好数组，则存在一个长度为\(n\)的\(01\)数组 \(x\)，使得 \(x_{a_i} \neq x_{b_i}, \forall i \in [1, m]\)。

解题思路

将条件抽象成图，相当于是点\(a_i\)和点\(b_i\)连一条边，它们的颜色不能相同。

即最后是否是一张二分图，黑白染色即可。

神奇的代码
#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(m), b(m);
    for (auto& i : a) {
        cin >> i;
        --i;
    }
    for (auto& i : b) {
        cin >> i;
        --i;
    }
    vector<vector<int>> edge(n);
    for (int i = 0; i < m; ++i) {
        edge[a[i]].push_back(b[i]);
        edge[b[i]].push_back(a[i]);
    }
    vector<int> col(n, -1);
    bool ok = true;
    auto BFS = [&](int st) {
        queue<int> team;
        team.push(st);
        col[st] = 0;
        while (!team.empty()) {
            int u = team.front();
            team.pop();
            int target = (col[u] ^ 1);
            for (auto& v : edge[u]) {
                if (col[v] == -1) {
                    col[v] = target;
                    team.push(v);
                } else if (col[v] != target) {
                    ok = false;
                    return;
                }
            }
        }
    };
    for (int i = 0; i < n && ok; ++i) {
        if (col[i] == -1)
            BFS(i);
    }
    if (ok)
        cout << "Yes" << '\n';
    else
        cout << "No" << '\n';

    return 0;
}

E - Maximize Rating (abc327 E)

题目大意

给定\(n\)场比赛的表现分\(p_i\)，现在选择一些场比赛，使得这些场比赛的 \(rating\)最大。

如果选择了 \(k\)场比赛 \((q_1, q_2, ..., q_k)\)，则 \(rating\)为

\[\frac{\sum_{i=1}^{k}(0.9)^{k-i}q_i}{\sum_{i=1}^{k}(0.9)^{k-i}} - \frac{1200}{\sqrt{k}} \]

注意这里的\(q\)要按照原来的顺序排列。

解题思路

枚举\(k\)，有几项就变成常数，唯一的变数就是最大化\(\sum_{i=1}^{k}(0.9)^{k-i}q_i\)，这其实就是个经典的背包问题。

设\(dp[i][j]\)表示前 \(i\)场比赛，我选择了\(j\)场的\(\sum_{i=1}^{k}(0.9)^{k-i}q_i\)的最大值。

转移就是考虑当前比赛选或不选，则\(dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] * 0.9 + p_i)\)

初始条件就是\(dp[0][0] = 0\)。

答案就是\(\max(\frac{dp[n][k]}{\sum_{i=1}^{k}(0.9)^{k-i}} - \frac{1200}{\sqrt{k}})\)

时间复杂度是\(O(n^2)\)

神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;

const double inf = numeric_limits<double>::max();

int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<double> dp(n + 1, -inf);
    dp[0] = 0;
    for (int i = 0; i < n; ++i) {
        vector<double> dp2 = dp;
        int p;
        cin >> p;
        for (int j = 1; j <= i + 1; ++j) {
            dp2[j] = max(dp2[j], dp[j - 1] * 0.9 + p);
        }
        dp2.swap(dp);
    }
    double ans = -inf;
    double bottom = 1;
    for (int i = 1; i <= n; ++i) {
        ans = max(ans, dp[i] / bottom - 1200 / sqrt(i));
        bottom = bottom * 0.9 + 1;
    }
    cout << fixed << setprecision(10) << ans << '\n';

    return 0;
}

F - Apples (abc327 F)

题目大意

二维平面，给定若干个点，问一个长宽为\(d \times w\)的矩形所能覆盖的点的数量的最大值。

解题思路

枚举一个维度\(i\)（时间），问题就是在\([i, i + d)\)的范围内的另一维度（地点）的宽度为\(w\)的点数的最大值。

设数组\(a[i]\)表示 \(sum[i, i + w)\)，即当前时间范围内的一个区间的点数，随着时间的流逝，会有新的点加入，会有旧的点删去。其影响的都是一个长度为 \(w\)的\(a\)区间，用线段树维护这个数组 \(a\)即可。

时间复杂度为\(O(n\log n)\)

神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;

const int N = 2e5 + 8;

class segtree {
#define lson (root << 1)
#define rson (root << 1 | 1)

    int max[N << 2], lazy[N << 2];

    inline void pushdown(int root) {
        if (lazy[root]) {
            lazy[lson] += lazy[root];
            max[lson] += lazy[root];
            lazy[rson] += lazy[root];
            max[rson] += lazy[root];
            lazy[root] = 0;
        }
    }

    void update(int root, int l, int r, int L, int R, LL val) {
        if (L <= l && r <= R) {
            lazy[root] += val;
            max[root] += val;
            return;
        }
        pushdown(root);
        int mid = (l + r) >> 1;
        if (L <= mid)
            update(lson, l, mid, L, R, val);
        if (R > mid)
            update(rson, mid + 1, r, L, R, val);
        max[root] = std::max(max[lson], max[rson]);
    }

    int query(int root, int l, int r) { return max[root]; }

  public:
    int n;
    void update(int L, int R, LL val) { update(1, 1, n, L, R, val); }

    int query() { return query(1, 1, n); }
};

int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n, d, w;
    cin >> n >> d >> w;
    vector<array<int, 2>> apple(n);
    for (auto& i : apple)
        cin >> i[0] >> i[1];
    vector<int> id(n);
    iota(id.begin(), id.end(), 0);
    ranges::sort(id, [&](int a, int b) { return apple[a][0] < apple[b][0]; });
    segtree seg;
    seg.n = N - 8;
    auto it = id.begin();
    int ans = 0;
    for (auto& i : id) {
        while (it != id.end() && apple[*it][0] + d <= apple[i][0]) {
            seg.update(max(1, apple[*it][1] - w + 1), apple[*it][1], -1);
            it = next(it);
        }
        seg.update(max(1, apple[i][1] - w + 1), apple[i][1], 1);
        ans = max(ans, seg.query());
    }
    cout << ans << '\n';

    return 0;
}

G - Many Good Tuple Problems (abc327 G)

题目大意

若两个数组是一对好数组，则存在一个长度为\(n\)的\(01\)数组 \(x\)，使得 \(x_{a_i} \neq x_{b_i}, \forall i \in [1, m]\)。

问所有的长度为\(m\)，仅包含 \(1-n\)的共 \(n^{2m}\)对数组中，好数组的数量。

解题思路

注意到一对数组是好数组，我们将每一位的数字连一条边，这意味着它们所形成的图是一张二分图。

考虑对这个二分图计数。

首先这个二分图会有重边，我们将重边都看成一条边，即设\(f[i][j]\)表示 \(i\)个点 \(j\)条边的简单二分图的方案数。

它跟答案之间差了个常数\(x_{m,j}\)——将\(m\)条相互区分的边分配到这 \(j\)个相互区分的边集合，且每个集合不为空的方案数。

注意到第二类斯特林数\(s(i,j)\)表示将 \(i\)个相互区分的球放到 \(j\)个互不区分的盒子的方案数， 则有\(x_{i,j} = s(i,j) \times j!\)。不过其实它可以通过二项式反演得到：设\(y_{m,i}\)意义类似\(x_{m,i}\)，但集合可以为空，有\(y_{m,i} = i^m = \sum_{j=0}^{i}\binom{i}{j}x_{m,j}\)，根据二项式反演即得

\[\begin{aligned} x_{m,i}&=\sum\limits_{j=0}^{i}(-1)^{i-j}\binom{i}{j}y_{m,j} \\ &=\sum\limits_{j=0}^{i}(-1)^{i-j}\binom{i}{j}j^m \\ &=\sum\limits_{j=0}^{i}\frac{i!(-1)^{i-j}j^m }{j!(i-j)!} \end{aligned} \]

这样我们可以在\(O(n^4\log m)\)求出 \(x_{m,i}\)。

注意到一条边\((u,v)\)，我们可以让 \(s_i = u, t_i = v\)，也可以 \(s_i = v, t_i = u\)，因此有两种构造数组的方式，所有还有个 \(2^m\)的系数。

由此 \(ans = \sum_{i=1}^{maxL}2^m f[n][i] \times x(m, i)\)，其中\(maxL\)表示可能的最大的边数，显然是左右点数均分，为\(\lfloor \frac{n}{2} \rfloor \times \lceil \frac{n}{2} \rceil\)

以下考虑如何求\(f[i][j]\)。

注意到二分图是可以将点分成左右两部分，由此可以枚举左边部分点（白色点）的数量\(k\)，注意到点标号不影响结果，因此方案数有 \(i \choose k\)。

然后考虑连边情况，每一条边都是从左边\(k\)个点选一个点，右边 \(i-k\)个点选一个点，然后连边，因此方案数是\(k(n-k) \choose j\)。

但思考会发现上述结果并不是\(f[i][j]\)，注意到一个比较显然的情况，连边并不保证二分图联通，可能会有单独的一个点。在上述方案计算中，我们会分别考虑该点处于左边（染成了白色）和右边的情况，而在 \(f[i][j]\)表示的情况中，应当只考虑一次。进一步的，对于一个有\(k\)个连通块的合法二分图，它对于 \(f[i][j]\)的贡献是 \(1\)，但上述结果计算得来的贡献是 \(2^k\)，因为每个二分图的染色方案有两种。

我们记上述的结果为 \(h[i][j]\)，即 \(i\)个点\(j\)条边的二分图的染色的方案数。注意到上述算重的因素是连通块个数，但从\(h[i][j]\)中难以知晓连通块个数的信息，难以从 \(h[i][j]\)中得到 \(f[i][j]\)。

怎么办呢，注意到关键还是连通块个数的问题，转换需要一个桥梁。我们设\(g[i][j]\)表示 \(i\)个点 \(j\)条边的连通的二分图的染色的方案数。即连通块数为\(1\)的方案数。

\(h\)和 \(g\)的区别仅仅是连通块个数的问题，可以通过容斥得到\(g[i][j]\)。

考虑从\(h[i][j]\)减去不合法的情况，即 \(1\)号点（其实是标号最小的点，\(1\)号点方便理解）的连通块个数不是 \(i\)的情况，通过枚举其点数和边数以及点的标号情况，有\(g[i][j] = h[i][j] - \sum_{k=1}^{i}\sum_{l=0}^{j}\)\(i - 1 \choose k - 1\)\(g[k][l] h[i-k][j-l]\)

\(g[i][j]\)是一个连通块的染色方案数，那二分图的方案数就是 \(\frac{g[i][j]}{2}\)。即设 \(a[i][j] = \frac{g[i][j]}{2}\)表示 \(i\)个点 \(j\)条边的连通的二分图的方案数。

\(a\)和 \(f\)的区别仅仅是连通块个数的问题，同 \(h\)和 \(g\)的关系，可以通过容斥得到 \(f[i][j]\)。

同样考虑枚举\(1\)号点所在连通块的点数、边数和点的标号的情况，有\(f[i][j] = \sum_{k=1}^{i}\sum_{l=0}^{j}\)\(i-1 \choose k-1\)\(a[k][l] f[i-k][j-l]\)

由此得到\(f[i][j]\)，就能得到答案了。

综上，我们设

  • \(f\)表示二分图的方案数
  • \(a\)表示连通二分图的方案数
  • \(h\)表示二分图染色的方案数
  • \(g\)表示连通二分图染色的方案数

然后\(h\)通过枚举染白色的点数量很轻易地求出，由于染色和二分图之间存在关于连通块个数的关系， 需要一个连通（连通块个数为\(1\)）作为桥梁，通过 \(h \to g \to a \to f\)。

  • \(h[i][j] = \sum_{k=0}^{i}\binom{i}{k}\binom{k(i-k)}{j}\)
  • \(g[i][j] = h[i][j] - \sum_{k=1}^{i}\sum_{l=0}^{j}\)\(i - 1 \choose k - 1\)\(g[k][l] h[i-k][j-l]\)
  • \(a[i][j] = \frac{g[i][j]}{2}\)
  • \(f[i][j] = \sum_{k=1}^{i}\sum_{l=0}^{j}\)\(i-1 \choose k-1\)\(a[k][l] f[i-k][j-l]\)

注意初值条件\(f[0][0] = 1\)。

最后再通过一个组合数得到\(ans = \sum_{i=1}^{maxL}2^m f[n][i] \times x_{m, i}\)

其中\(x_{m,i} = \sum_{j=0}^{i}(-1)^{i-j}\binom{i}{j}j^m\)表示将\(m\)个相互区分的球放到 \(i\)个相互区分的盒子，且每个盒子非空的方案数。

总的时间复杂度是\(O(n^6 + n^4\log m)\)文章来源地址https://www.toymoban.com/news/detail-741843.html

神奇的代码
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define FOR(i, x, y)                                                           \
    for (decay<decltype(y)>::type i = (x), _##i = (y); i < _##i; ++i)
#define FORD(i, x, y)                                                          \
    for (decay<decltype(x)>::type i = (x), _##i = (y); i > _##i; --i)

const int mo = 998244353;
const int M = 1e3;

LL bin(LL x, LL n, LL MOD) {
    LL ret = MOD != 1;
    for (x %= MOD; n; n >>= 1, x = x * x % MOD)
        if (n & 1)
            ret = ret * x % MOD;
    return ret;
}
inline LL get_inv(LL x, LL p) { return bin(x, p - 2, p); }

LL invf[M], fac[M] = {1};
void fac_inv_init(LL n, LL p) {
    FOR(i, 1, n)
    fac[i] = i * fac[i - 1] % p;
    invf[n - 1] = bin(fac[n - 1], p - 2, p);
    FORD(i, n - 2, -1)
    invf[i] = invf[i + 1] * (i + 1) % p;
}

inline LL C(LL n, LL m) { // n >= m >= 0
    return n < m || m < 0 ? 0 : fac[n] * invf[m] % mo * invf[n - m] % mo;
}

int main(void) {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    fac_inv_init(M, mo);
    int n, m;
    cin >> n >> m;
    int maxL = n / 2 * (n + 1) / 2;
    vector<vector<int>> h(n + 1, vector<int>(maxL + 1, 0));
    for (int i = 1; i <= n; ++i)
        for (int j = 0; j <= maxL; ++j)
            for (int k = 0; k <= i; ++k) {
                h[i][j] += C(i, k) * C(k * (i - k), j) % mo;
                if (h[i][j] >= mo)
                    h[i][j] -= mo;
            }

    vector<vector<int>> g(n + 1, vector<int>(maxL + 1, 0));
    for (int i = 1; i <= n; ++i)
        for (int j = 0; j <= maxL; ++j) {
            g[i][j] = h[i][j];
            for (int k = 1; k <= i; ++k)
                for (int l = 0; l <= j; ++l) {
                    g[i][j] -=
                        C(i - 1, k - 1) * g[k][l] % mo * h[i - k][j - l] % mo;
                    if (g[i][j] < 0)
                        g[i][j] += mo;
                }
        }

    vector<vector<int>> a(n + 1, vector<int>(maxL + 1, 0));
    int inv2 = get_inv(2, mo);
    for (int i = 1; i <= n; ++i)
        for (int j = 0; j <= maxL; ++j) {
            a[i][j] = 1ll * g[i][j] * inv2 % mo;
        }

    vector<vector<int>> f(n + 1, vector<int>(maxL + 1, 0));
    f[0][0] = 1;
    for (int i = 1; i <= n; ++i)
        for (int j = 0; j <= maxL; ++j)
            for (int k = 1; k <= i; ++k)
                for (int l = 0; l <= j; ++l) {
                    f[i][j] +=
                        C(i - 1, k - 1) * a[k][l] % mo * f[i - k][j - l] % mo;
                    if (f[i][j] >= mo)
                        f[i][j] -= mo;
                }

    vector<int> mm(maxL + 1);
    for (int i = 0; i <= maxL; ++i)
        mm[i] = bin(i, m, mo);

    vector<int> x(maxL + 1);
    for (int i = 0; i <= maxL; ++i) {
        int sig = 1 - 2 * (i & 1);
        for (int j = 0; j <= i; ++j) {
            x[i] = (x[i] + C(i, j) * mm[j] % mo * sig) % mo;
            if (x[i] < 0)
                x[i] += mo;
            sig *= -1;
        }
    }

    int ans = 0;
    int p2 = bin(2, m, mo);
    for (int i = 1; i <= maxL; ++i) {
        ans += 1ll * p2 * f[n][i] % mo * x[i] % mo;
        if (ans >= mo)
            ans -= mo;
    }
    cout << ans << '\n';

    return 0;
}

到了这里，关于AtCoder Beginner Contest 327的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Atcoder Begginer Contest 327 讲解（A~E题）

    Atcoder Begginer Contest 327 讲解（A~E题）

    Problem Statement You are given a string S S S of length N N N consisting of lowercase English letters. If there are any adjacent occurrences of a and b in S S S , print Yes ; otherwise, print No . (The order of a and b does not matter.) 问题陈述 给你一个长度为 N N N 的字符串 S S S ，由小写英文字母组成。 如果在 S S S 中出现相邻

    2024年02月05日
    浏览(50)

  • AtCoder Beginner Contest 318

    咕咕咕，总力战还没打，凹不过卷狗，躺了.jpg 给定 (n, m, p) ，问有多少个 (i) 满足 (0 m+pi leq n) 减去初始的 (m) ，剩下的就是看 (p) 的倍数个数。 神奇的代码 一个二维空间，有 (n) 个矩形覆盖。 问有多大的空间被覆盖了。重复覆盖算一次。 空间大小只有 (100) ，矩形

    2024年02月10日
    浏览(31)

  • AtCoder Beginner Contest 322

    给定一个字符串，找到最先出现 ABC 的位置。 直接查找判断即可。 神奇的代码 给定字符串 s 和 t ，问 s 是不是 t 的前缀和后缀。 根据前后缀定义判断即可。这里试了下 python 神奇的代码 (n) 天，有 (m) 天会放烟花。 问每一天，距离未来最近的放烟花的天数。 两个双指针一

    2024年02月08日
    浏览(21)

  • AtCoder Beginner Contest 336

    给定一个数 (n) ，将 long 中的 o 重复 (n) 次后输出。 模拟即可。 神奇的代码 给定一个数 (n) ，问 (n) 的二进制表示下的末尾零的数量。 即找到最小的 (i) 使得 (n (1 i)) 不为零的位置。枚举即可。 或者直接用内置函数 __builtin_ctz 。（count tail zero? 神奇的代码 定义一个数

    2024年01月20日
    浏览(32)

  • AtCoder Beginner Contest 326

    100楼层，一次可以上最多两层，或下最多三层。 给定两楼层，问能否一次到达。 比较大小，然后判断其差是是不是在 (2) 或 (3) 内即可。 神奇的代码 给定一个 (n) ，问不小于 (n) 的形如 (326) 的数字是多少。 形如 (326) 的数字，即数位有 (3) ，且百位 (times) 十位

    2024年02月08日
    浏览(23)

  • AtCoder Beginner Contest 349

    (n) 个人游戏，每局有一人 (+1) 分，有一人 (-1) 分。 给定最后前 (n-1) 个人的分数，问第 (n) 个人的分数。 零和游戏，所有人总分是 (0) ，因此最后一个人的分数就是前 (n-1) 个人的分数和的相反数。 神奇的代码 对于一个字符串，如果对于所有 (i geq 1) ，都有恰好

    2024年04月13日
    浏览(47)

  • AtCoder Beginner Contest 341

    给定 (n) ，输出 (n) 个 (0) 和 (n+1) 个 (1) 交替的字符串。 (101010...) 循环输出即可。 神奇的代码 货币兑换。 (A) 国货币每 (x_a) 钱可兑换 (B) 国货币 (y_a) 钱。 (B) 国货币每 (x_b) 钱可兑换 (C) 国货币 (y_b) 钱。 ... 给定你拥有的每国货币钱数和兑换规则，依次兑换

    2024年02月19日
    浏览(20)

  • AtCoder Beginner Contest 314

    怎么好多陌生单词 审核怎么这么逆天，半小时还没审完 给定 (pi) 的值以及数 (n) ，要求保留 (n) 位小数输出，不四舍五入。 字符串形式储存然后截取末尾即可。 神奇的代码 (n) 个人玩轮盘赌游戏，简单说就是一个转盘有 (37) 个数字以及一个箭头，箭头会等概率停在某

    2024年02月13日
    浏览(29)

  • AtCoder Beginner Contest 309

    感觉F写了个乱搞做法 给定一个 (3 times 3) 的网格，以及两个数字。 问这两个数字是否 水平相邻 。 求出两个数字的横纵坐标，看是否横坐标相同，纵坐标差一即可。 读题不仔细，开题就WA了。 神奇的代码 给定一个矩形。将最外围的数字顺时针旋转一格。 可以模拟一个指针

    2024年02月13日
    浏览(25)

  • AtCoder Beginner Contest 313

    貌似这次很难，还好去吃烧烤了 发现原来G就是个类欧几里德算法，参考abc283 ex，更了个G 给定 (n) 个数 (a_i) ，问第一个数要成为唯一的最大的数，应该加多少。 找到后面的最大的数 (m) ，答案就是 (max(0, m + 1 - a_0)) 。 神奇的代码 给定 (m) 条关于 (n) 个数的大小关系，

    2024年02月14日
    浏览(29)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包