AtCoder Beginner Contest 358 A~G

原创已于 2024-06-20 09:54:13 修改 · 1k 阅读

13 ·

CC 4.0 BY-SA版权

文章标签：

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

于 2024-06-16 11:48:44 首次发布

AtCoder 专栏收录该内容

62 篇文章

订阅专栏

A.Welcome to AtCoder Land

题意

给出两个字符串 $S, T$ ，请你判断是否满足：

字符串 $S$ 为AtCoder
字符串 $T$ 为Land

分析

输入后判断即可

代码

#include<bits/stdc++.h>
using namespace std;
void solve() {
    string s, t;
    cin >> s >> t;
    if (s == "AtCoder" && t == "Land") {
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }
}
int main() {
    solve();
    return 0;
}

B.Ticket Counter(思维)

题意

有 $N$ 个人会进入会场买票，每个人买票均需要花费 $A$ 分钟，其中第 $i$ 个人会在 $T_i$ 时间到达，如果到达后前面的人还没买完票，就需要等待前面的人完成后继续，否则，可以直接开始买票。

问：每个人买票结束的时间是多少。

分析

由于保证了到达时间是有序的，那么可以依次遍历每个人，第 $i$ 个人的开始买票时间为第 $i - 1$ 个人的结束时间和第 $i$ 个人的到达时间中的较大值，那么结束时间即为开始时间加上花费的时间。

输出每个人买票结束的时间即可。

代码

#include<bits/stdc++.h>
using namespace std;
int t[105];
void solve() {
    int n, a;
    cin >> n >> a;
    int now = 0;
    for (int i = 1; i <= n; i++) {
        cin >> t[i];
        now = max(now, t[i]);
        now += a;
        cout << now << endl;
    }
}
int main() {
    solve();
    return 0;
}

C. Popcorn(二进制枚举)

题意

有 $N$ 种爆米花，爆米花总共有 $M$ 种味道，使用一个包含 $M$ 个字符的字符串 $S_i$ 表示第 $i$ 种爆米花拥有的味道，即使用 $S_{i, j} = 'o'$ 表示第 $i$ 种爆米花拥有 $j$ 味道，用 $S_{i, j} = 'x'$ 表示第 $i$ 种爆米花没有 $j$ 味道。

问：最少买几种爆米花，才能包含所有味道。

分析

观察数据可以发现， $\le 10$ ，那么数据量是非常小的，可以直接使用二进制枚举去枚举所有选择方案，记录包含所有味道中，选择爆米花种类最小的一个即为最后的答案。

代码

#include<bits/stdc++.h>
using namespace std;
string s[105];
int vis[15];
void solve() {
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < n; i++) {
        cin >> s[i];
    }
    int ans = n;
    for (int i = (1 << n) - 1; i >= 0; i--) {
        memset(vis, 0, sizeof (vis));
        int cnt = 0, sum = 0;
        for (int j = 0; j < n; j++) {
            if (i & (1 << j)) {
                cnt++;
                for (int k = 0; k < m; k++) {
                    if (s[j][k] == 'o') {
                        vis[k]++;
                        if (vis[k] == 1) sum++;
                    }
                }
            }
        }
        if (sum == m) {
            ans = min(ans, cnt);
        }
    }
    cout << ans << endl;
}
int main() {
    solve();
    return 0;
}

D.Souvenirs(贪心)

题意

有 $N$ 个糖果盒，第 $i$ 个盒子价格为 $A_i$ ，且包含 $A_i$ 颗糖果。

你需要买其中 $M$ 盒糖果，并把这些盒子送给你的朋友，送给第 $j$ 个朋友的盒子需要至少包含 $B_j$ 颗糖果。

如果能买到满足要求的 $M$ 盒糖果，输出最小的花费，如果不能，输出-1。

分析

