2023牛客寒假算法集训营5

---

A. 小沙の好客（贪心 + 排序 + 前缀和 + 二分）

题意：

有一家超市，里面有 $n$ 件商品。

有 $Q$ 个问题，每次询问要求挑选最多 $k$ 个价值不大于 $x$ 的商品，问能挑选的价值和最大为多少。

思路：

要价值最大，那必然是先选价值为 $x$ 的商品，再从大到小挑选价值小于 $x$ 的商品，直到选完 $k$ 个，如果不满 $k$ 个，但没有可选的商品时那也只能结束挑选。

所以先对商品按从小到大的价值 排序，由于数据量较大，要先用 二分 找到可选的最大商品，同时用 前缀和 记录下当前商品的总价值。

又因为可以选择价值为 $x$ 的商品，所以可以用函数 upper_bound() 找到第一个大于 $x$ 的商品，并返回其下标，假设为 $p$ ，那么如果有超过 $k$ 个商品满足条件，则返回 $p$ 前面 k个的前缀和，若不足 $k$ 个，则返回 $p$ 前面所有的前缀和。

代码：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
const int N = 1e5 + 10;

int n, q;
ll a[N], s[N];

void solve()
{
    cin >> n >> q;
    
    for (int i = 1; i <= n; i++){
        cin >> a[i];
    }
    
    sort(a + 1, a + 1 + n);
    
    for (int i = 1; i <= n; i++)
        s[i] = s[i -1] + a[i];
    
    while (q--){
        ll k, x;
        cin >> k >> x;
        
        ll res = 0;
        ll p = upper_bound(a + 1, a + 1 + n, x) - a;
        p--;
        if (p < k){
            res = s[p];
        }
        else {
            res = s[p] - s[p - k];
        }
        
        cout << res << endl;
    }
}

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

    return 0;
}

---

B. 小沙の博弈（贪心 + 字典序）

题意：

小沙和小雅在玩"拿石子游戏"，他们两个人都十分聪明，均会选择最优的方法使得自己获胜。桌子上有 $n$ 个石子 ，他们两个人面前均有排成一行的若干个格子，每个格子都可以置放无限多个石子。

小沙和小雅两个人交替进行操作，小沙先手，每次操作可以从桌子上拿走任意正整数个石子，将其置放于自己面前第一个没有石子的格子里。

当桌上的石子数为 $0$ 时游戏结束，按照两人格子中石子数目组成序列的字典序判断胜负，字典序小的人获胜。

字典序：你有两个序列 $a$ 和 $b$ ，两个序列从前往后第一个不相同的字符分别为 $a_i$ ​, $b_i$ ​，如果 $a_i<b_i$ ​，那么我们称序列 $a<b$ 。如果两个序列完全相同，那么他们的字典序相等。

思路：

因为字典序小的获胜，那么每次放石子都放最少的 1 个石子。

若 $n$ 为偶数，则两人的字典序一样，平局。

若 $n$​ 为奇数，则先手的人还需要多放一次 1 个石子，即先手必输。

（也就是说，小沙永远也不可能赢🤣）

代码：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
const int N = 2e5 + 10;

int main()
{
    int n;
    cin >> n;
    
    if (n % 2 == 0){
        cout << "win-win!" << endl;
    }
    else {
        cout << "Yaya-win!" << endl;
    }
    
    return 0;
}

---

C. 小沙の不懂（贪心）

题意：

有两个数字字符串 $a$ , $b$ ，同时还有个下标从 $0$ 开始的，数字为 $0$ 到 $9$ 的，长度为 $10$ 的排列 $p$ 。

在将这两个数字给你之前，会对这两个数的每一位数进行一次 $a_i:=p_{a_i}$ 的操作。

现要求判断这两个数在进行 $a_i:=p_{a_i}$​ 之前谁大谁小

• 如果在每一种情况中 $a>b$ ，则输出 “>” 。

• 如果在每一种情况中 $a<b$ ，则输出 “<” 。

• 如果在每一种情况中 $a=b$ ，则输出 “=” 。

• 否则 $a\ne b$ ，则输出 “!” 。

由于不知道排列 $p$，所以需要分辨出所有可能的情况下原来的数字 $a$ 和 $b$ 的大小关系是否相同。

注：原来的数字可能存在前导零。

思路：

分类讨论：

• 当长度一样时，只要两个串不一样，就是不等于，否则等于。

• 当长度不一样时，长的不一定大，需要逐个判断。

  • 先交换，使其短串为 $a$ ，长串为 $b$ ，减少二次比较
  • 如果相差的字符只有 $1$ 个，再依次枚举两串中的字符，如果都与其不同，那就等于，否则不等于。
  • 其他情况均不等于。

