2022CCPC女生赛（补题）（A,C,E,G,H,I）

news2025/1/24 17:57:20

迟了好久的补题，，现在真想把当时赛时的我拉出来捶一拳

排序大致按照题目难度。

C. 测量学

思路：直接循环遍历判断即可，注意角度要和2π取个最小值。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
const int N = 1e5 + 5;
const double PI = acos(-1);
int n;
double ang, r[N];;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> n >> r[0] >> ang;
    double ans = 1e18;
    for(int i = 1; i <= n; i ++) {
        std::cin >> r[i];
    }
    ang = std::min(ang, 2 * PI - ang);
    for(int i = 0; i <= n; i ++) {
        double res = (r[0] - r[i]) * 2 + r[i] * ang;
        ans = std::min(ans, res);
    }
    std::cout << std::fixed << std::setprecision(6) << ans << '\n';
    return 0;
}

A. 减肥计划

思路：由k的范围，容易想到k很大的时候情况：找到序列最靠前且最大的数输出即可。对于剩下的情况，k的范围较小，将原数组复制一遍，处理一个前缀最大的数组，遍历寻找一个位置，满足这个位置及之前的最大值是他自己，并且后面k -1位没有比它更大的。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
const int N = 2e6 + 5;
int n, k;
int a[N], pre[N];

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> n >> k;
    int pos = -1, num = -1;
    for(int i = 1; i <= n; i ++) {
        std::cin >> a[i];
        a[i + n] = a[i];
        if(a[i] > num) {
            num = a[i], pos = i;
        }
    }
    if(k >= n - 1) {
        std::cout << pos << '\n';
        return 0;
    }
    for(int i = 1; i <= 2 * n; i ++) {
        if(a[i] > pre[i - 1]) 
            pre[i] = a[i];
        else
            pre[i] = pre[i - 1];
    }
    for(int i = 1; i <= 2 * n; i ++) {
        if(pre[i] == a[i] && pre[k + i - 1] == a[i]) {
            pos = i;
            break;
        }
    }
    std::cout << pos << '\n';
    return 0;
}

E. 睡觉

思路：主要是分情况讨论。我们经过一次循环，可以得到一个数字x1，由x1和原来的x的大小情况分类：

（1）x1小于x，说明每经过一首歌的影响，x都会减小，那么一定存在若干遍后，x小到满足条件；

（2）x1大于x，说明每经过一首歌的影响，x都会变大，那若存在满足情况的区间，那一定是在第一个区间最有可能满足条件，只需要在第一个区间内判断一下即可。

（3）x1等于x，这样可以想到原来x的性质，如果原来是大于k的，那情况和第二种情况类似，判断第一个区间即可；但是若是原来是等于k的，那极有可能第一段满足条件的区间和最后一段满足条件的区间的和是满足大于等于t的，所以要处理连续两个区间，当然要注意t的大小，如果t是大于等于n的，那必须两个个区间内的最大值要大于n才行。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
#define int long long
const int N = 2e6 + 5;
int T, x, t, k, n, d;
int a[N];

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> T;
    while(T --) {
        std::cin >> x >> t >> k >> n >> d;
        x -= k;
        int original = x;
        int cnt = 0, max = -1;;
        for(int i = 1; i <= n; i ++) {
            std::cin >> a[i];
            if(a[i] <= d)
                a[i] = -1;
            else
                a[i] = 1;
            a[i + n] = a[i];
            x += a[i];
            if(x <= 0) 
                cnt ++;
            else
                cnt = 0;
            max = std::max(max, cnt);
        }
        if(x < original) {
            std::cout << "YES" << '\n';
            continue;
        }
        if(x > original) {
            std::cout << (max >= t ? "YES" : "NO") << '\n';
            continue;
        }
        if(original > 0) {
            std::cout << (max >= t ? "YES" : "NO") << '\n';
            continue;
        }
        std::vector<int> vec;
        x = original;
        cnt = 0;
        for(int i = 1; i <= n; i ++) {
            x += a[i];
            if(x <= 0) {
                cnt ++;
            }
            else {
                vec.push_back(cnt);
                cnt = 0;
            }
        }
        vec.push_back(cnt);
        vec.push_back(vec[0] + vec[vec.size() - 1]);
        max = *max_element(vec.begin(), vec.end());
        t = std::min(t, n);
        std::cout << (max >= t ? "YES" : "NO") << '\n';
    }
    return 0;
}