首先一定要优先考虑给糖果需求大的选取盒子，那么该怎么选择最优呢，必然会去选择所有满足要求的盒子中 $\le A[i])$ ，价格最低的一个，对于这些盒子，可以使用优先队列维护所有价值大于等于 $B [j]$ 的糖果盒子，每次从优先队列取出最小的元素加到答案中，如果取不出来，则说明无解。

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
priority_queue<int, vector<int>, greater<int> >Q;
const int N = 2e5 + 5e2;
int n, m, a[N], b[N];
void solve() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int j = 1; j <= m; j++) cin >> b[j];
    sort(a + 1, a + n + 1);
    sort(b + 1, b + m + 1);
    ll ans = 0;
    for (int i = m, j = n; i >= 1; i--) {
        while (j >= 1 && a[j] >= b[i]) {
            Q.push(a[j--]);
        }
        if (Q.empty()) {
            cout << -1 << endl;
            return;
        }
        ans += Q.top();
        Q.pop();
    }
    cout << ans << endl;
}
int main() {
    solve();
    return 0;
}

E.Alphabet Tiles(DP)

题意

给出26个字母中每个字母的数量，即使用 $a_i$ 表示第 $i$ 个字母的个数。

定义函数 $f (i)$ 表示使用给出的字母组成长度为 $i$ 的字符串的个数。

给出一个正整数 $k$ ，请你求出：

$∑i=1kf(i)\sum\limits_{i = 1}^{k}f(i)$

hint：结果较大，需对 $998244353$ 取模

分析

定义 $d p [i] [j]$ 表示选择前 $i$ 个字母，组成 $j$ 长度的字符串的方案数。

状态转移：可以在前面所有字母已经放置了 $j$ 个字母的方案中，再放置 $l$ 个当前字母，此时的方案数可以视为总共 $j + l$ 个空位，要给前面的 $j$ 个字母放入这些空位中，此时摆放的方案数为 $C_{j + l}^{j}$ ，产生的总方案数即为 $\times C_{j + l}^{j}$

完成状态转移后，答案即为 $∑i=1kdp[26][i]\sum\limits_{i = 1}^{k}dp[26][i]$

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e3 + 5e2, mod = 998244353;
ll C[N][N], k, a[N], dp[N][N];
void init() {
    C[0][0] = 1;
    for (int i = 1; i <= 1000; i++) {
        C[i][0] = C[i][i] = 1;
        for (int j = 1; j <= i; j++) {
            C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
        }
    }
}
void solve() {
   cin >> k;
   for (int i = 1; i <= 26; i++) cin >> a[i];
   dp[0][0] = 1;
   for (int i = 1; i <= 26; i++) {
       for (int j = 0; j <= k; j++) {
           for (int l = 0; l <= a[i]; l++) {
               if (j + l > k) break;
               dp[i][j + l] = (dp[i][j + l] + dp[i - 1][j] * C[j + l][j] % mod) % mod;
           }
       }
   }
   ll ans = 0;
   for (int i = 1; i <= k; i++) {
       ans = (ans + dp[26][i]) % mod;
   }
   cout << ans << endl;
}
int main() {
    init();
    solve();
    return 0;
}

F.Easiest Maze（模拟、构造）

题意：

斯努克计划在AtCoder乐园中建造一个迷宫作为新景点。迷宫是一个有 $N$ 行和 $M$ 列的网格，右上角单元格的顶边是入口，右下角单元格的底边是出口。他将通过在相邻单元格之间适当放置墙壁来创建迷宫。

他喜欢简单的迷宫，因此他希望从入口到出口的路径正好经过 $K$ 个单元格，且没有任何分支。请判断是否可能创建这样一个迷宫，如果可能，请建造一个。

例如，在下图中， $N = 3$ 和 $M = 3$ ，并在实线处设置墙壁（除入口和出口外，墙壁总是设置在外围）。在这种情况下，从入口到出口的路径正好经过 $7$ 个单元格，没有任何分支。

下面是一个正式的说明。

有一个网格，网格中有 $N$ 行和 $M$ 列。让 $(i, j)$ 表示从上往下第 $i$ 行，从左往上第 $j$ 列的单元格。对于每一对边相邻的单元格，你可以决定是否在它们之间放置一堵墙。确定是否有可能放置墙来满足以下条件，如果有可能，请构建一个这样的放置方式。

