AtCoder Beginner Contest 359 A~F

原创已于 2024-06-26 14:54:44 修改 · 1.3k 阅读

21 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #算法 #ACM-ICPC #OI #atcoder

于 2024-06-23 17:47:00 首次发布

AtCoder 专栏收录该内容

62 篇文章

订阅专栏

A.Count Takahashi

题意

给出 $N$ 个字符串，每个字符串为以下两种字符串之一：

"Takahashi"
"Aoki"

请你统计"Takahashi"出现了多少次。

分析

输入并统计即可。

代码

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;

void solve() {
    int n;
    cin >> n;
    int ans = 0;
    for (int i = 0; i < n; i++) {
        string s;
        cin >> s;
        if (s[0] == 'T') ans++;
    }
    cout << ans << endl;
}

int main() {
    solve();
    return 0;
}

B. Couples

题意

有 $N$ 对人，每队人身上都穿着相同颜色的衣服，保证每种颜色只会出现两次（即只有同一对人才能拥有相同颜色）。

问：存在多少个人，同时与两个相同颜色衣服的人相邻？

分析

输入后依次判断是否存在第 $i$ 个人和第 $i - 2$ 个人衣服颜色相同即可。

代码

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int N = 3e5 + 5e2;
int a[N];

void solve() {
    int n;
    cin >> n;
    int ans = 0;
    for (int i = 1; i <= 2 * n; i++) {
        cin >> a[i];
        if (i >= 3 && a[i] == a[i - 2]) ans++;
    }
    cout << ans << endl;
}

int main() {
    solve();
    return 0;
}

C.Tile Distance 2(思维)

题意

有一个由大小为 $\times 1$ 的瓷砖铺成的平面，其中使用 $(x, y)$ 表示位于坐标 $(x + 0.5, y + 0.5)$ 的网格所在的位置。

问，从瓷砖 $S_{x}, S_{y})$ 走到瓷砖 $T_{x}, T{y})$ 最少仅需要经过多少个瓷砖(不包含起点)？

分析

不难发现，每块瓷砖的左半部分的 $x, y$ 坐标之和必然为偶数，右半部分的 $x, y$ 坐标之和必然为奇数。因此，为了便于处理，可以将输入的两个坐标均移动到瓷砖的左半边，此时不需要经过其他瓷砖。

然后考虑怎么移动最优，可以想到，每次向上或向下移动后，均可以再横向移动一次，此时也不需要经过其他瓷砖，即一次移动可以使两个瓷砖的行列坐标均接近 $1$ ，那么只需要经过 $min(|S_x - T_x|, |S_y - T_y|)$ 次操作，就能保证其中一个坐标相等了。

然后考虑此时的两种情况：

$x$ 坐标不相等，需要当前的 $x$ 坐标之差除以二的操作次数
$y$ 坐标不相等，需要当前的 $y$ 坐标之差的操作次数

令 $X, Y$ 为两个点的 $x, y$ 坐标之差的绝对值。

对于情况1，不难发现每次操作均能使两个点的曼哈顿距离接近 $2$ ，共需 $X+Y2\frac{X + Y}{2}$ 次操作。

对于情况2，不难发现需要的操作次数为 $Y$ ，为便于计算，将操作次数变为 $Y+Y2\frac{Y + Y}{2}$ 。

两式结合，操作次数变为 $max(X,Y)+Y2\frac{max(X, Y) + Y}{2}$ ，按公式计算输出即可。

代码

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int N = 3e5 + 5e2;
int a[N];

void solve() {
    ll sx, sy, tx, ty;
    cin >> sx >> sy >> tx >> ty;
    if (sx + sy & 1) sx--;
    if (tx + ty & 1) tx--;
    ll x = abs(sx - tx);
    ll y = abs(sy - ty);
    ll ans = (y + max(x, y)) / 2;
    cout << ans << endl;
}

int main() {
    solve();
    return 0;
}

D.Avoid K Palindrome（动态规划）

题意：

给你一个长度为 $N$ 的字符串 $S$ ，由字符A、B和?组成。

同时给你一个正整数 $K$ 。如果满足以下条件，那么由A和B组成的字符串 $T$ 就是一个好字符串：

