Educational Codeforces Round 114 A-D

A. Regular Bracket Sequences

请你构造n个长度为2n的不同的合法括号序列。

如下构造即可。

()
()()
()(())
()((()))
... ...

B. Combinatorics Homework

问是否存在这样的字符串：

• 恰好有a个字母’A’
• 恰好有b个字母’B’
• 恰好有c个字母’C’
• 没有其他字母
• 有m对相同的相邻字母对

计算最大和最小的相同相邻字母对数量，判断m是否在中间即可。

最大构造就是AAA…BBB…CCC
最小构造就是拿出最多的那种字母，另外两种字母隔板插入

代码：

#include <bits/stdc++.h>
using namespace std;

const int N = 1e5 + 5;

void solve()
{
    long long a, b, c, m;
    cin >> a >> b >> c >> m;
    long long A = max(0ll, a - 1);
    long long B = max(0ll, b - 1);
    long long C = max(0ll, c - 1);
    vector<long long> vec;
    vec.emplace_back(a);
    vec.emplace_back(b);
    vec.emplace_back(c);
    long long mx = A + B + C;
    sort(vec.begin(), vec.end());
    long long mn;
    if (vec[2] <= vec[0] + vec[1] + 1)
        mn = 0;
    else
        mn = vec[2] - vec[0] - vec[1] - 1;
    if (m > mx || m < mn)
        cout << "NO" << '\n';
    else
        cout << "YES" << endl;
}

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
        solve();
    return 0;
}

C. Slay the Dragon

有n个士兵，每个士兵有力量$a_i$。你可以用1个花费增强某个士兵的力量1.
每次询问有一条恶龙。恶龙有攻击力和防御力，你需要派出一个力量大于等于恶龙防御力的士兵进攻恶龙，并且其他士兵的力量和要大于等于恶龙攻击力。各询问独立，每次输出最小花费。

考虑贪心选取进攻的士兵：

• 如果选取的士兵力量太大，远大于恶龙的防御，导致浪费。

• 如果选取的士兵力量太小，可能其他士兵的力量和远大于恶龙的攻击力，导致浪费。

因此肯定会选择排序后，第一个力量大于等于恶龙的士兵 或 是最后一个力量小于恶龙的士兵进攻。

代码：

#include <bits/stdc++.h>
using namespace std;

const int N = 2e5 + 5;

void solve()
{
    int n, m;
    scanf("%d", &n);
    vector<long long> vec;
    long long sum = 0;
    for (int i = 1; i <= n; i++)
    {
        long long temp;
        scanf("%lld", &temp);
        sum += temp;
        vec.emplace_back(temp);
    }
    sort(vec.begin(), vec.end());
    scanf("%d", &m);
    while (m--)
    {
        long long x, y;
        scanf("%lld %lld", &x, &y);

        int p = lower_bound(vec.begin(), vec.end(), x) - vec.begin() + 1;
        if (p < 1 || p > n) //增强最后一个 进攻
        {
            long long ans = x - vec[n - 1];
            long long res = sum - vec[n - 1];
            if (res < y) //其他 防守
                ans += y - res;
            printf("%lld\n", ans);
            continue;
        }

        long long ans = 0; //找到的第一个力量 >=x的发起进攻
        long long res = sum - vec[p - 1];
        if (res < y)
            ans += y - res;

        if (p != 1)
        {
            long long ans2 = x - vec[p - 2];
            long long tempres = sum - vec[p - 2];
            if (tempres < y)
                ans2 += y - tempres;
            ans = min(ans, ans2);
        }
        printf("%lld\n", ans);
    }
}
int main()
{
    solve();
    return 0;
}

D. The Strongest Build

有n个装备栏和n种装备，每种装备有若干个，每个装备有一个力量值$a_{ij}$，同一种装备只能选取一个装在固定的装备栏上。同时有m个套装被禁用了，请问最大的装备组合力量是多少。保证至少有一套装备未被禁用。

如果最大装备组合未被禁用，那就选取最大装备组合，否则，最优组合肯定是在某一种禁用套装的基础上，选取某一种装备的前一个。

代码

#include <bits/stdc++.h>
using namespace std;

const int N = 12;
const int M = 2e5;

int c[N];
vector<int> a[N];
vector<int> res[M];

map<vector<int>, bool> vis;

int out[N];
int n;
long long ans;
void get(int id)
{
    vector<int> ress;
    ress.resize(n + 1);
    for (int i = 1; i <= n; i++)
        ress[i] = res[id][i];
    if (vis.count(ress))
        return;
    long long sum = 0;
    for (int i = 1; i <= n; i++)
        sum += a[i][res[id][i]];
    if (sum > ans)
    {
        ans = sum;
        for (int i = 1; i <= n; i++)
            out[i] = res[id][i];
    }
}

void solve()
{
    scanf("%d ", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &c[i]);
        a[i].resize(c[i] + 1);
        for (int j = 1; j <= c[i]; j++)
            scanf("%d", &a[i][j]);
    }
    int m;
    scanf("%d", &m);
    for (int i = 1; i <= m; i++)
    {
        res[i].resize(n + 1);
        for (int j = 1; j <= n; j++)
            scanf("%d", &res[i][j]);
        vis[res[i]] = 1; //标记
    }
    vector<int> ress;
    ress.resize(n + 1);

    for (int i = 1; i <= n; i++)
        ress[i] = c[i];
    if (!vis.count(ress)) //最大组合无限制
    {
        for (int i = 1; i <= n; i++)
            printf("%d ", c[i]);
        printf("\n");
        return;
    }

    for (int i = 1; i <= m; i++) //枚举每种限制
    {
        for (int j = 1; j <= n; j++) //答案一定是某一限制的某一位减少而来的
        {
            if (res[i][j] > 1)
            {
                res[i][j]--;
                get(i);
                res[i][j]++;
            }
        }
    }
    for (int i = 1; i <= n; i++)
        printf("%d ", out[i]);
    puts("");
}

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