考虑一个有 $N×MN\times M$ 个顶点的无向图 $G$ 。 $G$ 的每个顶点都由一对整数 $(i,j)(1≤i≤N,1≤j≤M)(i,j)(1\leq i\leq N,1\leq j\leq M)$ 唯一标注。两个不同的顶点 $i_1,j_1)$ 和 $i_2,j_2)$ 由一条边连接，当且仅当 $i_1-i_2|+|j_1-j_2|=1$ 和网格上对应的单元格 $i_1,j_1)$ 和 $i_2,j_2)$ 之间没有墙。

条件：存在一条顶点为 $K$ 的简单路径连接两个顶点 $(1, M)$ 和 $(N, M)$ ，且包含顶点 $(1, M)$ 和 $(N, M)$ 的连通部分仅由这条路径组成。

分析：

我们先将路径设为最短路径，再对其进行扩充。可以发现：如果进行扩充，这样增长的格子数一定是偶数。因为如果你要扩充，就会出去，出去了然后需要回来，出去和回来的路径长度一定是一样的，所以扩张只会增加偶数个格子。

先考虑无解的情况：

要求格子数大于能走过的总格子数。
要求格子数小于最短路径格子数。
要求格子数的奇偶性与能走过的总格子数的奇偶性不同。

此处考虑“能走过的总格子数”因为不一定能够走过全部的格子，例如：

$N$ 为偶数，如 $N = 4, M = 4$ ，那么可以走遍所有格子；
$N$ 为奇数，需要分类讨论：

$M$ 为奇数，那么可以走遍所有格子；
$M$ 为偶数，那么不可以走遍所有格子，会空一个格子；

然后考虑如何进行扩充，先计算出路径需要扩张几次：即求格子数减去最短路径格子数的差除以二。

接下来进行扩张，先横着扩张，一边扩张还要一边判断需要的扩张次数到了没有。横着扩充完了，再竖着扩张，虽然竖着扩张是 $N$ 为奇数独有的，但是因为剩下的都是有解的，所以
$N$ 为偶数的情况需要的扩张次数应该在横着扩张那里就满足了，最后将路径转换为迷宫问题来输出即可。

代码：

#include<bits/stdc++.h>

using namespace std;
const int N = 110;
const int MOD = 998244353;
int a[N][N], num;
int dx[10] = {0, -1, 0, 1, 0}, dy[10] = {0, 0, 1, 0, -1};
char ans[202][202];

int main() {
    int n, m, k;
    cin >> n >> m >> k;
    num = (k - n) / 2;
    if (k > n * m || k < n || (n % 2 == 0 && k % 2 == 1) || (n % 2 == 1 && m % 2 == 0 && (n * m - 1) % 2 != k % 2) ||
        (n % 2 == 1 && m % 2 == 1 && (n * m) % 2 != k % 2)) {
        cout << "No" << endl;
        return 0;
    }
    cout << "Yes" << endl;
    for (int i = 1; i <= n; i++)
        a[i][m] = 3;
    for (int i = 1; i < n && num > 0; i += 2)
        for (int j = m - 1; j >= 1 && num > 0; j--, num--) {
            a[i + 1][j] = 2;
            a[i][j] = 3;
            a[i][j + 1] = 4;
        }
    if (num != 0) {
        if (m % 2 == 0) {
            for (int i = 1; i < m - 1 && num > 0; i += 2, num--) {
                a[n - 1][i] = 3;
                a[n][i] = 2;
                a[n][i + 1] = 1;
            }
        } else {
            for (int i = 1; i < m && num > 0; i += 2, num--) {
                a[n - 1][i] = 3;
                a[n][i] = 2;
                a[n][i + 1] = 1;
            }
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            ans[i * 2 + dx[a[i][j]]][j * 2 + dy[a[i][j]]] = '.';
        }
    }
    for (int i = 1; i <= n * 2; i += 2) {
        for (int j = 1; j <= m * 2; j += 2) {
            ans[i][j] = '+';
            ans[i + 1][j + 1] = 'o';
            if (ans[i + 1][j] != '.')
                ans[i + 1][j] = '|';
            if (ans[i][j + 1] != '.')
                ans[i][j + 1] = '-';
        }
    }
    for (int i = 1; i <= n * 2 + 1; i++) {
        ans[i][m * 2 + 1] = '+';
        ans[i][1] = '+';
    }
    for (int i = 1; i <= m * 2 + 1; i++) {
        ans[n * 2 + 1][i] = '+';
        ans[1][i] = '+';
    }
    ans[1][m * 2] = 'S';
    ans[n * 2 + 1][m * 2] = 'G';
    for (int i = 1; i <= n * 2 + 1; i++) {
        for (int j = 1; j <= m * 2 + 1; j++)
            cout << ans[i][j];
        cout << endl;
    }
    return 0;
}