G. 排队打卡

思路：按照题意模拟即可，注意给出的数据分段，不要搞错了边界。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
#define int long long
const int N = 5e5 + 5;
int t, n, m, k;

struct node {
    int t, x;
} e[N];

bool cmp(node a, node b) {
    if(a.t < b.t) return true;
    else return false;
}

signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    int sum = 0, pos = -1;
    std::cin >> t >> n >> m >> k;
    for(int i = 1; i <= m; i ++) {
        std::cin >> e[i].t >> e[i].x;
    }
    std::sort(e + 1, e + 1 + m, cmp);
    for(int i = 1; i <= m; i ++) {
        if(e[i].t > t && pos == -1) 
            pos = i - 1;
    }
    if(!pos) {
        if(n) {
            std::cout << "Wrong Record" << '\n';
            return 0;
        }
    }
    else {
        sum = e[1].x;
        for(int i = 2; i <= pos; i ++) {
            sum -= std::min(sum, k * (e[i].t - e[i - 1].t));
            sum += e[i].x;
        }
        sum -= std::min(sum, k * (t - e[pos].t));
        if(sum != n) {
            std::cout << "Wrong Record" << '\n';
            return 0;
        }
    }
    int last = t, cnt = 5e18, ans;
    for(int i = pos + 1; i <= m; i ++) {
        sum -= std::min(sum, k * (e[i].t - last));
        sum += e[i].x;
        last = e[i].t;
        int res = (int)ceil((sum + 1) * 1.0 / (double)k);
        if(res <= cnt) {
            cnt = res;
            ans = e[i].t;
        }
    }
    std::cout << ans << ' ' << cnt << '\n';
    return 0;
}

os：现在写来感觉这个题比E要简单，按照题意写就行了，也没啥需要思考的，为啥当时就没做出来呢

I. 宠物对战

思路：其实看题目可以知道是一个比较典的dp问题。可以这样考虑，令f[i][0/1]表示处理到第i个字母，是由A中的字符串还是由B中的字符串组成的。可以考虑循环枚举最后到的位置，和这一整个字符串最后一个子字符串的开始位置，判断这个子字符串是否出自A或B组中，若是，则可以更新：

f[i][1/0] = min(f[i][1/0], f[j - 1][0/1] + 1)；

而对于子字符串是否存在于A或者B组中，可以采用Trie树或者字符串哈希来处理，在这里我用的是字典树，但是在查询的时候加入了一点优化，如果直接查询的话会T飞欸。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
#define INF 0x3f3f3f3f
const int N = 5e5 + 5;
int n, m;
std::string a[N], b[N], s;
int f[N][2];

struct Trie {
    int idx = 0;
    int mp[N][26], cnt[N];

    void insert(std::string s) {
        int p = 0;
        for(int i = 0; i < s.length(); i ++) {
            int u = s[i] - 'a';
            if(!mp[p][u]) mp[p][u] = ++ idx;
            p = mp[p][u];
        }
        cnt[p] ++;
    }
}A, B;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> n;
    for(int i = 1; i <= n; i ++) {
        std::cin >> a[i];
        A.insert(a[i]);
    }
    std::cin >> m;
    for(int i = 1; i <= m; i ++) {
        std::cin >> b[i];
        B.insert(b[i]);
    }
    std::cin >> s;
    int len = s.length();
    s = ' ' + s;
    memset(f, INF, sizeof(f));
    f[0][1] = f[0][0] = 0;
    for(int i = 0; i <= len; i ++) {
        if(f[i][0] < INF) {
            int p = 0;
            for(int j = i + 1; j <= len; j ++) {
                int u = s[j] - 'a';
                if(A.mp[p][u]) {
                    p = A.mp[p][u];
                    if(A.cnt[p]) {
                        f[j][1] = std::min(f[j][1], f[i][0] + 1);
                    }
                }
                else break;
            }
        }
        if(f[i][1] < INF) {
            int p = 0;
            for(int j = i + 1; j <= len; j ++) {
                int u = s[j] - 'a';
                if(B.mp[p][u]) {
                    p = B.mp[p][u];
                    if(B.cnt[p]) {
                        f[j][0] = std::min(f[j][0], f[i][1] + 1);
                    }
                }
                else break;
            }
        }
    }
    int ans = std::min(f[len][1], f[len][0]);
    std::cout << (ans == INF ? -1 : ans) << '\n';
    return 0;
}

