【CF】Day6——Codeforces Round 942 (Div. 2) BC + Codeforces Round 941 (Div. 2) C

最新推荐文章于 2025-04-01 18:04:54 发布

KyollBM

最新推荐文章于 2025-04-01 18:04:54 发布

阅读量945

点赞数 8

文章标签：算法

本文链接：https://blog.csdn.net/qq_61422664/article/details/146262675

版权

B. Coin Games

题目：

思路：

虽然标签是博弈论，但我感觉更像一个找规律的思维题

由于题目告诉我们每次只能选U，那我们不妨来考虑选U会造成什么情况（以下都为选中间U）

①.UUU = -3*U

此时选了U会导致两侧的U变为D，同时自身消失，此时相当于消去了三个U

②.UUD/DUU = -U

此时选了U会导致左右两侧相反，同时自身消失，此时左右两侧转变后对还是UD/DU形式，故只消耗了一个U

③.DUD = +U

此时选了U会导致增加两个U，但是自身会消失，所以总的来说是增加了一个U

综上所述，无论怎么选U，每次都是奇数次变化，也就是说只要总U数是奇数，那么先手必赢，否者后者获胜

代码：

#include <iostream>
#include <algorithm>
#include<cstring>
#include<cctype>
#include<string>
#include <set>
#include <vector>
#include <cmath>
#include <queue>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <stack>
#include <memory>
using namespace std;
#define ll long long
#define yes cout << "YES\n"
#define no cout << "NO\n"

void solve()
{
    int n;
    cin >> n;
    string s;
    cin >> s;
    int cnt = 0;
    for (int i = 0; i < s.length(); i++)
    {
        cnt += (s[i] == 'U');
    }
    if (cnt & 1)
        yes;
    else 
        no;
}

int main()
{
    cin.tie(0)->sync_with_stdio(false);
    int t = 1;
    cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

C. Everything Nim

（这题是后面的C题，但是也是博弈论，一起说了）

题目：

思路：

这题才有博弈，首先我们可以考虑特殊情况，只要我们数组中有1，那么就只能选1，这是一个关键点，那么在数组中没有1前，我们只能选1

注意：这题主要看的是不同元素个数，因为每次选取都对所有堆都进行了操作，所以我们可以用set来储存不同元素个数就行了，以下的数组都是set

那么假设现在数组中没有1了，假设最小的数是k，那么k肯定是大于等于2的，因为数组中没1了，那我们先不管谁是先手，那么对于任意一个人，如果我们想要赢的话，那最后一步肯定是自己走，也就是说最后一堆肯定是被那个人一次性拿完，那么现在就有两种情况

①.如果只剩一堆

显然可以直接赢

②.如果剩了两堆or以上

那么对于先手，要想最后一步是自己，那么我可以这样，每次选k-1个，这样后手只能选一个，那么就能保证每一堆都是自己先手

所以现在就很简单了，首先将数组的1清空，然后看谁先手就行了，肯定是此时的先手赢

特殊的，如果一个数组是这样的 1 2 3 4 5 ，对于这样的连续数组，显然每次是选1，那么此时的结果就是取决与数组长度的奇偶性了

代码：

#include <iostream>
#include <algorithm>
#include<cstring>
#include<cctype>
#include<string>
#include <set>
#include <vector>
#include <cmath>
#include <queue>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <stack>
#include <memory>
using namespace std;
#define ll long long
#define yes cout << "YES\n"
#define no cout << "NO\n"

void solve()
{
    int n;
    cin >> n;
    set<int> a;
    for (int i = 0; i < n; i++)
    {
        int x; cin >> x;
        a.insert(x);
    }
    int sizeofa = a.size();
    int mex = 1;
    for (auto x : a)
    {
        if (x == mex)
        {
            mex++;
        }
    }
    mex--;
    if (mex >= sizeofa)//mex把数组中元素都遍历了一遍，且1~mex-1（sizeofa）都有了，故A是一个连续数组
    {
        //此时就取决于a中不同元素的数量
        cout << (sizeofa % 2 == 1 ? "Alice" : "Bob") << endl;
    }
    else
    {
        //此时看选完所有1后谁先手
        cout << (mex % 2 == 0 ? "Alice" : "Bob") << endl;
    }
}

int main()
{
    cin.tie(0)->sync_with_stdio(false);
    int t = 1;
    cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

C. Permutation Counting

(非常好题目，使我的思维旋转)

题目：

思路：

先说做法：二分答案 + 思维（构造）

对于题目要求，既然我们要增加答案，那我们肯定要构造越多的1~n排列越好，而排列的数量取决于所有数字的最小值，但是这个最小值不好求，因为k的范围高达1e12，因此我们可以使用二分答案的方法，我们可以假设最小值为mid，然后对于每次二分我们就检测所有数与mid相差多少，如果这个数小于mid，那么肯定要分配，否则就不分配，所以我们可以简单求出是否符合

注意二分的check，然后最后我们跳出二分后我们再看看是l更合适还是r更合适

那么我们有了最小数字后，那我们来看看如何构造才能使得答案最大呢？

显然肯定是像如下这样构造

1 2 3 ... n 1 2 3 ... n ...

这样的话每次1都可以与前面的2 3 4 ... n 又构成一个新的排列

这样得出来的答案就是 1 +（min - 1）* n 了

那我们在考虑多的数能不能利用呢？

比如1 2 3 3 2，如果按上诉排，那么就是 1 2 3 2 3这样了，显然这肯定不是最优的，那么我们换一种方式，如 3 2 1 3 2，我们发现这样的答案肯定是最优的，因为多出来的数都利用到了

我们可以形式化的表示构造方法：(多多多 ... 多少少少 ...) * n，表示有n个这样的结构（循环）

这样的话多出来的就可以继续放少的后面再构造一个新的排列（有点贪心的想法）

同时既然这道题不需要我们输出排列方式，那真的省了很大功夫

所以最后的答案就是 1 + （min - 1）* n + add

其中add为每个元素是否多，如果多就加1，表示为( $\sum (a[i] > min)$ )

代码：

#include <iostream>
#include <algorithm>
#include<cstring>
#include<cctype>
#include<string>
#include <set>
#include <vector>
#include <cmath>
#include <queue>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <stack>
#include <memory>
using namespace std;
#define ll long long
#define yes cout << "YES\n"
#define no cout << "NO\n"

ll n, k;
bool check(const vector<ll>& a,ll mid)
{
    ll need = 0;
    for (int i = 0; i < n; i++)
    {
        if (a[i] < mid)
            need += mid - a[i];
    }
    return need <= k;
}

void solve()
{
    cin >> n >> k;
    vector<ll> a(n);
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];
    }
    ll l = 0,r = 2e12;
    while (l+1 < r)
    {
        ll mid = l + r >> 1;
        if (check(a,mid))
        {
            l = mid;
        }
        else
        {
            r = mid;
        }
    }
    ll mn = check(a,r) ? r : l;
    ll add = 0;
    for (int i = 0; i < n; i++)
    {
        if (a[i] < mn)
        {
            ll need = mn - a[i];
            a[i] += need;
            k -= need;
        }
    }
    for (int i = 0; i < n; i++)
    {
        if (a[i] == mn && k)
        {
            k--;
            a[i]++;
        }
        if (a[i] > mn)
        {
            add++;
        }
    }
    ll ans = n * (mn - 1) + 1 + add;
    cout << ans << endl;
}

int main()
{
    cin.tie(0)->sync_with_stdio(false);
    int t = 1;
    cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}