Codeforces Round 995 (Div. 3)

A. Preparing for the Olympiad

题目描述

Monocarp 和 Stereocarp正在准备奥林匹克。现在仅剩 $n$ 天奥林匹克就要开始了。在这第 $i$天，如果Monocarp 准备训练，那么他将完成$a_i$题，同样的，如果Stereocarp也在这天准备训练，那么他将完成$b_i$题。

Monocarp 可以在任意一天进行训练，然而，Stereocarp在观察他，并且学习他的计划：如果Monocarp在第$i$（$i<n$）天进行训练,那么Stereocarp将在第（$i+1$）天进行训练。

Monocarp想要制定一个计划使得他与Stereocarp的训练题目量相差最大。形式化的：Monocarp想要使（$m-s$）的值最大，其中$m$表示他完成的题目量，$s$表示Stereocarp完成的题目量s是立体果解决的问题数。帮助Monocarp确定他们之间解决问题数量的最大可能差。

输入格式

第一行包含一个单独的整数$t$（$1\le t<103$）测试用例的数量。

每个测试用例的第一行包含单个整数$n（1<n<100）$。

第二行包含n个整数$a_1,a_2,...a_n（a_i\le 100）$。

第三行包含n个整数$b_1，b_2,...,b_n（1<b<100）$。

输出格式

对于每个测试，输出一个整数：Monocarp解决的问题数量和Stereocarp解决的问题数量之间的最大可能差。

输入输出样例 #1

输入 #1

4
2
3 2
2 1
1
5
8
3
1 1 1
2 2 2
6
8 2 5 6 2 6
8 2 7 4 3 4

输出 #1

4
5
1
16

说明/提示

在第一个测试用例中，Monocarp最好两天都训练；然后Stereocarp将在第二天训练

在第二个测试用例中，Monocarp最好在唯一一天训练，Stereocarp根本不会训练。

在第三个测试用例中，Monocarp最好在最后一天训练（而且只在当天）。

在第四个测试用例中，Monocarp最好在几天内训练1,3,4,6; 然后Stereocarp将训练2,4,5天

本翻译来自洛谷

题解

#include 

using namespace std;