os：学弟给的优化方法，tqlllllllll

H. 提瓦特之旅

思路：如果说对于每个询问都跑一次最短路的话，那必然会t，想办法通过离线预处理部分东西来降低部分时间复杂度。所以可以通过预处理数组dis[i][j]，表示经过i个点到达j的最短路径，这样在每次询问的时候就可以在O(n * q)的复杂度内得到答案。

AC Code：

#include <bits/stdc++.h>

typedef long long ll;
typedef std::pair<int, int> PII;
const int N = 505;
int n, m, q, x, t;
ll dis[N][N];
std::vector<PII> vec[N];

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> n >> m;
    for(int i = 1; i <= m; i ++) {
        int u, v, w;
        std::cin >> u >> v >> w;
        vec[u].push_back({v, w});
        vec[v].push_back({u, w});
    }
    for(int i = 0; i <= n; i ++) {
        for(int j = 0; j <= n; j ++) {
            dis[i][j] = 3e18;
        }
    }
    dis[0][1] = 0;
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= n; j ++) {
            for(auto [u, w] : vec[j]) {
                dis[i][j] = std::min(dis[i][j], dis[i - 1][u] + w);
            }
        }
    }
    std::cin >> q;
    while(q --) {
        std::cin >> t;
        ll sum = 0, ans = 3e18;
        for(int i = 1; i < n; i ++) {
            std::cin >> x;
            sum += x;
            ans = std::min(ans, dis[i][t] + sum);
        }
        std::cout << ans << '\n';
    }
    return 0;
}

os：个人感觉这个题比前一个好写很多欸，但是可能就是怎样预处理卡住了吧QWQ

这次让我没想到的是和前几年难度差别这么大，感觉大概到了省赛难度吧，明年加油哇

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/396850.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux设备的I/O模型

Linux设备的I/O模型

背景&#xff1a;进程休眠和唤醒为了把一个进程设置为睡眠状态&#xff0c;需要把这个进程从TASK_RUNNING(可运行状态或就绪态)状态设置为TASK_INTERRUPTIBLE(浅度睡眠)或TASK_NUINTERRUPTIBLE(深度睡眠)状态&#xff0c;并且从进程调度器的运行队列中移走&#xff0c;我们称这…
阅读更多...
jUnit的学习笔记

jUnit的学习笔记

jUnit学习笔记要不要做单元测试的思考jUnit的使用jUnit的一些注意事项注解Assert断言JUnitCoreTestCaseTestResultTestSuite 测试套件忽略测试时间测试异常测试参数化测试jUnit中遇到的问题1.多线程测试时&#xff0c;jUnit自动退出了&#xff1f;2.测试入库的数据时&#xff0…
阅读更多...
各种激活函数的计算公式、图像以及实现代码

各种激活函数的计算公式、图像以及实现代码

激活函数已经成为神经网络中非常重要的一部分&#xff0c;随着各种类型的神经网络模型被人们开发出来&#xff0c;各种激活函数也应运而生&#xff0c;在不同的场景中&#xff0c;取得良好的效果。本文跟据著名的YOLO系列目标检测模型的源码 AlexeyAB Darknet&#xff0c;整理出…
阅读更多...
HTML第5天 HTML新标签与特性

HTML第5天 HTML新标签与特性