（太难了，插个眼）⛳

代码：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
const int N = 1e5 + 10;

char a[N], b[N];

int main()
{
    cin >> a + 1 >> b + 1;
    int n1 = strlen(a + 1);
    int n2 = strlen(b + 1);

    if (n1 == n2){
        int eq = 1;  //标记字符相等
        for (int i = 1; i <= n1; i++){
            if (a[i] != b[i]){
                eq = 0;
                break;
            }
        }

        if (eq) puts("=");
        else puts("!");
        
        return 0;
    }

    //标记是否交换，一般短串为a，长串为b
    int sw = 0;  
    if (n1 > n2){
        sw = 1;
        for (int i = 1; i <= n1; i++){
            swap(a[i], b[i]);
        }
        swap(n1, n2);
    }

    set<char> st;  //存多余的部分
    for (int i = 1; i <= n2 - n1; i++){
        st.insert(b[i]);
    }

    if (st.size() == 1){
        char ch = *st.begin();
        for (int i = 1; i <= n1; i++){
            if (a[i] != b[n2 - n1 + i]){
                if (a[i] != ch && b[n2 - n1 + i] != ch){
                    puts("!");
                    return 0;
                }
                else if (a[i] == ch){
                    if (!sw) puts("<");
                    else puts(">");
                    return 0;
                }
                else if (b[i] == ch){
                    puts("!");
                    return 0;
                }
            }
        }

        puts("!");
    }
    else {
        //如果前面交换了则需要输出相反的答案
        if (!sw) puts("<");
        else puts(">");
    }

    return 0;
}

---

D. 小沙の赌气（区间合并）

题意：

小沙和小雅在一起打游戏。

假设小沙和小雅都从第一关开始，他们必须一关一关通，只有通过了第 $x$ 关，第 $x+1$ 关才会解锁。

每次同时卡关他们各自会获得了一个道具，第 $i$ 个道具可以使他们通过 $[l_i,r_i]$ 之间的每一关。

现询问在每次获得道具后，谁会领先，领先多少。

思路：

左端点从 $1$​ 开始的区间合并问题，只有区间有重复部分才能够覆盖更新区间长度，每次比较区间的长度，并输出相差的长度。

我们用 set<pair<int, int> > s1, s2 来分别存储两个人的区间，然后循环遍历，更新区间右端点，将已使用过的区间删掉，直至 set 为空退出循环。

set 对 pair<int, int> 排序是先比较第一个元素，若相等再比较第二个元素。

代码：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'
#define PII pair<int, int>
using namespace std;
const int N = 1e5 + 10;

int n;
set<PII> s1, s2;
int l1[N], r1[N];
int l2[N], r2[N];

void solve(set<PII> &st, int l, int r, int &R)
{
    st.insert({l, r});
    PII L = (*st.begin());
    while (L.first <= R){
        R = max(R, L.second + 1);
        st.erase(st.begin());

        if (st.empty()) return;

        L = (*st.begin());
    }
}

int main()
{
    cin >> n;
    
    for (int i = 1; i <= n; i++){
        cin >> l1[i] >> r1[i];
    }

    for (int i = 1; i <= n; i++){
        cin >> l2[i] >> r2[i];
    }

    int sum1 = 1, sum2 = 1;
    for (int i = 1; i <= n; i++){
        solve(s1, l1[i], r1[i], sum1);
        solve(s2, l2[i], r2[i], sum2);

        if (sum1 > sum2) puts("sa_win!");
        else if (sum1 < sum2) puts("ya_win!");
        else puts("win_win!");

        printf("%d\n", abs(sum1 - sum2));
    }

    return 0;
}

---

E. 小沙の印章（构造 + 冒泡）

题意：

有 $n$ 个人玩游戏，围成一个环， 编号从 $1$ 到 $n$ ，一开始每个人都有一个与其他人不同的印花，与自己的编号相同。

每个人都可以获得他相邻的两个人的印花。

在每轮游戏中，每个人可以选择和他相邻的其中一个人组成一对，也可以不组，然后交换位置。

要求设计一种交换方案，使得在 $n$​ 轮游戏后，每个人都可以获得所有的印花。

思路：

（又是诈骗题我靠难的一批）插眼⛳

不要把它看成是环，拉成直线，冒泡排序，每次交换相邻两个数即可。

代码：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
const int N = 1010;

int n;
int a[N];

