AtCoder Beginner Contest 364 A~F

已于 2024-08-02 16:45:35 修改
阅读量560 收藏 9
点赞数 8
分类专栏： AtCoder 文章标签： 算法 c++ OI ACM-ICPC atcoder
于 2024-08-02 16:42:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Code_Shark/article/details/140874473
版权

A.Glutton Takahashi（模拟）

题意：

高桥打算吃 N N N 道菜。
如果 S i = S_i = Si​=sweet 是 “甜的”，那么他打算吃的 i i i 道菜就是甜的；如果 S i = S_i = Si​=salty 是 “咸的”，那么他打算吃的 i i i 道菜就是咸的。咸的。
如果他连续吃了两道甜菜，他就会感到不适，并且无法再吃任何菜肴。
判断他是否能吃下所有菜肴。

分析：

如果有两个连续sweet出现在字符串中，不包括末尾，那么为Yes，否则为No。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define endl '\n'
#define PII pair<LL, LL>
const int maxn = 2e5 + 5;
const int INF = 1e9;
const int mod = 1e9 + 7;
string s[105];
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    while (t--)
    {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
        {
            cin >> s[i];
        }
        for (int i = 2; i <= n; i++)
        {
            if (s[i] == "sweet" && s[i - 1] == "sweet" && i != n)
            {
                cout << "No" << endl;
                return 0;
            }
        }
        cout << "Yes" << endl;
    }
    return 0;
}

B.Grid Walk（模拟）

题意：

有一个网格，网格中有 H H H 行和 W W W 列。让 ( i , j ) (i, j) (i,j) 表示从上往下数第 i i i 行和从左往上数第 j j j 列的单元格。

如果 C i , j C_{i, j} Ci,j​ 是 .，那么单元格 ( i , j ) (i, j) (i,j) 就是空的，如果 C i , j C_{i, j} Ci,j​ 是 #，那么单元格 ( i , j ) (i, j) (i,j) 就不是空的。

高桥目前位于 ( S i , S j ) (S_i, S_j) (Si​,Sj​) 单元格，他将按照以下规则依次对 i = 1 , 2 , … , ∣ X ∣ i = 1, 2, \ldots, |X| i=1,2,…,∣X∣ 采取行动。

  • 如果 X X X 的 i i i个字符是 L，并且当前单元格左边的单元格是空的，那么他会移动到左边的单元格。否则，他将留在当前单元格中。
  • 如果 X X X 的 i i i个字符是 R，并且当前单元格右边的单元格是空的，那么他将移动到右边的单元格。否则，他将留在当前的单元格中。
  • 如果 X X X 的 i i i个字符是 U，并且当前单元格的上方存在空格，那么他将移动到上方的单元格。否则，他将留在当前的单元格中。
  • 如果 X X X 的 i i i个字符是 D，并且当前单元格下方存在空格，那么他将移动到下方的单元格。否则，他将停留在当前单元格。

输出他完成一系列操作后所在的单元格。

分析：

按照题目要求模拟即可。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define endl '\n'
#define PII pair<LL, LL>
const int maxn = 2e5 + 5;
const int INF = 1e9;
const int mod = 1e9 + 7;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    while (t--)
    {
        int n, m;
        cin >> n >> m;
        int sx, sy;
        cin >> sx >> sy;
        vector<vector<char>> g(n + 1, vector<char>(m + 1));
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                cin >> g[i][j];
            }
        }
        string op;
        cin >> op;
        for (int i = 0; i < op.length(); i++)
        {
            char x = op[i];
            if (x == 'D')
            {
                if (sx + 1 <= n && g[sx + 1][sy] == '.')
                {
                    sx++;
                }
            }
            else if (x == 'U')
            {
                if (sx - 1 > 0 && g[sx - 1][sy] == '.')
                {
                    sx--;
                }
            }
            else if (x == 'R')
            {
                if (sy + 1 <= m && g[sx][sy + 1] == '.')
                {
                    sy++;
                }
            }
            else if (x == 'L')
            {
                if (sy - 1 > 0 && g[sx][sy - 1] == '.')
                {
                    sy--;
                }
            }
        }
        cout << sx << ' ' << sy << endl;
    }
    return 0;
}