新标签与特性文档类型设定前端复习帮手W3Schoool常用新标签datalist标签&#xff0c;与input元素配合&#xff0c;定义选项列表fieldset元素新增input表单文档类型设定 document – HTML: 开发环境输入html:4s – XHTML: 开发环境输入html:xt – HTML5: 开发环境输入html:5 前…
阅读更多...
如何在知行之桥EDI系统中定时自动更换交易伙伴AS2证书？

如何在知行之桥EDI系统中定时自动更换交易伙伴AS2证书？

为了保证客户与交易伙伴之间数据传输的安全性&#xff0c;AS2传输协议中&#xff0c;通常会通过一对数字证书对传输数据进行签名和加密。但是证书是有有效期的&#xff0c;在证书到期之前&#xff0c;需要贸易双方及时更换新的证书。 在更新证书时&#xff0c;由于客户通常是和…
阅读更多...
第十六节 接口

第十六节 接口

接口 接口是一种规范。规范也是一种公开的。 接口中的成分特点&#xff1a;JDK8之前接口中只能有抽象方法和常量。 接口的用法&#xff1a; ●接口是用来被类实现(implements)的&#xff0c;实现接口的类称为实现类。实现类可以理解成所谓的子类。 从上面可以看出&#xff0c…
阅读更多...
网络的瓶颈效应

网络的瓶颈效应

python从小白到总裁完整教程目录:https://blog.csdn.net/weixin_67859959/article/details/129328397?spm1001.2014.3001.5501 ❤ 网络的瓶颈效应 网络瓶颈&#xff0c;指的是影响网络传输性能及稳定性的一些相关因素&#xff0c;如网络拓扑结构&#xff0c;网线&#xff0…
阅读更多...
了解栈Stack一篇文章就够了

了解栈Stack一篇文章就够了

什么是栈栈是一种特殊的线性表&#xff0c;只允许一端进行数据的插入和删除&#xff0c;即先进后出原则。类似于弹夹先装进去的子弹后面出&#xff0c;后放入的子弹先出。栈的底层原理栈是一种线性结构&#xff0c;所以既能使用数组实现&#xff0c;也能使用链表实现&#xff0…
阅读更多...
【蓝桥杯刷题训练营】day05

【蓝桥杯刷题训练营】day05

1 数的分解 拆分成3个数相加得到该数 然后采用了一种巨愚蠢的办法&#xff1a; int main() {int count 0;int a 2;int b 0;int c 1;int d 9;int a1, a2, a3;int c1, c2, c3;int d1, d2, d3;for (a1 0; a1 < 2; a1){for (a2 0; a2 < 2; a2){for (a3 0; a3 <…
阅读更多...
中断和事件

中断和事件

目录 中断概述 什么是中断&#xff1f; 什么是EXTI&#xff1f; EXTI初始化结构体&#xff1a; 中断/事件线&#xff1a; EXTI模式&#xff1a; 触发类型&#xff1a; EXTI控制&#xff1a; 什么是优先级&#xff1f; 什么是优先级分组&#xff1f; 什么是NVIC&#…
阅读更多...
【Java】最新版本SpringCloudStream整合RocketMQ实现单项目中事件的发布与监听

【Java】最新版本SpringCloudStream整合RocketMQ实现单项目中事件的发布与监听

文章目录前言依赖配置代码参考前言 SpringCloud项目中整合RocketMQ是为了削峰填谷。 这里我使用RocketMQ的作用用于接收项目中产生的消息&#xff0c;然后异步的发送邮件给客户&#xff0c;这是这个项目的产生的背景。 依赖配置 <dependencies><dependency><…
阅读更多...
开发钉钉微应用,实现免登+调试

开发钉钉微应用,实现免登+调试

1.创建h5微应用 https://open.dingtalk.com/document/orgapp/develop-org-h5-micro-applications 根据里面的三个步骤,创建h5微应用 2.免登之前必须要先进行JSAPI的授权 文档说明: https://open.dingtalk.com/document/orgapp/jsapi-authentication 根据文档中的说明 步骤…
阅读更多...
spring事物源码分析

spring事物源码分析

