AtCoder Beginner Contest 365 A~E

最新推荐文章于 2025-11-21 17:34:35 发布

原创最新推荐文章于 2025-11-21 17:34:35 发布 · 593 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#ACM-ICPC #OI #c++ #算法 #atcoder

AtCoder 专栏收录该内容

62 篇文章

订阅专栏

A.Leap Year（思维）

题意：

给你一个介于 $1583$ 和 $2023$ 之间的整数 $Y$ 。

求公历 $Y$ 年的天数。

在给定的范围内， $Y$ 年的天数如下：

如果 $Y$ 不是 $4$ 的倍数，则为 $365$ 天；
如果 $Y$ 是 $4$ 的倍数，但不是 $100$ 的倍数，则为 $366$ 天；
如果 $Y$ 是 $100$ 的倍数，但不是 $400$ 的倍数，则为 $365$ 天；
如果 $Y$ 是 $400$ 的倍数，则为 $366$ 天。

分析：

判断年份是否为闰年。

如果 $n$ 不能被 $4$ 整除，那么不是闰年。
如果 $n$ 可以被 $400$ 整除，那么是闰年。
如果 $n$ 不可以被 $100$ 整除但是可以被 $4$ 整除，那么是闰年。

否则就不是闰年。使用if-else语句判断即可。

代码：

#include<bits/stdc++.h>

using namespace std;

int main() {
    int n;
    cin >> n;
    if (n % 4 != 0) {
        cout << 365 << endl;
    } else if (n % 400 == 0) {
        cout << 366 << endl;
    } else if ((n % 100 != 0) && n % 4 == 0) {
        cout << 366 << endl;
    } else {
        cout << 365 << endl;
    }
    return 0;
}

B.Second Best（模拟）

题意：

给你一个长度为 $N$ 的整数序列 $A=(A1,…,AN)A=(A_1,\ldots,A_N)$ 。这里的 $A1,A2,…,ANA_1,A_2,\ldots,A_N$ 都是不同的。

在 $A$ 中，哪个元素是第二大元素？

分析：

按照题意，使用map、pair或结构体对元素进行排序即可。

代码：

#include<bits/stdc++.h>

using namespace std;
const int N = 1000100;

struct s {
    int x, id;

    bool operator<(const s &r) const {
        return x > r.x;
    }
} a[N];

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i].x;
        a[i].id = i;
    }
    sort(a + 1, a + n + 1);
    cout << a[2].id << endl;
    return 0;
}

C.Transportation Expenses（二分答案）

题意：

有 $N$ 人参加一项活动，第 $i$ 个人的交通费用是 $A_i$ 日元。

活动组织者高桥决定设定交通补贴的最高限额为 $x$ 。第 $i$ 个人的补贴为 $min(x,A_i)$ 日元。这里， $x$ 必须是一个非负整数。

高桥的预算为 $M$ 日元，他希望所有 $N$ 人的交通补贴总额最多为 $M$ 日元，那么补贴限额 $x$ 的最大可能值是多少？

如果补贴限额可以无限大，输出infinite。

分析：

本题我们分情况讨论，首先考虑答案为无限大的情况。对于这种情况可以先计算序列的总和和 $M$ 比较，如果这个都小于等于 $M$ ，那么肯定答案是无穷大。

对于不是无穷大的情况，考虑尝试枚举一个 $x$ ，然后对于每一个 $x$ 判断是否满足题目条件，然后记录最大的 $x$ ，时间复杂度 $O (NM)$ 。

对 $x$ 的枚举我们采用二分，然后来判断，题目要求 $x$ 的最大值，可以发现若此时的 $x$ 为最大，那么对于每一个 $k≤xk\le x$ 都可以满足题条件，而对于每一个 $k≥xk\ge x$ 都不能满足题目条件，满足单调性。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const int N = 200005;
LL n, m, a[N], ans = -1e17;

bool check(LL x) {
    LL res = 0;
    for (int i = 1; i <= n; i++)
        res += min(a[i], x);
    return (res <= m);
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    if (check(1e17)) {
        cout << "infinite" << endl;
        return 0;
    }
    LL l = 0, r = m;
    while (l <= r) {
        LL mid = (l + r) >> 1;
        if (check(mid)) {
            ans = mid;
            l = mid + 1;
        } else
            r = mid - 1;
    }
    cout << ans << endl;
    return 0;
}

D.AtCoder Janken 3（动态规划）

题意：

