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

AtCoder Beginner Contest 327

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

这篇具有很好参考价值的文章主要介绍了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日
    浏览(58)

  • AtCoder Beginner Contest 310

    感觉F又双叒叕写复杂了 点杯咖啡，要 (p) 元，但可以用一个优惠券，使得咖啡只要 (q) 元，但你需要额外购买 (n) 个商品中（价格为 (a_i) ）的一个。 问点杯咖啡的最小价格。 考虑直接买还是使用优惠券，使用优惠券的话就选 (n) 个商品中价格最小的。 两种情况取最小

    2024年02月16日
    浏览(28)

  • AtCoder Beginner Contest 320

    给定 (a,b) ，输出 (a^b + b^a) 。 因为数不超过 (10) ，可以直接用 pow 计算然后转成 (int) 。不会有精度损失。 神奇的代码 给定一个字符串 (s) ，求长度最长的回文串。 因为长度只有 (100) ，可以直接枚举子串，然后暴力判断是不是回文串（翻转后是否和自身相同），复杂

    2024年02月08日
    浏览(38)

  • AtCoder Beginner Contest 348

    给定 (n) ，输出 (ooxooxoox...) ，长度为 (n) 。 按题意模拟即可。 神奇的代码 给定 (n) 个点，对每个点，求出与其距离最远的点的下标。 (n) 只有 (100) ，对于每个点，花 (O(n)) 遍历每个点最大化距离，时间复杂度为 (O(n^2)) 。 神奇的代码 (n) 个豌豆，每个豌豆有美味值

    2024年04月08日
    浏览(42)

  • AtCoder Beginner Contest 302

    给定怪物的血量 (a) 和你每次攻击扣除的血量 (b) ，问打多少次怪物才会死。 答案即为 (lceil frac{a}{b} rceil = lfloor frac{a + b - 1}{b} rfloor) 神奇的代码 给定一个二维网格，格子上有字母，找到一连串位置，使得其字符串为 (snuke) ，要求这一连串位置俩俩相邻，即有共边或

    2024年02月05日
    浏览(78)

  • AtCoder Beginner Contest 304

    依次给定每个人的姓名和年龄，排成一圈。从年龄最小的人依次输出姓名。 找到年龄最小的，依次输出就好了。 神奇的代码 给定一个数字，如果其超过三位数，则仅保留其最高三位，低位数字全部置为0。 读一个 string ，直接赋值即可。 神奇的代码 给定 (n) 个人的坐标，第

    2024年02月07日
    浏览(39)

  • AtCoder Beginner Contest 329

    劳累一天不该写题，启发式合并都写错了 给定一个字符串，将每个字符输出出来，中间留个空格。 遍历输出即可。 神奇的代码 给定一个数组，找出次大的数。 遍历一下，从非最大的数求一个最大值即可。 神奇的代码 给定一个字符串，问有多少个连续的子串，其由一个字母

    2024年02月05日
    浏览(75)

  • AtCoder Beginner Contest 339

    给一个网址，问它的后缀是多少。 找到最后的\\\'.\\\'的位置，然后输出后面的字符串即可。 python 可以一行。 神奇的代码 二维网格，上下左右相连，左上原点。初始全部为白色，位于原点，面朝上。 进行 (n) 次操作，每次操作，将当前格子颜色黑白反转，然后 如果原来是白色

    2024年02月19日
    浏览(31)

  • AtCoder Beginner Contest 340

    给定等差数列的 首项 、 末项 、 公差 。 输出这个等差数列。 从 首相 依次累加 公差 到 末项 即可。 神奇的代码 依次进行 (Q) 次操作，分两种。 1 x ，将 x 放到数组 (a) 的末尾。 2 k ，输出数组 (a) 的倒数第 (k) 项。 用 vector 模拟即可，操作 2 可快速寻址访问。 神奇的代

    2024年02月19日
    浏览(33)

  • AtCoder Beginner Contest 314

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

    2024年02月13日
    浏览(40)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包