AtCoder Beginner Contest 381

省流版

• A. 按题意判断即可
• B. 按题意判断即可
• C. 枚举/的位置，然后分别向左右找到最长的1串和2串，然后取最小值即可
• D. 讨论起始位置的奇偶性，然后用双指针，每两个字符每两个字符，维护出现的次数为2，两种情况取最大值即可
• E. 答案为所有/的左右12个数的最小值的最大值，注意到个数随着/的增大是单调的，而最大值出现在交点，二分找该交点即可
• F. $dp[i]$表示已经选择的字符的集合状态是$i$时的最小的选择字符的位置，转移枚举下一个字符，然后找到下一个字符的位置，然后更新$dp$即可

A - 11/22 String (abc381 A)

题目大意

给定一个字符串，问它是不是形如11/22的形式。即一个1串和一个2串，长度相等，中间用/分隔。

解题思路

找到/，然后判断左右两边是否是1串和2串即可。

神奇的代码

n = input()
s = input()
s = s.split('/')
if len(s) == 2 and len(s[0]) == len(s[1]) and all(i == '1' for i in s[0]) and all(i == '2' for i in s[1]):
    print('Yes')
else:
    print('No')

---

B - 1122 String (abc381 B)

题目大意

给定一个字符串，问它是不是形如11223344的形式。即每两位相同，且每个字符出现的次数为2。

解题思路

判断奇数位和偶数位是否相同，然后判断每个字符出现的次数是否为2即可。

神奇的代码

s = input()
c = set(s)
if s[::2] == s[1::2] and all(sum(1 for i in s if i == j) == 2 for j in c):
    print('Yes')
else:
    print('No')

---

C - 11/22 Substring (abc381 C)

题目大意

给定一个字符串，问它的最长子串是多少，使得子串中1的个数和2的个数相等，中间用/分隔。

解题思路

枚举/的位置，然后分别向左右找到最长的1串和2串，然后取最小值即可。

因为每个子串只包含一个/，因此字符串就被/分成若干部分，每个部分最多只会遍历两次，因此时间复杂度为$O(n)$。

神奇的代码

#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;
    int ans = 0;
    auto find1 = [&](int x) {
        for (int i = x; i >= 0; --i) {
            if (s[i] != '1')
                return x - i;
        }
        return x + 1;
    };
    auto find2 = [&](int x) {
        for (int i = x; i < n; ++i) {
            if (s[i] != '2')
                return i - x;
        }
        return n - x;
    };
    for (int i = 0; i < n; i++) {
        if (s[i] == '/') {
            ans = max(ans, min(find1(i - 1), find2(i + 1)));
        }
    }
    ans = ans * 2 + 1;
    cout << ans << '\n';
 
    return 0;
}
 

---

D - 1122 Substring (abc381 D)

题目大意

给定一个字符串，问它的最长子串是多少，使得每两位相同，且每个字符出现的次数为2。

解题思路

如果每两个看成一个字符，问题其实就是求最长的子串，其每个字符出现的次数为1。这是一个经典的双指针问题，即维护一个区间$l,r$，使得区间内的每个字符出现的次数为1，然后不断向右移动$r$，直到区间内的字符出现的次数不满足条件，然后向右移动$l$，直到区间内的字符出现的次数满足条件，然后继续向右移动$r$，直到字符串结束。因为每个字符最多只会被访问两次，因此时间复杂度为$O(n)$。

而此处的字符是两个字符，其实也没什么区别，原本是一个字符一个字符的移动，现在是两个字符两个字符的移动而已。区别仅仅是起始位置的奇偶性，即可以从第一个字符开始，也可以从第二个字符开始。

这两种情况分别讨论，然后取最大值即可。

神奇的代码

#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;
    cin >> n;
    vector<int> a(n);
    for (auto& i : a) {
        cin >> i;
        --i;
    }
    auto solve = [&](int st) {
        int ret = 0;
        int la = st;
        vector<int> cnt(n);
        for (int i = st; i < n; i += 2) {
            if (i + 1 >= n || a[i] != a[i + 1] || cnt[a[i]] == 1) {
                ret = max(ret, i - la);
                while (la < i && (a[i] != a[i + 1] || cnt[a[i]] == 1)) {
                    cnt[a[la]]--;
                    la += 2;
                }
            }
            if (a[i] == a[i + 1])
                cnt[a[i]]++;
            else
                la += 2;
        };
        ret = max(ret, n - la - ((n - st) & 1));
        return ret;
    };
    int ans = max(solve(0), solve(1));
    cout << ans << '\n';
 
    return 0;
}
 

---

E - 11/22 Subsequence (abc381 E)

题目大意

给定一个字符串$s$，给定$q$个询问，每个询问给定$l,r$，问$s[l,r]$的最长子序列，使得子序列中1的个数和2的个数相等，中间用/分隔。

解题思路

对于每个询问，枚举/的位置$m$，答案就是$[l,m]$的$1$的个数和$[m+1,r]$的$2$的个数的最小值的两倍加一。后者个数的计算可以通过前缀和来实现。但前者枚举的复杂度是$O(n)$，因此总的复杂度是$O(nq)$，无法通过。