高桥和青木玩了 $N$ 次剪刀石头布。注：在这个游戏中，石头赢剪刀，剪刀赢布，布赢石头。

青木的动作由长度为 $N$ 的字符串 $S$ 表示，字符串由"R"、"P"和"S"组成。 $S$ 中的第 $i$ 个字符表示青木在第 $i$ 个对局中的出招：“R"表示"石头”，“P"表示"布”，“S"表示"剪刀”。

高桥的出招满足以下条件：

高桥从未输给过青木。
对于 $i=1,2,…,N−1i=1,2,\ldots,N-1$ ，高桥在第 $i$ 场对局中的出招与他在第 $(i + 1)$ 场对局中的出招不同。

确定高桥可能赢得的最大对局数。

可以保证存在一个满足上述条件的高桥出招顺序。

分析：

因为相邻两场对局出招不同，发现之前的对局存在后效性，考虑动态规划。

设 $dp_{i,[0/1/2]}$ 表示当前为第i场对局，当前出的拳是 $R, P, S$ ，最多可以赢多少局。

特殊计算一下 $dp_{1,[0/1/2]}$ ， $dp_{i,j}$ 的值可以通过 $dp_{i-1,k}$ 转移来当且仅当 $k≠jk\neq j$ ，对于会输的出招直接赋值为一个极小值，取一个最大值然后增加对答案的贡献即可。

代码：

#include<bits/stdc++.h>

using namespace std;
const int N = 1000100;
const int MIN_INF = -2e9;
int n;
int dp[N][3];

int main() {
    cin >> n;
    string s;
    cin >> s;
    s = ' ' + s;
    if (s[1] == 'R') {
        dp[1][0] = 0;
        dp[1][1] = 1;
        dp[1][2] = MIN_INF;
    } else if (s[1] == 'P') {
        dp[1][0] = MIN_INF;
        dp[1][1] = 0;
        dp[1][2] = 1;
    } else {
        dp[1][0] = 1;
        dp[1][1] = MIN_INF;
        dp[1][2] = 0;
    }
    for (int i = 2; i <= n; ++i) {
        if (s[i] == 'R') {
            dp[i][0] = max({dp[i - 1][1], dp[i - 1][2]});
            dp[i][1] = max({dp[i - 1][0], dp[i - 1][2]}) + 1;
            dp[i][2] = MIN_INF;
        } else if (s[i] == 'P') {
            dp[i][0] = MIN_INF;
            dp[i][1] = max({dp[i - 1][0], dp[i - 1][2]});
            dp[i][2] = max({dp[i - 1][0], dp[i - 1][1]}) + 1;
        } else {
            dp[i][0] = max({dp[i - 1][1], dp[i - 1][2]}) + 1;
            dp[i][1] = MIN_INF;
            dp[i][2] = max({dp[i - 1][0], dp[i - 1][1]});
        }
    }
    cout << max({dp[n][0], dp[n][1], dp[n][2]}) << endl;
    return 0;
}

E.Xor Sigma Problem（数学）

题意：

给你一个长度为 $N$ 的整数序列 $A=(A1,…,AN)A=(A_1,\ldots,A_N)$ 。求以下表达式的值：

$∑i=1N−1∑j=i+1N(Ai⊕Ai+1⊕…⊕Aj)\displaystyle\sum_{i=1}^{N-1}\sum_{j=i+1}^N(A_i\oplus A_{i+1}\oplus\ldots\oplus A_j)$

分析：

看到异或我们考虑拆位计算答案。设当前枚举到第 $k$ 位，这一位有 $i$ 个0， $j$ 个1，因为异或为 $1$ 要求两个异或的数互不相同，所以这一位对答案的贡献即为 $i×j×2ki\times j\times 2^k$ 。

将所有位对答案的贡献累加即可。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const int N = 200001;
LL a[N], s[N];

int main() {
    LL n;
    cin >> n;
    for (LL i = 1; i <= n; ++i) {
        cin >> a[i];
        s[i] = a[i];
        a[i] ^= a[i - 1];
    }
    LL res = 0;
    for (LL k = 0; k < 30; ++k) {
        LL cnt = 0;
        for (LL j = 0; j <= n; ++j)
            cnt += a[j] >> k & 1;
        res += cnt * (n - cnt + 1) * (1LL << k);
    }
    for (LL i = 1; i <= n; ++i)
        res -= s[i];
    cout << res << endl;
    return 0;
}