在 $T$ 中，长度为 $K$ 的连续子串都不是回文。

设 $q$ 是 $S$ 中的?字符数量，用A或B替换 $S$ 中的每个?，可以得到 $2^q$ 个字符串。请找出其中有多少个字符串是好字符串。

这个数目可能非常大，答案对 $998244353$ 取模。

分析：

从左到右考虑每个字符，如果当前是?，则考虑其变为 $A$ , $B$ ，是否出现长度为 $k$ 的回文串。

我们需要知道该?前 $k - 1$ 位的情况，加上该字母，就可以判断出新增的子串是不是回文串。

即设 $dp_{i,j}$ 表示考虑前 $i$ 位字符，其中?都已经替换成 $A$ 或 $B$ 后，且后 $9$ 位的字符状态为 $j$ (因为只有 $A B$ 两种，可以编码成 $01$ ，用二进制压缩表示)。

然后考虑当前位的情况，如果取值为 $A$ 即 $0$ ，则判断 $j << 1$ 状态是不是回文串，不是的话则有 $dp_{i+1,(j<<1) \&mask}+=dp_{i,j}$ ，否则就状态非法，不转移。因为 $j << 1$ 是后 $10$ 个字符的状态信息，而 $j$ 的含义是后 $9$ 位，所以 $&mask\&mask$ 是把第 $10$ 位去掉。

同理，取值为 $B$ 的话，即 $1$ ，则判断 $(j << 1) ∣1$ 是不是回文串，不是的话就转移，否则不转移。事先预处理每个状态是否是回文串，然后当 $i \geq k$ 时再考虑转移的合法性。

代码：

#include<bits/stdc++.h>

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

int main() {
    int n, k;
    string s;
    cin >> n >> k >> s;
    int up = (1 << k);
    vector<int> p(up);
    for (int i = 0; i < up; i++) {
        vector<int> bit(k);
        int num = i;
        for (int j = 0; j < k; j++) {
            bit[j] = (num & 1);
            num >>= 1;
        }
        auto rev = bit;
        reverse(rev.begin(), rev.end());
        p[i] = rev == bit;
    }

    up = 1 << (k - 1);
    int mask = up - 1;
    vector<int> dp(up, 0);
    dp[0] = 1;
    for (int i = 0; i < n; ++i) {
        int chr = s[i];
        vector<int> dp2(up, 0);
        for (int j = 0; j < up; j++) {
            if (chr == '?') {
                if (i + 1 < k || !p[j << 1]) {
                    int nxt = (j << 1) & mask;
                    dp2[nxt] = (dp2[nxt] + dp[j]) % MOD;
                }
                if (i + 1 < k || !p[j << 1 | 1]) {
                    int nxt = (j << 1 | 1) & mask;
                    dp2[nxt] = (dp2[nxt] + dp[j]) % MOD;
                }
            } else {
                if (i + 1 < k || !p[j << 1 | (chr - 'A')]) {
                    int nxt = (j << 1 | (chr - 'A')) & mask;
                    dp2[nxt] = (dp2[nxt] + dp[j]) % MOD;
                }
            }
        }
        dp.swap(dp2);
    }
    LL ans = 0;
    for (int i = 0; i < up; i++) {
        ans = (ans + dp[i]) % MOD;
    }
    cout << ans << endl;
    return 0;
}

E.Water Tank（单调栈）

题意：

给你一个长度为 $N$ 的正整数序列： $H=(H1,H2,…,HN)H=(H_1,H_2,\dotsc,H_N)$ 。

有一个长度为 $N + 1$ 的非负整数序列： $A=(A0,A1,…,AN)A=(A_0,A_1,\dotsc,A_N)$ 。最初为 $A0=A1=⋯=AN=0A_0=A_1=\dotsb=A_N=0$ 。

对 $A$ 重复进行以下运算：

将 $A_0$ 的值增加 $1$ 。
依次对 $i=1,2,…,Ni=1,2,\ldots,N$ 进行以下操作：
- 如果 $Ai−1>AiA_{i-1}\gt A_i$ 和 $Ai−1>HiA_{i-1}\gt H_i$ ，则将 $A_{i-1}$ 的值减少 $1$ ，并将 $A_i$ 的值增加 $1$ 。