C.Minimum Glutton（贪心）

题意：

有 N N N 道菜，其中 i i i 道菜的甜度为 A i A_i Ai​ ，咸度为 B i B_i Bi​ 。

高桥打算将这些 N N N 菜肴按照自己喜欢的顺序排列，然后按照这个顺序吃掉。

他将按照排列顺序吃掉这些菜肴，但是一旦他吃掉的菜肴的总甜度超过 X X X 或总咸度超过 Y Y Y ，他就会停止进食。

求他最后吃掉的菜肴的最少数量。

分析：

为了让更早结束，我们显然只需要考虑其中一种属性。将甜度与咸度分离，分别排序，取符合条件的最小值即可。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define endl '\n'
#define PII pair<LL, LL>
const int maxn = 2e5 + 5;
const int INF = 1e9;
const int mod = 1e9 + 7;
LL a[maxn], b[maxn];
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    while (t--)
    {
        LL n, x, y;
        cin >> n >> x >> y;
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        for (int i = 1; i <= n; i++)
            cin >> b[i];
        sort(a + 1, a + 1 + n);
        sort(b + 1, b + 1 + n);
        LL ans = n;
        LL tmp = 0;
        for (int i = n; i >= 1; i--)
        {
            tmp += a[i];
            ans = i;
            if (tmp > x)
                break;
        }
        tmp = 0;
        LL ans1 = 0;
        for (int i = n; i >= 1; i--)
        {
            tmp += b[i];
            ans1 = i;
            if (tmp > y)
                break;
        }
        cout << n - max(ans, ans1) + 1 << endl;
    }
    return 0;
}

D.K-th Nearest （二分）

题意：

在一条数线上有 N + Q N+Q N+Q 个点 A 1 , … , A N , B 1 , … , B Q A_1,\dots,A_N,B_1,\dots,B_Q A1​,…,AN​,B1​,…,BQ​ ，其中点 A i A_i Ai​ 的坐标为 a i a_i ai​ ，点 B j B_j Bj​ 的坐标为 b j b_j bj​ 。

