Codeforces Global Round 25 A~E_c. ticket hoarding-优快云博客

本文链接：https://blog.youkuaiyun.com/Code_Shark/article/details/137671629

A. Dual Trigger (思维)

题意：

有 $n$ 盏灯，编号为 $1$ 至 $n$ ，排成一排，一开始全部都是灭的。可以执行以下任意次数的操作（可能为零）：

选择两个不相邻的 ${}^\dagger$ 没开的灯，将它们打开。
确定是否能达到配置 $s$ ，其中 $s_i = 1$ 表示 $i$ 个灯泡已打开，否则为 $s_i = 0$ 。

分析：

灯的数量为偶数时，需要特判如果只有两盏灯亮，那么要求不能相邻，相邻不成立，其他成立。灯的数量为奇数时不成立，

代码：

#include <bits/stdc++.h>

using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n;
        string s;
        cin >> n >> s;
        vector<int> tmp;
        for (int i = 0; i < s.size(); i++)
            if (s[i] == '1')
                tmp.push_back(i);
        if (tmp.size() % 2) {
            cout << "NO" << endl;
            continue;
        }
        if (tmp.size() == 2 && tmp[0] + 1 == tmp[1])
            cout << "NO" << endl;
        else
            cout << "YES" << endl;
    }
    return 0;
}

B.Battle Cows （贪心）

题意：

有 $n$ 头奶牛参加编码比赛。奶牛 $i$ 的 $C o w d e f orces$ 值为 $a_i$ （全部不同），最初位于位置 $i$ 。比赛由以下 $n - 1$ 场比赛组成：

第一场比赛在位置 $1$ 的奶牛和位置 $2$ 的奶牛之间进行。
随后，每场比赛 $i$ 都在位置 $i + 1$ 的奶牛和比赛 $i - 1$ 的获胜者之间进行。
在每场比赛中， $C o w d e f orces$ 等级较高的奶牛获胜并进入下一场比赛。

您是奶牛 $k$ 的主人。对您来说，赢得比赛并不重要；相反，您希望您的奶牛在尽可能多的比赛中获胜。作为比赛组织者的熟人，您可以要求他们将您的奶牛与另一头奶牛交换一次位置，或者您也可以选择什么都不做。

找出您的奶牛能够赢得的最大场次。

分析：

通过观察发现，对于第 $k$ 头牛，如果前面有一个下标 $i$ 满足 $a_i > a_k$ ，对于第 $k$ 头牛来说只有两种情况，一种是击败从 $1$ 到 $i - 1$ 的牛，另一种是和第 $i$ 头牛交换，击败从 $i$ 开始的到下一个大于 $a_k$ 的中间所有的牛。

代码：

#include <bits/stdc++.h>

using namespace std;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, k;
        cin >> n >> k;
        vector<int> a(n + 1);
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        int pos = 0;
        for (int i = 1; i < k; i++) {
            if (a[i] > a[k]) {
                pos = i;
                break;
            }
        }
        int ans = 0;
        if (pos != 0) {
            if (pos != 1)
                ans = 1;
            for (int i = 1; i < pos; i++)
                if (a[i] > a[k])
                    ans = 0;
            for (int i = pos + 1; i <= n; i++) {
                if (a[k] > a[i])
                    ans++;
                else
                    break;
            }
        }
        int tmp = 0;
        if (k != 1)
            swap(a[1], a[k]);
        for (int i = 2; i <= n; i++)
            if (a[i] > a[1])
                break;
            else
                tmp++;
        cout << max(tmp, ans) << endl;
    }
    return 0;
}

C.Ticket Hoarding (贪心)

题意：

作为一家创业公司的首席执行官，你想奖励 $k$ 位员工每人一张即将到来的音乐会门票。门票将在 $n$ 天内发售，你预测在 $i$ 天每张门票的价格将是 $a_i$ 。但是，为了防止囤积门票，演唱会主办方采取了以下措施：

每人每天购票不得超过 $m$ 张。
如果某人在 $i$ 日购买了 $x$ 张门票，则其后各日（即从 $i + 1$ 日开始）的每张门票价格将提高 $x$ 。

例如，如果 $a = [1, 3, 8, 4, 5]$ 你在 $1$ 日购买了 $2$ 张门票，那么这些门票的总价为 $2$ ，而从 $2$ 日开始的价格将变为 $[5, 10, 6, 7]$ 。如果您在 $2$ 日又购买了 $3$ 张门票，那么这些门票的总费用将增加 $15$ ，从 $3$ 日起的价格将变为 $[13, 9, 10]$ 。

求购买 $k$ 张车票的最低消费。

分析：

通过观察发现，如果票的价格和每种票买的数量是确定的，那么最终价格和购买顺序没有任何关系，所以我们只需要贪心地进行排序，每次买价格最低的即可。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

int main() {
    int T;
    cin >> T;
    while (T--) {
        int n, m, k;
        cin >> n >> m >> k;
        vector<int> a(n + 1), id(n);
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
            id[i - 1] = i;
        }
        sort(id.begin(), id.end(), [&](int x, int y) {
            if (a[x] != a[y]) return a[x] < a[y];
            return x < y;
        });
        LL ans = 0;
        int num = 0;
        for (auto tmp: id) {
            int t = min(m, k);
            ans += 1LL * t * (a[tmp] + num);
            num += t;
            k -= t;
        }
        cout << ans << endl;
    }
    return 0;
}

D.Buying Jewels (思维)

题意：