求每个 $i=1,2,…,Ni=1,2,\ldots,N$ 在 $Ai>0A_i\gt 0$ 第一次成立之前的运算次数。

分析：

观察样例，模拟一下，很容易发现如果要求第 $i$ 位的答案，则要求之前的第 $i - 1$ 位装满，即和柱子 $a_i$ 高度一样，而高度一样要求 $i−2,i−3,…i−2,i−3,\dots$ 位高度也一样。观察上述会发现，假设前面比柱子 $a_i$ 还高的柱子是 $a_j$ ，那么 $j,j+1,…,i−1j,j+1,\dots,i−1$ 位的水高都必须是 $a_i$ 。

因此，求解第 $i$ 位的答案，则需要 $i−1,i−2,…,ji−1,i−2,\dots,j$ 位与 $a_i$ 高度相同，然后 $j−1,j−2,…,kj−1,j−2,\dots,k$ 与 $a_j$ 高度相同， $k−1,k−2,…k−1,k−2,\dots$ 与 $a_k$ 高度相同，其中 $a_i≤a_j≤a_k$ ，需要维护一个从左到右，柱子高度单调递减的序列，可以用单调栈进行维护，栈底是最左边，栈顶是最右边。在维护递减高度时，同时维护每个递减区间的水高度总和即可。

代码：

#include<bits/stdc++.h>

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

int main() {
    cin >> n;
    LL ans = 1;
    vector<pair<int, int>> f;
    f.emplace_back(0, INT_MAX);
    for (int i = 1, x; i <= n; i++) {
        cin >> x;
        int lst, lx;
        while (f.back().second <= x) {
            lst = f.back().first;
            lx = f.back().second;
            f.pop_back();
            ans -= 1ll * (lst - f.back().first) * lx;
        }
        ans += 1ll * x * (i - f.back().first);
        f.emplace_back(i, x);
        cout << ans << " ";
    }
    cout << endl;
    return 0;
}

F.Tree Degree Optimization（树、优先队列）

题意：

问题陈述

给你一个整数序列 $A=(A1,…,AN)A=(A_1,\ldots,A_N)$ 。对于一棵有 $N$ 个顶点的树 $T$ ，定义 $f (T)$ 如下：

设 $d_i$ 是 $T$ 中顶点 $i$ 的度数。那么， $f(T)=∑i=1Ndi2Aif(T)=\sum\limits_{i=1}^N{d_i}^2 A_i$ 。

求 $f (T)$ 的最小可能值。

约束条件保证答案小于 $2^{63}$ 。

分析：

由于是一棵树，则满足：

$1≤i≤n,d_i≥1$
$∑di=2n−2,1≤di≤n−1\sum d_i=2n−2,1≤d_i≤n−1$ 。

对于任意满足上述条件的 $d_i$ ，都可以构造出对应的树，使得每个点的度数都是 $d_i$ 。构造方法为每次选择度数为 $1$ 和非 $1$ 的点连边，然后更新剩余度数。

下面考虑如何分配这些度数。

如果给点 $1$ 分配一个度，是其 $d_1=1→2$ ，则代价是 $4a_1−a_1$ ，而如果是 $d_1=2→3$ ，则代价是 $9a_1−4a_1$ 。

我们考虑贪心的做法，直接先把全部 $d_i$ 赋上 $1$ 的权值，然后把剩下的 $n - 2$ 个度分配给每个点，使得代价最小，每次仅分配 $1$ 的度，贪心的将其分配给代价最小的点。用优先队列维护上述代价即可。

代码：

#include<bits/stdc++.h>

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

int n, a[N], d[N];
LL ans;
priority_queue<pair<LL, int>, vector<pair<LL, int> >, greater<pair<LL, int> > > q;

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        ans += a[i];
        d[i] = 1;
        q.emplace(3ll * a[i], i);
    }
    for (int i = 1; i <= n - 2; i++) {
        int id = q.top().second;
        ans += q.top().first;
        q.pop();
        d[id]++;
        q.emplace(a[id] * (d[id] * 2ll + 1), id);
    }
    cout << ans << endl;
    return 0;
}