就每个 j = 1 , 2 , … , Q j=1,2,\dots,Q j=1,2,…,Q 回答下面的问题：

  • 设 X X X 是 A 1 , A 2 , … , A N A_1,A_2,\dots,A_N A1​,A2​,…,AN​ 中最靠近点 B j B_j Bj​ 的 k j k_j kj​点。求点 X X X 与 B j B_j Bj​ 之间的距离。更具体地说，设 d i d_i di​ 是点 A i A_i Ai​ 与 B j B_j Bj​ 之间的距离。将 ( d 1 , d 2 , … , d N ) (d_1,d_2,\dots,d_N) (d1​,d2​,…,dN​) 按升序排序，得到序列 ( d 1 ′ , d 2 ′ , … , d N ′ ) (d_1',d_2',\dots,d_N') (d1′​,d2′​,…,dN′​) 。求 d k j ′ d_{k_j}' dkj​′​ .

分析：

我们先将 a i a_i ai​排序，对于每一个 b i b_i bi​，我们可以二分这个距离是 x x x，然后看 [ t m p − m , t m p + m ] [tmp−m , tmp+m] [tmp−m,tmp+m]的点的数量，如果是大于等于 k k k，则说明该距离是第 k k k小或更大距离，则往小的方向收缩。而统计点的数量则通过两次二分点坐标即可

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define endl '\n'
#define PII pair<LL, LL>
const int maxn = 2e5 + 5;
const int INF = 1e9;
const int mod = 1e9 + 7;
int a[maxn], b[maxn], k[maxn];
int tmp, num, n, q;
bool check(int x)
{
    int idxhigh = upper_bound(a + 1, a + 1 + n, tmp + x) - a;
    int idxlow = lower_bound(a + 1, a + 1 + n, tmp - x) - a;
    idxhigh--;
    int res = idxhigh - idxlow + 1;
    return res >= num;
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    while (t--)
    {
        cin >> n >> q;
        for (int i = 1; i <= n; i++)
            cin >> a[i];
        for (int i = 1; i <= q; i++)
            cin >> b[i] >> k[i];
        sort(a + 1, a + 1 + n);
        for (int i = 1; i <= q; i++)
        {

            tmp = b[i];
            num = k[i];
            int low = 0, high = 2e8;
            while (low < high)
            {
                int mid = low + high >> 1;
                if (check(mid))
                {
                    high = mid;
                }
                else
                    low = mid + 1;
            }
            cout << high << endl;
        }
    }
    return 0;
}

E.Maximum Glutton （dp）

题意：

高桥为斯努克准备了 N N N 道菜。菜肴的编号从 1 1 1 到 N N N ，菜肴 i i i 的甜度为 A i A_i Ai​ ，咸度为 B i B_i Bi​ 。
高桥可以按照自己喜欢的顺序排列这些菜肴。斯努克会按照排列顺序吃掉这些菜肴，但如果他吃过的菜肴的总甜度超过 X X X 或总咸度超过 Y Y Y ，他就不会再吃任何菜肴。
高桥希望斯努克吃尽可能多的菜肴。求如果高桥把菜肴摆放得最合理，斯努克最多吃的菜肴数。

分析：

设 d p [ i ] [ j ] dp[i][j] dp[i][j]表示第 i i i个菜品，甜度为 j j j时的最小咸度，有转移方程为: d p [ j ] [ k ] = m i n ( d p [ j ] [ k ] , d p [ j − 1 ] [ k − a ] + b ) ; dp[j][k] = min(dp[j][k], dp[j - 1][k - a] + b); dp[j][k]=min(dp[j][k],dp[j−1][k−a]+b);。最后只要求得 d p [ i ] [ j ] ≤ y dp[i][j] \le y dp[i][j]≤y的最大的 i i i即可。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define endl '\n'
#define PII pair<LL, LL>
const int maxn = 2e5 + 5;
const int INF = 1e9;
const int mod = 1e9 + 7;
const int N = 1e2 + 10, M = 1e4 + 10;
int dp[N][M], n, a, b, x, y;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    while (t--)
    {
        cin >> n >> x >> y;
        memset(dp, 0x3f, sizeof dp);
        for (int i = 0; i <= x; i++)
            dp[0][i] = 0;
        for (int i = 1; i <= n; i++)
        {
            cin >> a >> b;
            for (int j = i; j; j--)
            {
                for (int k = x; k >= a; k--)
                {
                    dp[j][k] = min(dp[j][k], dp[j - 1][k - a] + b);
                }
            }
        }
        for (int i = n - 1; i; i--)
        {
            for (int j = 0; j <= x; j++)
            {
                if (dp[i][j] <= y)
                {
                    cout << i + 1 << endl;
                    return 0;
                }
            }
        }
    }
    cout << 1 << endl;
    return 0;
}

F.Range Connect MST （图论）

题意：

有一个图，它有 N + Q N + Q N+Q 个顶点，编号为 1 , 2 , … , N + Q 1, 2, \ldots, N + Q 1,2,…,N+Q 。最初，该图没有边。
对于这个图，请依次对 i = 1 , 2 , … , Q i = 1, 2, \ldots, Q i=1,2,…,Q 执行以下操作：

  • 对于每个满足 L i ≤ j ≤ R i L_i \leq j \leq R_i Li​≤j≤Ri​ 的整数 j j j ，在顶点 N + i N + i N+i 和 j j j 之间添加一条代价为 C i C_i Ci​ 的无向边。