int main(){
    int t;
    cin>>t;
    vector a;
    vector b;
    vector ans;
    while(t--) {
        int n=0,num=0,temp=0;
        cin>>n;
        for(int i=0;i>num;
            a.push_back(num);
        }
        for(int i=0;i>num;
            b.push_back(num);
        }
        for(int i=0;ib[i+1]) {
                temp+=a[i]-b[i+1];
            }
        }
        temp+=a[n-1];
        ans.push_back(temp);
        a.clear();
        b.clear();
    }
    for(auto i:ans) {
        cout<

B. Journey

题目描述

Monocarp 决定去进行一次漫长的徒步旅行。

他计划，第一天走 $a$ 公里，第二天走 $b$ 公里，第三天走 $c$ 公里，到第四天再像第一天那样走 $a$ 公里，第五天如同第二天走 $b$ 公里，第六天则重复第三天走 $c$ 公里，如此循环下去。

当他走过的总路程达到至少 $n$ 公里时，就完成了整个旅程。你的任务是找出 Monocarp 在哪一天达到了这个目标。

输入格式

输入的第一行包含一个整数 $t$，表示测试用例的数量（$1\le t\le 10^4$）。

接下来的每一行包含四个整数 $n$、$a$、$b$、$c$，分别代表每个测试用例的数据（$1\le n\le 10^9$; $1\le a,b,c\le 10^6$）。

输出格式

对于每个测试用例，输出一个整数，表示 Monocarp 在走满至少 $n$ 公里并结束旅行的那一天。

输入输出样例 #1

输入 #1

4
12 1 5 3
6 6 7 4
16 3 4 1
1000000000 1 1 1

输出 #1

5
1
6
1000000000

说明/提示

在第一个例子中，Monocarp 在前四天总共走了 $1+5+3+1=10$ 公里。到了第五天，他又走了 $5$ 公里，总数达到 $15$ 公里。因为 $n=12$，所以 Monocarp 在第五天实现了目标，完成了旅程。

在第二个例子中，Monocarp 第一天就走了 $6$ 公里。而由于 $n=6$，他实际上一天就完成了旅程。

在第三个例子中，Monocarp 在六天内的总行程为 $3+4+1+3+4+1=16$ 公里。因为 $n=16$，所以他在第六天达成旅程目标。

本翻译来自洛谷

题解

#include 

int main(){
  int t;
  std::cin >> t;
  int n, a, b, c;
  while(t--){
    std::cin >> n >> a >> b >> c;
    int res = 0;
    res = n / (a + b + c) * 3;
    n %= a + b + c;
    if(n != 0)  res = n <= a ? res + 1 : n <= a + b ? res + 2 : res + 3;
    std::cout << res << std::endl;
  }
  
  return 0;
}

C. Preparing for the Exam

题目描述

Monocarp 正在为他的第一场大学考试做准备。这场考试可能会涉及到 $n$ 个不同的问题，编号从 $1$ 到 $n$。一共有 $m$ 个不同的问题列表，每个列表包含正好 $n-1$ 个不同的问题。对于每个列表 $i$，用一个整数 $a_i$ 指定唯一没有出现在第 $i$ 个列表中的问题。例如，当 $n=4$ 且 $a_i=3$ 时，第 $i$ 个列表里有问题 $[1,2,4]$。

在考试的时候，Monocarp 将会拿到其中的一个问题列表，然后老师会要求他回答列表中所有的问题。要通过考试，Monocarp 必须回答列表中所有问题。

Monocarp 已经掌握了 $k$ 个问题的答案，这些问题编号是 $q_1,q_2,\dots ,q_k$。请判断对于每一个问题列表，Monocarp 是否能够通过考试。

输入格式

第一行输入一个整数 $t$，表示测试用例的数量（$1\le t\le 10^4$）。

每个测试用例包含以下三行：

• 第一行给出三个整数 $n$、$m$ 和 $k$（$2\le n\le 3\times 10^5$；$1\le m,k\le n$）；
• 第二行包含 $m$ 个不同的整数 $a_1,a_2,\dots ,a_m$（$1\le a_i\le n$；$a_i<a_{i+1}$）；
• 第三行包含 $k$ 个不同的整数 $q_1,q_2,\dots ,q_k$（$1\le q_i\le n$；$q_i<q_{i+1}$）。

注意：所有测试用例中 $n$ 的总和不超过 $3\times 10^5$。

输出格式

对于每个测试用例，输出一个长度为 $m$ 的由 ‘1’ 和 ‘0’ 组成的字符串。如果 Monocarp 能通过这个问题列表，则对应位置输出 ‘1’，否则输出 ‘0’。

输入输出样例 #1

输入 #1

4
4 4 3
1 2 3 4
1 3 4
5 4 3
1 2 3 4
1 3 4
4 4 4
1 2 3 4
1 2 3 4
2 2 1
1 2
2

输出 #1

0100
0000
1111
10

说明/提示

在第一个测试用例中，Monocarp 已掌握的问题是 $[1,3,4]$。我们来看所有的问题列表：

• 第一个列表的问题是 $[2,3,4]$。Monocarp 不懂第 $2$ 个问题，所以不能通过；
• 第二个列表的问题是 $[1,3,4]$。Monocarp 知道这些问题，因此能通过；
• 第三个列表的问题是 $[1,2,4]$。Monocarp 不懂第 $2$ 个问题，所以不能通过；
• 第四个列表的问题是 $[1,2,3]$。Monocarp 不懂第 $2$ 个问题，所以不能通过。

本翻译来自洛谷

题解

#include 

int main(){
  int t;
  std::cin >> t;
  int n, m, k;
  while(t--){
    std::cin >> n >> m >> k;
    int sum = 0, target = 0;
    for(int i = 1; i <= n; i++) target += i;
    std::vector arr_1(m), arr_2(k);
    for(int i = 0; i < m; i++) {
      std::cin >> arr_1[i];
    }
    for(int i = 0; i < k; i++) {
      std::cin >> arr_2[i];
      sum += arr_2[i];
    }
    std::string res = "";
    if(k < n - 1) {
      while(m--) res += "0";
      std::cout << res << std::endl;
    }else if(k >= n) {
      while(m--) res += "1";
      std::cout << res << std::endl;
    }else {
      for(int i = 0; i < m; i++) {
        if(sum + arr_1[i] != target) res += "0";
        else res += "1";
      }
      std::cout << res << std::endl;
    }
  }
  
  return 0;
}

E. Best Price

题目描述

伯兰德最大的商店收到了一批圣诞树，并已有 $n$ 位顾客前来欲购这些树。在销售启动前，商店需要统一为每棵树定价。为了合理制定价格，商店掌握了关于每位顾客的一些信息。

对于第 $i$ 位顾客，有两个已知整数 $a_i$ 和 $b_i$，它们定义了顾客的购物行为：

• 如果价格不超过 $a_i$，顾客将购买一棵树并给出正面评价；
• 如果价格超过 $a_i$ 但不超过 $b_i$，顾客仍会购买，但会留下负面评价；
• 如果价格高于 $b_i$，则顾客将不会购买。

在负面评价不超过 $k$ 条的前提下，你的任务是帮助商店计算出最大的可能收益。

输入格式

第一行是一个整数 $t$（$1\le t\le 10^4$），表示测试用例的数量。

接下来的每个测试用例，第一行包含两个整数 $n$ 和 $k$（$1\le n\le 2\cdot 10^5$，$0\le k\le n$），分别表示顾客数量和允许的最大负面评价数。

第二行是 $n$ 个整数 $a_1,a_2,\dots ,a_n$（$1\le a_i\le 2\cdot 10^9$），分别表示每位顾客给出正面评价的最高价格。

第三行是 $n$ 个整数 $b_1,b_2,\dots ,b_n$（$1\le b_i\le 2\cdot 10^9$ 且 $a_i<b_i$），表示顾客购买的最高价格。

输入的附加限制是：所有测试用例中 $n$ 的总和不超过 $2\cdot 10^5$。

输出格式

对于每一个测试用例，输出一个整数，即在满足负面评价不超过 $k$ 条的情况下，商店可能获得的最大收益。

输入输出样例 #1

输入 #1

5
2 0
2 1
3 4
1 1
2
5
3 3
1 5 2
3 6 4
4 3
2 3 2 8
3 7 3 9
3 1
2 9 5
12 14 9

输出 #1

2
5
9
14
15

说明/提示

考虑以下例子：

• 在第一个测试用例中，如果价格设为 $1$，两位顾客都会各买一棵树且没有负面评价。
• 在第二个测试用例中，如果价格设为 $5$，顾客会购买一棵树且给出一条负面评价。
• 在第三个测试用例中，如果价格定为 $3$，所有顾客会购买且将收到两条负面评价。
• 在第四个测试用例中，价格定为 $7$ 时，有两位顾客购买，一条负面评价。

本翻译来自洛谷

思路

我们不难发现，最大利润只能是来自数组 $b$（买的人越多越好），如果令 cnt_ok 为购买并且给予好评的人数，而 cnt_sum 为购买的总人数，那么 cnt_sum 减去 cnt_ok 是什么呢？对了，就是那些购买了但是给了差评的顾客，那么只要给了差评的顾客不超过k即可。

题解

#include 

int main(){
  int t, n, k;
  std::cin >> t;
  while(t--) {
    std::cin >> n >> k;
    std::vector a(n), b(n);
    for(int i = 0; i < n; i++) std::cin >> a[i];
    for(int i = 0; i < n; i++) std::cin >> b[i];
    std::sort(a.begin(), a.end());
    std::sort(b.begin(), b.end());
    std::set s(a.begin(), a.end()); 
    s.insert(b.begin(), b.end());
    int cnt_ok = 0, cnt_all = 0;
    long long res = 0;
    for(long long int money : s) {
        long long int cnt_ok = n - (std::lower_bound(a.begin(), a.end(), money) - a.begin());
        long long int cnt_all = n - (std::lower_bound(b.begin(), b.end(), money) - b.begin());
        if(cnt_all - cnt_ok <= k) {
            res = std::max(res, cnt_all * money);
        }
    }
    std::cout << res << std::endl;
  }
  
  return 0;
}