贝塔编程2022寒假模拟赛进阶组

模拟赛第一天

---

目录

• 模拟赛第一天
  • T1.活动安排
    • 描述：
    • 输入：
    • 输出：
    • 思路：
  • T2.光与暗的交错2
    • 描述：
    • 输入：
    • 输出：
    • 思路：
  • T3.休息站点
    • 描述：
    • 输入：
    • 输出：
    • 思路：

T1.活动安排

描述：

现有n个活动，其中每个活动都会使用同一资源（如演讲会场等），而在同一时间内只有一个活动能使用这一资源，所以有些活动相互冲突。

每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi，且si < fi。如果选择了活动i，则它在时间区间[si, fi)内占用资源。

若区间[si, fi)与区间[sj, fj)不相交，则称活动i与活动j是相容的。

输入：

第一行一个整数，表示活动的数量n；

接下来的n行，每行两个整数si和fi，表示第i个活动的开始和结束时间。

输出：

输出互相兼容的最大活动个数。

输入样例 1

4
1 3
4 6
2 5
1 7

输出样例 1

2

提示

1 ≤ n ≤ 1000

思路：

这题使用结构体做，做一个结构体排序即可，排序的内容是我对每个活动的结束时间进行排序，结束最早的最先被录取，其次向后寻找开始时间大于前一个活动的结束时间。

// @Class name:Cold_Day1_T1
// @Description ToDo
// @Author: Amadues
// @Date 2022/1/12 11:21
// @Version 0.0
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
struct Contest
{
    int begin;
    int end;
};

Contest contests[1000];

bool compare(Contest a, Contest b)
{
    return a.end < b.end;
}
int main()
{
    int N;
    scanf("%d", &N);
    for (int i = 1; i <= N; i++)
    {
        scanf("%d %d", &contests[i].begin, &contests[i].end);
    }
    sort(contests + 1, contests + 1 + N, compare);
    int ans = 1;
    int j = 1;
    for (int i = 2; i <= N; i++)
    {
        if (contests[i].begin >= contests[j].end)
        {
            ans++;
            j = i;
        }
    }
    printf("%d\n", ans);
    return 0;
}

T2.光与暗的交错2

描述：

贝塔科技的最新游戏《决战信奥大陆》上线啦！！！做为游戏和编程双料爱好者的你，立刻迫不及待的去体验这双倍的快乐！！！

击败第一个BOSS后，很快你又在练级过程中遇到了第二个BOSS----光暗双子Beta。Beta的技能是释放一个暗の数组B，而你必须在1s内求出其对应的光の数组A，才能对其造成有效伤害。

光の数组A是一个存放N个正整数的数组，光の数组A中无序的存放着正整数1~N。

光の数组A的对立面是暗の数组B，暗の数组B的定义如下：

• B[0]的为0；
• B[i]（i ≠ 0）的值为A[0]、A[1]、...、A[i - 1]中，值比A[i]小的数字的个数

例如：

N=6时，有光の数组A = {4, 3, 6, 5, 1, 2}

对应的暗の数组B为：B= {0, 0, 2, 2, 0, 1}

现给出暗の数组B中的所有元素，请你求出光の数组A中的所有元素，并将其顺序输出，从而对BOSS造成有效伤害。

输入：

输入的第一行会输入一个正整数N，表示光の数组A的大小。

输入的第二行会输入N个正整数，表示暗の数组B中的每个数字，数字间以空格分隔。

输出：

输出仅一行，按顺序输出光の数组A中的每个元素，数字间以空格分隔。

输入样例 1

6
0 0 2 2 0 1

输出样例 1

4 3 6 5 1 2

提示

1 <= N <= 10^3

思路：

从后向前找就行。

#include <iostream>
#include <algorithm>
using namespace std;
int a[1010], b[1010], c[1010];
int n;
int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> b[i];
        c[i] = i;
    }
    for (int i = n; i >= 1; i--)
    {
        int t = b[i];
        a[i] = c[t + 1];
        c[t + 1] = 9999;
        sort(c + 1, c + 1 + n);
    }
    for (int i = 1; i <= n; i++)
    {
        cout << a[i] << " ";
    }
    return 0;
}

T3.休息站点

描述：

Farmer John和他的私人教练Bessie正在徒步攀登温哥牛山。基于他们的目的（也是你的目的），这座山可以用一条长为L米（1≤L≤10^6）的长直路径表示。Farmer John会沿着这条路径以每米rF秒（1≤rF≤10^6）的固定速度攀登。由于他正在训练他的耐力，他在途中不会进行任何的休息。

然而Bessie可以在休息站休息，在那里她能够找到一些美味的嫩草。当然，她也不能在任何地方都休息！在路径上总共有N个休息站（1≤N≤10^{5）；第i个休息站距离路径的起点xi米（0<xi<L），美味值为ci（1≤ci≤10}6）。如果Bessie在休息站i休息了t秒，她能够得到ci*t个美味单位。

不在休息站的时候，Bessie会以每米rB秒（1≤rB≤10^6）的固定速度攀登。由于Bessie年轻而健康，rB严格小于rF。

Bessie想要吃到最多的美味嫩草。然而她也担心Farmer John；她认为如果在任何时候她位于Farmer John身后，Farmer John可能就会失去前进的动力了！

帮助Bessie求出，在确保Farmer John能够完成登山的情况下，她能够获得的最多的美味单位。

输入：

输入的第一行包含四个整数：L，N，rF，以及rB。

下面N行描述了休息站。对于1至N之间的每一个i，第i+1行包含了两个整数xi和ci，描述了第i个休息站的位置和那里的草的美味值。

输入保证rF>rB，并且0<x1<⋯<xN<L。

注意rF和rB的单位为秒每米！

输出：

输出一个整数：Bessie可以获得的最多的美味单位。

输入样例 1

10 2 4 3
7 2
8 1

输出样例 1

15

提示

在这个样例中，Bessie的最佳方案是在位于x=7的休息站停留7秒（获得14个美味单位），再在位于x=8的休息站停留1秒（再获得1个美味单位，总共是15个美味单位）。

思路：

判断就完事，首先得把草地按照美味程度进行一个排序，肯定去找最美味的草去吃。

// @Class name:Cold_Day1_T3
// @Description ToDo
// @Author: Amadues
// @Date 2022/1/12 11:56
// @Version 0.0
#include <iostream>
#include <algorithm>

using namespace std;

#define io_opt                   \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0);
long long l, n, v1, v2, ans, cao;

struct node
{
    long long a, b;
} a[100001];

bool cmp(node sb1, node sb2)
{
    return sb1.b > sb2.b;
}

int main()
{
    io_opt;
    cin >> l >> n >> v1 >> v2;
    for (long long i = 1; i <= n; i++)
    {
        cin >> a[i].a >> a[i].b;
    }
    sort(a + 1, a + n + 1, cmp);
    for (long long i = 1; i <= n; i++)
    {
        if (a[i].a * v2 + cao <= a[i].a * v1)

        {
            ans += (a[i].a * v1 - a[i].a * v2 - cao) * a[i].b;

            cao = a[i].a * v1 - a[i].a * v2;
        }
    }
    cout << ans;
    return 0;
}