完成所有操作后，确定图形是否相连。如果相连，求该图的最小生成树的代价。

分析：

考虑是否构成连通块，即这 q q q个线段是否构成一个大线段。再考虑最小生成树怎么求，即考虑前 n n n个点该和哪个操作点 ( n + i ) (n+i) (n+i)连边。
我们从代价小的操作开始，给 L i ≤ j ≤ R i L_i \le j \le R_i Li​≤j≤Ri​ 中的每个点合并成一个联通块，每合并一次的代价是 C i C_i Ci​。最后看是否是同个连通块即可。
连通块利用并查集维护，合并时总是以编号大的点为根，这样在上述从左到右合并时每次都从还未连通的点开始遍历即可。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define endl '\n'
#define PII pair<LL, LL>
const int maxn = 2e5 + 5;
const int INF = 1e9;
const int mod = 1e9 + 7;
int fa[maxn], rmax[maxn];
int n, q;
struct node
{
    int l, r, c;
} a[maxn];
bool cmp(node p, node q)
{
    return p.c < q.c;
}
LL ans;
int find(int x)
{
    if (fa[x] == x)
        return x;
    return fa[x] = find(fa[x]);
}
void merge(int x, int y)
{
    int fx = find(x), fy = find(y);
    if (fx != fy)
    {
        fa[fx] = fy;
        rmax[fy] = max(rmax[fx], rmax[fy]);
    }
}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    while (t--)
    {
        cin >> n >> q;
        for (int i = 1; i <= n; ++i)
            fa[i] = rmax[i] = i;
        for (int i = 1; i <= q; ++i)
        {
            cin >> a[i].l >> a[i].r >> a[i].c;
        }
        sort(a + 1, a + 1 + q, cmp);
        for (int i = 1; i <= q; ++i)
        {
            int now = a[i].l;
            while (1)
            {
                ans += 1ll * a[i].c;
                int nxt = rmax[find(now)] + 1;
                if (nxt > a[i].r)
                    break;
                else
                {
                    merge(now, nxt);
                    now = nxt;
                }
            }
        }
        if (rmax[find(1)] != n)
            cout << -1 << endl;
        else
            cout << ans << endl;
    }
    return 0;
}

赛后交流

在比赛结束后，会在交流群中给出比赛题解，同学们可以在赛后查看题解进行补题。

群号： 704572101，赛后大家可以一起交流做题思路，分享做题技巧，欢迎大家的加入。