G.AtCoder Tour（动态规划）

题意：

AtCoder Land 是一个有 $H$ 行和 $W$ 列的网格。让 $(i, j)$ 表示第 $i$ 行和第 $j$ 列上的单元格。

高桥从 $S_i,S_j)$ 单元格开始，重复以下操作 $K$ 次：

他要么停留在当前单元格，要么移动到相邻单元格。在这个操作之后，如果他在 $(i, j)$ 单元格中，他将获得 $A_{i,j}$ 的趣味值。

请找出他能获得的最大总乐趣值。

在这里，当且仅当 $∣ x - x^{'} ∣ + ∣ y - y^{'} ∣ = 1$ 时， $(x^{'}, y^{'})$ 单元格被视为与 $(x, y)$ 单元格相邻。

分析：

在最优解中，显然会且只会在同一个方格（路径上权值最大的方格）停留，并且一直停留直到无法再进行操作，正确性很好说明：若停留在其他方格，不如在最后用这些操作数停留在路径上权值最大的方格贡献更大；若路径上权值最大的方格不是路径的终点，那么遍历剩下的点的操作数还不如停留在这个方格。

设 $dp_k,i,j$ 表示经过 $k$ 个操作并到达 $(i, j)$ 能得到的最大贡献，其中 $k \leq min (h \times w, v)$ （ $v$ 就是题面中的 $K$ ），跑完 $d p$ 后再处理停留的问题即可。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const int N = 55;
const int MOD = 998244353;

int a[N][N];
LL dp[2510][N][N];
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};

int check(int ux, int uy, int vx, int vy) {
    return abs(ux - vx) + abs(uy - vy);
}

int main() {
    int h, w, v;
    cin >> h >> w >> v;
    int stx, sty;
    cin >> stx >> sty;
    for (int i = 1; i <= h; i++) {
        for (int j = 1; j <= w; j++)
            cin >> a[i][j];
    }
    LL ans = 0;
    for (int k = 1; k <= min(v, h * w); k++) {
        for (int i = 1; i <= h; i++) {
            for (int j = 1; j <= w; j++) {
                if (check(i, j, stx, sty) <= 1) {
                    LL temp = dp[k - 1][stx][sty];
                    dp[k][i][j] = max(dp[k][i][j], temp + a[i][j]);
                }
                if (dp[k - 1][i][j]) {
                    LL temp = dp[k - 1][i][j];
                    dp[k][i][j] = max(dp[k][i][j], temp + a[i][j]);
                }
                for (int c = 0; c < 4; c++) {
                    int vx = i + dx[c], vy = j + dy[c];
                    if (dp[k - 1][vx][vy]) {
                        LL temp = dp[k - 1][vx][vy];
                        dp[k][i][j] = max(dp[k][i][j], temp + a[i][j]);
                    }
                }
            }
        }
    }
    for (int i = 1; i <= h; i++) {
        for (int j = 1; j <= w; j++) {
            int dis = check(i, j, stx, sty);
            if (dis <= v) {
                for (int k = 1; k <= min(v, h * w); k++) {
                    if (dp[k][i][j]) {
                        ans = max(ans, dp[k][i][j] + 1ll * (v - k) * a[i][j]);
                    }
                }
            }
        }
    }
    cout << ans << endl;
    return 0;
}