int main()
{
    cin >> n;

    cout << n << endl;
    for (int i = 1; i <= n; i++){
        a[i] = i;
    }

    for (int i = 1; i <= n; i++){
        if (n % 2) cout << n / 2 << endl;
        else {
            if (i % 2) cout << n / 2 << endl;
            else cout << n / 2 - 1 << endl;
        }

        for (int j = 1; j <= n; j++){
            if (a[j] < a[j + 1]){
                cout << a[j] << ' ' << a[j + 1] << endl;
                swap(a[j], a[j + 1]);
                j++;
            }
        }
    }

    return 0;
}

---

F. 小沙の串串（贪心 + 字典序）

题意：

有一个长度为 $n$ 的字符串， 给定 $k$ 次操作。

每次操作可以任意选择一个字符，将其移动到字符串的最后。

要求找到恰好 $k$ 次操作后，字符串的字典序最大，输出字符串。

思路：

（难题–插眼⛳）

从第一个字母开始遍历，找到后面第二大的字母，删除中间的字符串，存放到另外的字符数组中，重复操作，最后在后面加上删除的且也是按从大到小排序的字符数组，使得前面的字母大后面的字母小。

另外也有大佬的线段树做法

代码：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
const int N = 1e5 + 10;

int n, k;
char s[N];

int main()
{
    cin >> n >> k;
    cin >> s + 1;

    queue<int> q[30];  //用来存储26个字母
    for (int i = 1; i <= n; i++){
        q[s[i] - 'a'].push(i);
    }

    int p = 1;  //下标从1开始遍历
    string s1, s2, s3;
    while (k){
        for (int i = 25; i >= 0; i--){
            while (!q[i].empty() && q[i].front() < p){
                q[i].pop();
            }

            //若不为空且可操作
            if (!q[i].empty() && q[i].front() <= p + k){
                int nxt = q[i].front();
                q[i].pop();
                k -= (nxt - p);
                while (p < nxt){
                    s2 += s[p];
                    p++;
                }

                s1 += s[p];
                p++;
                break;
            }
        }

        if (p == n + 1) break;
    }

    for (int i = p; i <= n; i++) s3 += s[i];

    while (k && !s1.empty()){
        assert(s3.size() == 0);
        s2 += s1[s1.size() - 1];
        s1.pop_back();
        k--;
    }

    sort(s2.begin(), s2.end());
    reverse(s2.begin(), s2.end());
    string res = s1 + s3 + s2;
    cout << res << endl;

    return 0;
}

---

H. 小沙の店铺（模拟）

题意：

新开了一个商铺，物品初始定价为 $x$ ，而后每卖出去 $k$ 件的商品数，单价便上涨 $y$ 元。

现有 $n$ 个客户来购买商品，第一个客户购买 $n$ 个物品，第二个购买 $n-1$ 个依次递减，客户的顺序无法改变。

请问想要卖出去至少 T 元，至少需要接待多少个客户。每次涨价都是在客户买完之后，即每个客户在购买时，价格不会变化。

如果接待完 $n$ 个客户都没有卖出去至少 $T$ 元的货物的话，输出 $-1$ 。

思路：

模拟即可。

要注意的是 在客户购买时商品不涨价。

只需要在 循环 中记录下当前共卖出了多少件商品，计算出当前顾客购买时的价格，满足条件后退出即可。

代码：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
const int N = 2e5 + 10;

ll x, y, k, n, t;

int main()
{
    cin >> x >> y >> k >> n >> t;
    
    ll ans = 0;
    ll cnt = 0;  //已经卖出多少件
    ll res = 0;  //第几个客户
    ll v = 0;    //当前客户的价格上涨幅度
    while (n){
        if (ans >= t) break;
        ans += (x + v) * n;
        cnt += n;
        v = (cnt / k) * y;
        n--;
        res++;
    }
    
    if (ans < t) cout << -1 << endl;
    else cout << res << endl;

    return 0;
}

---

I. 小沙の金银阁（思维 + 前缀和）

题意：

有 $n$ 轮游戏， $m$ 个灵石。

有一个游戏，规则是：每轮游戏开始前需要压下一定的灵石（玩家可任意压，不得超过自己所带灵石上限），如果失败，则输掉该轮压的所有灵石，如果获胜则赢得该轮所压灵石以及本金。

有一名玩家，他在接下来的 $n$ 轮游戏中，仅有一场能获胜，其他均会失败。

现需要给这名玩家设计一个最优方案，当他获胜后就退出游戏。

保证所有轮游戏所压的灵石总是不超过 $m$ ，如果没有方案能赚取灵石，输出 -1 。

在能必定不会亏灵石的条件下（你可以玩完 $n$ 轮下来，一分钱没赚），对于任意的另一个方案，在第 $X$ 轮获胜的时候，前 $X-1$ 轮，每轮结束之后剩余灵石相同，第 $X$ 轮获胜时总灵石越多，则该方案优于其它方案。