AC-Panda
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AtCoder Beginner Contest 364 A~E
swan416的博客
07-27 742
好久没打atc了 这场打的挺烂的
AtCoder Beginner Contest 364
cocoack的博客
07-28 371
对于A,B排个序，我们用最大的分别去与X,Y做差，最后取最小值即可。中a的个数，我们再二分一下，找出第一个不小于b-x的下标。表示到了第i个物品，甜度为j，咸度为k的选的最大数量。表示到了第i个物品，甜度为j，选了k个的最小咸度。下面问题就是给定一个x,如何求出。满足单调性，于是我们二分即可。,以及最后一个小于等于b+x的。最后对后两维扫一下即可。先给排个序，就是求在。
AtCoder Beginner Contest 364（ABCDEF题）视频讲解
Edward Shi的博客
07-27 878
AtCoder Beginner Contest 364（ABCDEF题）视频讲解
AtCoder Beginner Contest 364（A-F）题解
m0_73582730的博客
07-29 343
给你一张有N + Q个点的图，有Q次操作，每次操作给你三个数，L，R，W。我们将Li与N + i连接后，与Li已连接的点都不需要与N+i进行连边了，我们可以跳过这些点，由于操作是连续的，与Li已连接的点也应该是连续的，所以我们跳过的点是一个区间。这题我们需要二分答案，假设答案为D，则[x - D， x + D]这个区间内必有>=K个点，距离变大，区间变大，区间内的点数不会变少，这样具有单调性的问题，可以使用二分去做。给你了N盘菜， 当你连续吃两盘甜的菜就死了，问能不能吃完所有的菜。
AtCoder Beginner Contest 334 A~F
Code_Shark的博客
12-26 681
给出球拍和手套的价格，哪个贵买哪个，要求输出购买的物品。
AtCoder Beginner Contest 359 A~F
Code_Shark的博客
06-23 1136
给出N请你统计出现了多少次。
AtCoder Beginner Contest 355 A~F
Code_Shark的博客
05-26 967
已知有三个嫌疑人，有两个证人，每个证人可以指出其中一个嫌疑人不是罪犯，如果可以排除两个嫌疑人来确定犯人，输出犯人的身份，如果无法确定，输出"-1"。
AtCoder Beginner Contest 356 A~F
Code_Shark的博客
06-02 973
给出三个正整数NLR。对于一个序列A12N，请你输出翻转了L∼R之间数字后得到的序列。
AtCoder Beginner Contest 346 A~F
Code_Shark的博客
03-24 420
给出N个数字A1​A2​AN​。定义Bi​Ai​×Ai1​1≤i≤N−1。请你打印B1​B2​BN−1​。
Atcoder Beginner Contest 273 ABC A~F
yh2021tanghao的博客
10-21 585
Atcoder ABC 273 A~F
AtCoder Beginner Contest 198 （A ~ F）题解
繁凡さん的博客
04-12 1199
目录A. DivB. Palindrome with leading zerosC. Compass WalkingD. Send More MoneyE. Unique ColorF. Cube A. Div Problem Solution 签到 第一反应隔板法，把 nnn 个物品用一个板子隔开，不能为空，答案就是 Cn−2+2−1 2−1=Cn−1 1=n−1C_{n-2+2-1}^{\ 2-1}=C_{n-1}^{\ 1}=n-1Cn−2+2−1 2−1​=Cn−1&
AtCoder Beginner Contest 250 A~E
m0_51731088的博客
05-09 497
AtCoder Beginner Contest 250 A~E A - Adjacent Squares 题意：给出一个行列为H，W的矩阵，再给一个坐标，问周围有多少个正方形。 // Problem: C - Adjacent Swaps // Contest: AtCoder - AtCoder Beginner Contest 250 // URL: https://atcoder.jp/contests/abc250/tasks/abc250_c // Memory Limit: 1024 MB /
AtCoder Beginner Contest 239
Z_Y_S_的博客
02-20 697
G 就是个最小割板子，但是打比赛时一直以为求最小割方案就是把流满的边当作割边，机房里几个人还同时犯了这个错误，错误的点的数量一样，当时一致认为数据有问题，事实上需要从源点开始跑广搜，找出源点不经过流量为000的边所能到达的所有的点记为SSS集，其余点记为TTT集，如果有一条边上的两个点所在集合不一样，那这条边就是割边 F 关键是怎么设状态，一开始设f(x)f(x)f(x)表示当前数为xxx，期望经过几次操作大于mmm，怎么推都只能推出一个暴力dpdpdp，事实上如果把状态设为f(x)f(x)f(x)表示从1
【解题总结】Atcoder Beginner Contest 汇总
zqy1018的blog
09-14 851
ABC
dp算法练习【7】
最新发布
MADAO的博客
09-08 763
给你一个按排序的整数数组nums，返回组成的新数组，要求也按排序。平方后，数组变为 [16,1,0,9,100]排序后，数组变为 [0,1,9,16,100]非常简单，思路平方后排序。优化：插入法。
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 660
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 573
四、实验结果。
atcoder beginner contest 265
12-17
atcoder beginner contest 265 是由日本 Atcoder 组织的一场面向初学者的比赛。这是一场在线编程竞赛，旨在为初学者提供机会锻炼和展示他们的编程技能。 这次比赛包括了多个题目，涉及到算法、数据结构、动态规划等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值