爱丽丝有 $n$ 枚硬币，她想去鲍勃的珠宝店购物。今天，虽然鲍勃还没有开店，但他想确保爱丽丝会买到准确的 $k$ 颗珠宝。为了开设珠宝店，鲍勃最多可以设置 $60$ 个摊位（每个摊位上的珠宝数量不限），并将每个摊位上每件珠宝的价格设置为介于 $1$ 和 $10^{18}$ 之间的整数个硬币。

幸运的是，鲍勃知道爱丽丝会贪婪地购买：她会去 $1$ 号摊位，尽可能多地购买珠宝，然后去 $2$ 号摊位，尽可能多地购买珠宝，以此类推直到最后一个摊位。知道这一点后，鲍勃就可以选择摆摊的数量，并设定每个摊位的价格，这样爱丽丝就能买到恰好 $k$ 件珠宝。请帮助鲍勃完成任务，或者判断是否不可能完成任务。

请注意，爱丽丝不需要花光所有金币。

分析：

首先处理特判， $n = k ， k = 1$ 时分别 $1, 1$ 和 $1, n$ 。通过打表或其他方法发现当 $\times k \le n+1$ 时，可以两步解决， $n - k + 1, 1$ ，首先取 $k - 1$ 个 $1$ ，剩下的一块取即可。其他都是无解的。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int mod = 1e9 + 7;

int main() {
    int T;
    cin >> T;
    while (T--) {
        LL n, k;
        cin >> n >> k;
        if (n == k) {
            cout << "YES" << endl;
            cout << 1 << endl;
            cout << 1 << endl;
            continue;
        }
        if (k == 1) {
            cout << "YES" << endl;
            cout << 1 << endl;
            cout << n << endl;
            continue;
        }
        if (2 * k <= n + 1) {
            cout << "YES" << endl;
            cout << 2 << endl;
            cout << n - k + 1 << " " << 1 << endl;
            continue;
        }
        cout << "NO" << endl;
    }
    return 0;
}

E. No Palindromes (字符串)

题意：

给出一个由小写拉丁字符组成的字符串 $s$ 。需要将其分割成若干子串，使得每个子串都不是回文子串。

分析：

首先特判本身就是回文串的情况，本题有个结论：除了某些特殊情况， $s$ 最多分成两个字符串，在保证 $s$ 是回文串的情况下，只有以下情况不能被分割：

$n < 4$ 时，无法分割
$s$ 是只由同一个字母构成的字符串
$s$ 的形状是 $aaaaabaaaaa$ ，其中一个字母有 $n - 1$ 个

$s$ 的形状是 $ababababa$ 的循环子串。

其他情况都能被分成两个非回文串，通过双哈希进行回文串的判断。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

struct PIIhash {
    const LL base[2] = {29, 31};
    const LL hashmod[2] = {(LL) 1e9 + 9, 998244353};
    array<vector<LL>, 2> hash1;
    array<vector<LL>, 2> pwMod;

    void init(string S) {
        int n = S.size();
        S = ' ' + S;
        hash1[0].resize(n + 1), hash1[1].resize(n + 1);
        pwMod[0].resize(n + 1), pwMod[1].resize(n + 1);
        for (int i = 0; i < 2; ++i) {
            pwMod[i][0] = 1;
            for (int j = 1; j <= n; ++j) {
                pwMod[i][j] = pwMod[i][j - 1] * base[i] % hashmod[i];
                hash1[i][j] = (hash1[i][j - 1] * base[i] + S[j]) % hashmod[i];
            }
        }
    }

    pair<LL, LL> get(int l, int r) {
        pair<LL, LL> ans;
        ans.first = (hash1[0][r] - hash1[0][l - 1] * pwMod[0][r - l + 1]) % hashmod[0];
        ans.second = (hash1[1][r] - hash1[1][l - 1] * pwMod[1][r - l + 1]) % hashmod[1];
        ans.first = (ans.first + hashmod[0]) % hashmod[0];
        ans.second = (ans.second + hashmod[1]) % hashmod[1];
        return ans;
    }
};

bool check(PIIhash &a, int la, int ra, PIIhash &b, int lb, int rb) {
    return a.get(la, ra) == b.get(lb, rb);
}

int main() {
    int T;
    cin >> T;
    while (T--) {
        string s;
        cin >> s;
        int n = s.size();
        string tmp = s;
        reverse(tmp.begin(), tmp.end());
        PIIhash a, b;
        a.init(s), b.init(tmp);
        if (!check(a, 1, n, b, 1, n)) {
            cout << "YES" << endl;
            cout << 1 << endl;
            cout << s << endl;
            continue;
        }
        int cnt = count(s.begin(), s.end(), s[0]);
        if (n != 1)
            count(s.begin(), s.end(), s[1]);
        if (cnt >= n - 1) {
            cout << "NO" << endl;
            continue;
        }
        bool flag = 0;
        for (int i = 2; i < n; i++) {
            if (s[i] != s[i - 2])
                flag = 1;
        }
        if (n < 4 || (!flag) && (n & 1)) {
            cout << "NO" << endl;
            continue;
        }
        for (int i = 1; i <= n; i++) {
            if (!check(a, 1, i, b, n - i + 1, n) && !check(a, i + 1, n, b, 1, n - i)) {
                cout << "YES" << endl;
                cout << 2 << endl;
                cout << s.substr(0, i) << ' ' << s.substr(i, n - i) << endl;
                break;
            }
        }
    }
    return 0;
}