注意答案是$\min(cnt1[l, m], cnt2[m, r])$，其中$cnt1[l, m]$表示$[l,m]$的$1$的个数，$cnt2[m, r]$表示$[m+1,r]$的$2$的个数。随着$m$的增大，$cnt1[l, m]$是单调递增的，$cnt2[m, r]$是单调递减的。

因此两者最小值，首先是取在$cnt1$，然后再变成在$cnt2$，而其最大值就在这两者的交点。因此可以通过二分来找到这个交点。这样就可以将复杂度降到$O(q\log n)$。

虽然这个$\min$是个单峰函数，但由于有相同的值，不能直接三分找到最大值。

神奇的代码

#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, q;
    string s;
    cin >> n >> q >> s;
    array<vector<int>, 2> cnt{vector<int>(n), vector<int>(n)};
    vector<int> pos;
    for (int i = 0; i < n; i++) {
        if (s[i] == '/')
            pos.push_back(i);
        else
            cnt[s[i] - '1'][i] = 1;
    }
    partial_sum(cnt[0].begin(), cnt[0].end(), cnt[0].begin());
    partial_sum(cnt[1].begin(), cnt[1].end(), cnt[1].begin());
    auto get_sum = [&](int l, int r, int c) {
        return cnt[c][r] - (l - 1 < 0 ? 0 : cnt[c][l - 1]);
    };
    auto solve = [&](int L, int R) {
        auto calc1 = [&](int x) { return get_sum(L, x, 0); };
        auto calc2 = [&](int x) { return get_sum(x, R, 1); };
        auto check = [&](int x) { return calc1(x) <= calc2(x); };
 
        int l = lower_bound(pos.begin(), pos.end(), L) - pos.begin();
        int r = upper_bound(pos.begin(), pos.end(), R) - pos.begin();
        if (l == r)
            return 0;
        int ret = 0;
        while (l + 1 < r) {
            int m = (l + r) / 2;
            if (check(pos[m]))
                l = m;
            else
                r = m;
        }
        for (int i = l; i <= r; i++) {
            if (L <= pos[i] && pos[i] <= R)
                ret = max(ret, min(calc1(pos[i]), calc2(pos[i])));
        }
        return ret * 2 + 1;
    };
    while (q--) {
        int l, r;
        cin >> l >> r;
        --l, --r;
        int ans = solve(l, r);
        cout << ans << '\n';
    }
 
    return 0;
}
 

---

F - 1122 Subsequence (abc381 F)

题目大意

给定一个字符串，问它的最长子序列是多少，使得每两位相同，且每个字符出现的次数为2。

解题思路

注意字符只有$20$种。一种朴素搜索就是花$O(20!)$枚举字符出现的顺序，一旦顺序确定好了，就是可行性判断，找出这个子序列就可以用贪心的方法，即每次找到一个字符，然后找到下一个字符，直到找到所有的字符。这样的复杂度是$O(n)$的。

考虑如何优化呢，找到其中重复的部分，比如考虑排列123 4567以及213 4567以及312 4567，我们要依次判断这些排列的可行性，比如我们找到4，就要从上一次的位置开始找，对于123、213、312，这所谓的上一次的位置可能是不一样的，但因为我们要找4，自然希望上一次位置越靠前越好。而对于我们找4还是找5，取决于我们之前是否选择了4。因此这里可以把排列的信息压缩掉，即记$dp[i]$表示已经选择的字符的集合状态是$i$时的最小的选择字符的位置。比如状态$i$表示选择了123，那$dp[i]$就是选择顺序123, 132, 213, 231, 312, 321按照上述贪心方法找到的子序列最大下标的最小值。

转移就是枚举下一个字符，然后找到下一个字符的位置，然后更新$dp$即可。时间复杂度是$O(2^{20} 20)$的。

神奇的代码

#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;
    cin >> n;
    constexpr int num = 20;
    array<vector<int>, num> pos;
    for (int i = 0; i < n; i++) {
        int a;
        cin >> a;
        --a;
        pos[a].push_back(i);
    }
    constexpr int up = (1 << num);
    vector<int> dp(up, n);
    dp[0] = 0;
    int ans = 0;
    for (int i = 0; i < up; ++i) {
        for (int j = 0; j < num; ++j) {
            if ((i >> j) & 1) {
                int la = i ^ (1 << j);
                auto it = lower_bound(pos[j].begin(), pos[j].end(), dp[la]);
                if (it != pos[j].end() && next(it) != pos[j].end()) {
                    dp[i] = min(dp[i], *next(it));
                    ans = max(ans, __builtin_popcount(i));
                }
            }
        }
    }
    cout << ans * 2 << '\n';
 
    return 0;
}
 

---

G - Fibonacci Product (abc381 G)

题目大意

定义$a_1 = x, a_2 = y, a_i = a_{i-1} + a_{i - 2}$。

求$\prod_{i=1}^{n} (a_i) \mod 998244353$

解题思路

<++>

神奇的代码

---