今天的任务是剖析源码&#xff0c;看看Spring 是怎么运行事务的&#xff0c;并且是基于当前最流行的SpringBoot。还有&#xff0c;我们之前剖析Mybatis 的时候&#xff0c;也知道&#xff0c;Mybatis 也有事务&#xff0c;那么&#xff0c;他俩融合之后&#xff0c;事务是交给谁…
阅读更多...
MySQL (六)------MySQL的常用函数、 事务(TCL)、DCL用户操作语句、常见环境、编码问题

MySQL (六)------MySQL的常用函数、 事务(TCL)、DCL用户操作语句、常见环境、编码问题

第一章 MySQL的常用函数 1.1 字符串函数 1.1.1 字符串函数列表概览 函数用法CONCAT(S1,S2,......,Sn)连接S1,S2,......,Sn为一个字符串CONCAT_WS(separator, S1,S2,......,Sn)连接S1一直到Sn&#xff0c;并且中间以separator作为分隔符CHAR_LENGTH(s)返回字符串s的字符数LENGTH…
阅读更多...
深入理解性能压测工具原理

深入理解性能压测工具原理

如果没有性能测试工具如何通过手工实现 如果没有性能测试工具&#xff0c;通过手工进行性能测试&#xff0c;这是一个值得我们思考的问题。这时候需要一个协调员发送指令&#xff0c;一个操作员进行操作&#xff0c;对系统施加压力&#xff0c;多个操作员代表着多个用户进行并…
阅读更多...
面向对象设计模式：创建型模式之原型模式

面向对象设计模式：创建型模式之原型模式

文章目录一、引入二、代理模式&#xff0c;Prototype Pattern2.1 Intent 意图2.2 Applicability 适用性2.3 类图2.4 应用实例&#xff1a;使用下划线或消息框展示字符串2.4 应用实例&#xff1a;JDK java.lang.Object java.lang.Cloneable一、引入 二、代理模式&#xff0c;Pr…
阅读更多...
Python—看我分析下已经退市的 可转债 都有什么特点

Python—看我分析下已经退市的 可转债 都有什么特点

分析 需求分析 可转债退市原因的种类与占比是多少 强赎与非强赎导致的退市可转债 存续时间 维度占比 强赎与非强赎导致的退市可转债 发行资金 规模占比 强赎与非强赎导致的退市可转债 各个评级 的占比 强赎与非强赎导致的退市可转债 各个行业&#xff08;一级行业&#xf…
阅读更多...
互相关延时估计 Matlab仿真

互相关延时估计 Matlab仿真

文章目录互相关延时估计什么是互相关延时估计&#xff1f;原理代码实现总结互相关延时估计 互相关延时估计是一种信号处理技术&#xff0c;用于计算两个信号之间的时间延迟。在本篇博客中&#xff0c;我们将使用MATLAB来实现互相关延时估计&#xff0c;并提供多个例子和代码&a…
阅读更多...
TypeScript深度剖析: TypeScript 中函数的理解？与 JavaScript 函数的区别？

TypeScript深度剖析: TypeScript 中函数的理解？与 JavaScript 函数的区别？

一、是什么 函数是 JavaScript 应用程序的基础&#xff0c;帮助我们实现抽象层、模拟类、信息隐藏和模块 在 TypeScript 里&#xff0c;虽然已经支持类、命名空间和模块&#xff0c;但函数仍然是主要定义行为的方式&#xff0c;TypeScript 为 JavaScript 函数添加了额外的功能…
阅读更多...
English Learning - L2-5 英音地道语音语调 弹力双元音 [ɪə] [ʊə] [eə] 2023.03.6 周一

English Learning - L2-5 英音地道语音语调 弹力双元音 [ɪə] [ʊə] [eə] 2023.03.6 周一

English Learning - L2-5 英音地道语音语调 弹力双元音 [ɪə] [ʊə] [eə] 2023.03.6 周一朗读节奏元音的长度元音发音在清辅音和浊辅音前的区别元音发音跟后面浊辅音节数的区别元音在重读音节中复习大小元音发音对比/ʌ/ 舌中音/ɒ/ 舌后音/ʊ/ 舌后音/ɪ/ 舌前音[ɑ:] VS […
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023