例如：

游戏轮数为 3 ，灵石数为 11 。
方案1为： 2 , 3 , 6 。
方案2为： 2 , 2 , 7 。
则方案 1 更优，因为方案 1 第 2 轮获胜之后，有 12 个灵石，方案 2 ，第二轮获胜只拥有 11 个灵石。

思路：

转化为构造一个序列，满足：

1. $a_i\ge a_1+a_2+...+a_{i-1}$
2. 字典序尽量大
3. $a_1+a_2+...+a_n\le m$​

即序列的某个元素要大于等于它前面的前缀和，即 $a_i\ge s_{i-1}$ .

所以可以从后往前构造，a[n] = m ，a[i - 1] = a[i] / 2 ，当 a[1] == 0 时，表示不满足条件，输出 -1，否则输出全部序列。

代码：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
const int N = 2e5 + 10;

ll a[N];

int main()
{   
    ll n, m;
    cin >> n >> m;

    a[n] = m;
    for (int i = n; i >= 1; i--){
        a[i - 1] = a[i] / 2;
    }

    if (a[1] == 0){
        cout << "-1" << endl;
    }
    else {
        cout << a[1] << ' ';
        for (int i = 2; i <= n; i++)
            cout << a[i] - a[i - 1] << ' ';
        cout << endl;
    }

    return 0;
}

---

K. 小沙の抱团 easy（贪心）

题意：

有 $n$​ 个人玩抱团游戏。

要求以 $x$ 人为一个团，每个回合可以有多个团，当某个人不能融入到某个恰好 $x$ 个人的团中，则被淘汰出局。每个回合的 $x$ 可以任意规定。

请问最少需要多少个回合才能使得剩余的人数最少。

思路：

贪心的思维，要使剩下的人最少，那么每次淘汰的人要尽可能的多。

可以分成两团，一团是多的，一团是少的，每次都会淘汰人少的团。

如果 $n$ 是偶数，那就对半分后将一个团中的一个人加到另一个团中去，然后淘汰这个团中的所有人；
如果 $n$ 是奇数，同样对半分后剩下的那个团中的人数 +1 。

最后剩下的团中的人数会等于 $2$ ，再小的话就无法淘汰人了。

整理一下，每次淘汰后剩余的人数为 n / 2 + 1 。

代码：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
const int N = 2e5 + 10;

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    
    ll n;
    cin >> n;
    
    int res = 0;
    while (n > 2){
        n = n / 2 + 1;
        res++;
    }
    
    cout << res << endl;

    return 0;
}

---

L. 小沙の抱团 hard（DP）

题意：

与 $k$ 题类似，有 $n$ 个人玩一个抱团游戏，每次有 $m$ 条指令可以下达。

对于第 $i$ 条指令可以花费 $b_i$ 的代价，要求以 $x_i$ 人为单位抱团，每个人只能在一个团里，若一个人不属于某一个恰好 $x_i$ 个人的团则被淘汰。

问最少需要花费多少代价才能使得剩余的人数最少。

注：每个指令都可以重复使用。

思路：

用一种不同的递归方式去 $dp$ ，形如 (i, j) -> (i + 1, j + w) .

定义 dp[i] 为人数变为 $i$ 所需要的最小花费，所以 dp[n] = 0 .

从 $n$ 到 $1$ 去枚举 $i$ ，对于每一种情况去枚举花费，当 x[i] < i 时，更新最小花费，dp[i - i%x[j]] = min(dp[i - i%x[j]], dp[i] + b[j]) 。

再遍历一遍 $dp$ 数组，当它不是无穷大时，即是最小花费，输出即可。

代码：

#include <bits/stdc++.h>
#define ll long long
#define endl '\n'
#define INF 0x3f3f3f3f
using namespace std;
const int N = 1e5 + 10;

int dp[N];
int b[N], x[N];

int main()
{
    int n, m;
    cin >> n >> m;
    
    memset(dp, 0x3f, sizeof dp);
    
    for (int i = 1; i <= m; i++){
        cin >> b[i] >> x[i];
    }
    
    dp[n] = 0;
    for (int i = n; i >= 1; i--){
        for (int j = 1; j <= m; j++){
            if (x[j] < i){
                int p = i - i % x[j];   //剩余人数
                dp[p] = min(dp[p], dp[i] + b[j]);
            }
        }
    }
    
    for (int i = 1; i <= n; i++){
        if (dp[i] != INF){
            cout << dp[i] << endl;
            break;
        }
    }

    return 0;
}

---