Atcoder Beginner Contest 294

news2024/11/22 21:35:34

A - Filter

AC代码：

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++){
        int x;
        cin>>x;
        if(x%2==0)cout<<x<<" ";
     }
    return 0;
}

B - ASCII Art

AC代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
const int N=110;
int a[N][N];
int main()
{
    int h,w;
    cin>>h>>w;
    for(int i=1;i<=h;i++){
        for(int j=1;j<=w;j++){
            cin>>a[i][j];
        }
    }
    for(int i=1;i<=h;i++){
        for(int j=1;j<=w;j++){
            if(a[i][j]==0) cout<<'.';
            else{
                printf("%c",'A'+a[i][j]-1);
            }
        }
        cout<<endl;
    }
    return 0;
}

C - Merge Sequences

大致题意就是对于A的每一个数，输出它们在所有数中(A和B的所有数)是第几小的数，对于B的每一个数，输出它们在所有数中是第几小的数

可以用两个指针分别遍历A和B中的每个数，然后两两比较，小的那个数就可以给它标记是第几小的数，双指针要注意边界问题，之前也做过类似的题目，经常搞不清边界，在这时就可以

用样例来试，发现如果A或B一边全部标记完了，那么剩下的就需要全部依次标记，可以将a[n+1]和b[m+1]初始化为超级大的数，这样的话，一边全部标记好之后，就可以把剩下的数依次标记了

注意while(l<=n||r<=m)用或而不是且

AC代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
const int N=1e5+10;
int a[N],b[N];
int idxa[N],idxb[N];
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>a[i];
    a[n+1]=1e9+10;
    for(int i=1;i<=m;i++) cin>>b[i];
    b[m+1]=1e9+10;
    int l=1,r=1;
    int idx=1;
    while(l<=n||r<=m){
        if(a[l]<b[r]){
            idxa[l]=idx;
            l++;
            idx++;
        }
        else if(a[l]>b[r]){
            idxb[r]=idx;
            r++;
            idx++;
        }
    }
    for(int i=1;i<=n;i++) cout<<idxa[i]<<" ";
    cout<<endl;
    for(int i=1;i<=m;i++) cout<<idxb[i]<<" ";
    cout<<endl; 
    return 0;
}

D - Bank 

 

超时代码： 

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
using namespace std;
const int N=5e5+10;
bool flag[N];//表示是否被呼叫过 
set<int>s;
int main()
{
    int n,q;
    cin>>n>>q;
    for(int i=1;i<=n;i++) s.insert(i);
    while(q--){
        int op;
        cin>>op;
        if(op==1){
            for(auto v:s){
                if(!flag[v]){
                    flag[v]=true;
                    break;
                }
            }
        }
        else if(op==2){
            int x;
            cin>>x;
            s.erase(x);
        }
        else{
            for(auto v:s){
                if(flag){
                    cout<<v<<endl;
                    break;
                }
            }
        }
    } 
    return 0;
}

实际上根本没必要用flag标记是否被呼叫过，如果是第一次被呼叫，那么直接将其放入set中，set中的就表示被呼叫过但没来的人，如果呼叫过然后来了的人就从set中删去

AC代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
using namespace std;
set<int>s;
int main()
{
    int n,q;
    cin>>n>>q;
    int idx=1;
    while(q--){
        int op;
        cin>>op;
        if(op==1){
            s.insert(idx);//表示被呼叫过但没来
            idx++;
        }
        else if(op==2){
            int x;
            cin>>x;
            s.erase(x);//被呼叫过然后来了的
        }
        else{
            cout<<*s.begin()<<endl;
        }
    }
    return 0;
}

E - 2xN Grid

大致题意是有一个行为2列为L的矩阵

这样输入：输入N1对数字(x,y),表示数字x有y个，依次填入第一行

同理，输入N2对数字(x,y)，表示数字x有y个，依次填入第二行

最终，同一列的两个数字相等算一组，问一共有几组

首先，不能一个一个的填，因为L可以达到1e12，一个一个的填必定超时，共有N1+N2对，可以一对一对填，这样不会超时

然后填完之后，可以利用双指针进行判断，同时枚举上一边和下一边

 

 代码如下：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#define int long long
using namespace std;
vector<pair<int,int>>a,b;
signed main()
{
    int len,n1,n2;
    cin>>len>>n1>>n2;
    for(int i=1;i<=n1;i++){
        int x,y;
        cin>>x>>y;
        a.push_back({x,y});
    }
    for(int i=1;i<=n2;i++){
        int x,y;
        cin>>x>>y;
        b.push_back({x,y});
    }
    int l=0,r=0;
    int len1=a[0].second,len2=b[0].second;
    int res=0;
    if(a[0].first==b[0].first) res+=min(len1,len2);
    while(len1<=len||len2<=len){
        if(len1<=len2){
            l++;
            if(a[l].first==b[r].first) res+=min(a[l].second,len2-len1);
            len1+=a[l].second;
        }
        else{
            r++;
            if(b[r].first==a[l].first) res+=min(b[r].second,len1-len2);
            len2+=b[r].second;
        }
    }
    cout<<res<<endl;
    return 0;
}

进行改进：加上 

if(len1==len&&len2==len) break;//如果双指针用while加if和else的话，最后不要忘记再加一句以退出循环

 这样就没有RE了，此时还有点小错误，看来大方向是没问题的，只不过有一些小细节没有处理好，可能有特殊情况没有考虑到

代码如下： 

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#define int long long
using namespace std;
vector<pair<int,int>>a,b;
signed main()
{
    int len,n1,n2;
    cin>>len>>n1>>n2;
    for(int i=1;i<=n1;i++){
        int x,y;
        cin>>x>>y;
        a.push_back({x,y});
    }
    for(int i=1;i<=n2;i++){
        int x,y;
        cin>>x>>y;
        b.push_back({x,y});
    }
    int l=0,r=0;
    int len1=a[0].second,len2=b[0].second;
    int res=0;
    if(a[0].first==b[0].first) res+=min(len1,len2);
    while(len1<=len||len2<=len){
        if(len1<=len2){
            l++;
            if(a[l].first==b[r].first) res+=min(a[l].second,len2-len1);
            len1+=a[l].second;
        }
        else{
            r++;
            if(b[r].first==a[l].first) res+=min(b[r].second,len1-len2);
            len2+=b[r].second;
        }
        if(len1==len&&len2==len) break;
    }
    cout<<res<<endl;
    return 0;
}

再进行改进，依旧是对边界的改进，改完之后又对了一个测试点 

if(len1<len) l++;
if(len2<len) r++;

 代码如下：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#define int long long
using namespace std;
vector<pair<int,int>>a,b;
signed main()
{
    int len,n1,n2;
    cin>>len>>n1>>n2;
    for(int i=1;i<=n1;i++){
        int x,y;
        cin>>x>>y;
        a.push_back({x,y});
    }
    for(int i=1;i<=n2;i++){
        int x,y;
        cin>>x>>y;
        b.push_back({x,y});
    }
    int l=0,r=0;
    int len1=a[0].second,len2=b[0].second;
    int res=0;
    if(a[0].first==b[0].first) res+=min(len1,len2);
    while(len1<=len||len2<=len){
        if(len1<=len2){
            if(len1<len) l++;
            if(a[l].first==b[r].first) res+=min(a[l].second,len2-len1);
            len1+=a[l].second;
        }
        else{
            if(len2<len) r++;
            if(b[r].first==a[l].first) res+=min(b[r].second,len1-len2);
            len2+=b[r].second;
        }
        if(len1==len&&len2==len) break;
    }
    cout<<res<<endl;
    return 0;
}

此时样例错了一个，而且是样例二，第一行为1e10个1，第二行也为1e10个1

试了一下，发现res一开始+=1e10，然后len1变成了2e10，导致没有退出循环，后面res又加了，真是个巧合，这边可以避免len1变成2e10，即将res+=和len1+=都放到if(len1<len)里面

AC代码： 

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#define int long long
using namespace std;
vector<pair<int,int>>a,b;
signed main()
{
    int len,n1,n2;
    cin>>len>>n1>>n2;
    for(int i=1;i<=n1;i++){
        int x,y;
        cin>>x>>y;
        a.push_back({x,y});
    }
    for(int i=1;i<=n2;i++){
        int x,y;
        cin>>x>>y;
        b.push_back({x,y});
    }
    int l=0,r=0;
    int len1=a[0].second,len2=b[0].second;
    int res=0;
    if(a[0].first==b[0].first) res+=min(len1,len2);
    while(len1<=len||len2<=len){
        if(len1<=len2){
            if(len1<len) {
                l++;
                   if(a[l].first==b[r].first) res+=min(a[l].second,len2-len1);
                len1+=a[l].second;
            }
        
        }
        else{
            if(len2<len) {
                r++;
                if(b[r].first==a[l].first) res+=min(b[r].second,len1-len2);
                len2+=b[r].second;
            }
        }
        if(len1==len&&len2==len) break;
    }
    cout<<res<<endl;
    return 0;
}

或者将len1==len改为大于等于

AC代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<set>
#include<vector>
#define int long long
using namespace std;
vector<pair<int,int>>a,b;
signed main()
{
    int len,n1,n2;
    cin>>len>>n1>>n2;
    for(int i=1;i<=n1;i++){
        int x,y;
        cin>>x>>y;
        a.push_back({x,y});
    }
    for(int i=1;i<=n2;i++){
        int x,y;
        cin>>x>>y;
        b.push_back({x,y});
    }
    int l=0,r=0;
    int len1=a[0].second,len2=b[0].second;
    int res=0;
    if(a[0].first==b[0].first) res+=min(len1,len2);
    while(len1<=len||len2<=len){
        if(len1<=len2){
            if(len1<len) l++;
            if(a[l].first==b[r].first) res+=min(a[l].second,len2-len1);
            len1+=a[l].second;
        }
        else{
            if(len2<len) r++;
            if(b[r].first==a[l].first) res+=min(b[r].second,len1-len2);
            len2+=b[r].second;
        }
        if(len1>=len&&len2>=len) break;
    }
    cout<<res<<endl;
    return 0;
}

 总的来说，一开始大致方向是对的，双指针主要难点在于处理边界问题

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

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

相关文章

​​INNODB和MyISAM区别

​​INNODB和MyISAM区别

1 存储引擎是MyISAM 如下&#xff1a; CREATE table test_myisam (cli int ) ENGINEMyISAM 存储目录里会有三个文件 test_myisam.frm为“表定义”&#xff0c;是描述数据表结构的文件 test_myisam.MYI文件是表的索引 test_myisam.MYD文件是表的数据 2 存储引擎是INNODB…
阅读更多...
LeetCode——比较字符串最小字母出现频次

LeetCode——比较字符串最小字母出现频次

1、题目 1170. 比较字符串最小字母出现频次 - 力扣&#xff08;Leetcode&#xff09; 定义一个函数 f(s)&#xff0c;统计 s 中&#xff08;按字典序比较&#xff09;最小字母的出现频次 &#xff0c;其中 s 是一个非空字符串。 例如&#xff0c;若 s "dcce"&am…
阅读更多...
httprunner 2.x的基本使用（一）

httprunner 2.x的基本使用（一）

上一章&#xff1a; 下一章&#xff1a; httprunner 2.x的基本使用&#xff08;二&#xff09;_做测试的喵酱的博客-CSDN博客 一、参考地址&#xff1a; 使用说明_httprunner2.0 概述及使用说明 二、介绍 HttpRunner是一款面向 HTTP(S) 协议的通用测试框架&#xff0c;只需…
阅读更多...
location.href 和 document.URL 与 document.documentURI

location.href 和 document.URL 与 document.documentURI

location.href 和 document.URL 与 document.documentURI 相同点 获取到的值相同 不同点 location.hrefurl可以赋值, 效果类似location.assign(url) , 可以后退 document.URL 与 document.documentURI 是只读的, 赋值无效 location.href locationwindow.location true lo…
阅读更多...
从源码角度看Linux线程是怎么创建出来的

从源码角度看Linux线程是怎么创建出来的

这篇文章来学习一下线程的创建过程。 线程不是一个完全由内核实现的机制&#xff0c;它是由内核态和用户态合作完成的。 用户态创建线程 pthread_create 不是一个系统调用&#xff0c;是 glibc 库的一个函数&#xff0c;位于 nptl/pthread_create.c 中&#xff1a; int __pth…
阅读更多...
redis商户查询缓存

redis商户查询缓存

1 什么是缓存? 前言:什么是缓存? 就像自行车,越野车的避震器。 举个例子:越野车,山地自行车,都拥有"避震器",防止车体加速后因惯性,在酷似"U"字母的地形上飞跃,硬着陆导致的损害,像个弹簧一样; 同样,实际开发中,系统也需要"避震器",防止过…
阅读更多...
Unity Shader - 兰伯特漫反射

Unity Shader - 兰伯特漫反射

兰伯特漫反射公式&#xff1a; 漫反射&#xff08;Diffuse&#xff09; 光源颜色 * max&#xff08;0&#xff0c;cos&#xff08;光方向和法线的夹角&#xff09;&#xff09; 公式原理&#xff1a; 从上面图片可以看出光照方向 L 与物体法相 N形成的 余弦值越大&#xff0c;反…
阅读更多...
力扣笔记（每日随机一题）—— 打折购买糖果的最小开销

力扣笔记（每日随机一题）—— 打折购买糖果的最小开销

问题&#xff08;简单&#xff09; 一家商店正在打折销售糖果。每购买 两个 糖果&#xff0c;商店会 免费 送一个糖果。 免费送的糖果唯一的限制是&#xff1a;它的价格需要小于等于购买的两个糖果价格的 较小值 。 比方说&#xff0c;总共有 4 4 4 个糖果&#xff0c;价格…
阅读更多...
开源代码分享(3)—微电网鲁棒定价策略(附matlab代码)

开源代码分享(3)—微电网鲁棒定价策略(附matlab代码)

1背景介绍 1.1摘要 本论文聚焦于微电网中的能量失衡管理问题&#xff0c;并从电力市场的角度进行研究。与传统电力网不同&#xff0c;微电网可从可再生能源&#xff08;RES&#xff09;如太阳能电池板或风力涡轮机等获得额外能源。然而&#xff0c;来自RES的随机输入给平衡供需…
阅读更多...
简述Vue的生命周期以及每个阶段做的事情

简述Vue的生命周期以及每个阶段做的事情

03_简述Vue的生命周期以及每个阶段做的事情 思路 给出概念 列举出生命周期各个阶段 阐述整体流程 结合实际 扩展&#xff1a;vue3变化 回答范例 每个vue组件实例被创建后都会经过一系列步骤。比如它需要数据观测、模板编译、挂载实例到dom、以及数据变化的时候更新dom、…
阅读更多...
Android系统的启动过程（三）：Launcher启动过程

Android系统的启动过程（三）：Launcher启动过程

Android系统的启动过程(三)&#xff1a;Launcher启动过程 摘要&概述 前两篇文章中我们已经将系统启动的过程推进到了系统服务启动完毕之后&#xff0c;本篇文章就来介绍Android系统启动的最后一步&#xff1a;启动Launcher。 这个Launcher我们可以通俗地理解为桌面&#…
阅读更多...
深度相机介绍

深度相机介绍

一、什么是深度相机 &#xff08;五&#xff09;深度相机&#xff1a;结构光、TOF、双目相机 - 知乎 传统的RGB彩色普通相机称为2D相机&#xff0c;只能拍摄相机视角内的物体&#xff0c;没有物体到相机的距离信息&#xff0c;只能凭感觉感知物体的远近&#xff0c;没有明确的数…
阅读更多...
V90 PN伺服驱动器转矩控制(750报文)

V90 PN伺服驱动器转矩控制(750报文)

主要介绍通过标准报文加附加报文 750 实现发送驱动报文的控制字、速度给定、转矩限幅及附加转矩给定的功能，首先就是V90在博途环境下的组态，安装GSD文件，GSD文件下载地址如下： https://download.csdn.net/download/m0_46143730/86542047https://download.csdn.net/downloa…
阅读更多...
Qt线程的几种使用方法

Qt线程的几种使用方法

目录 引言使用方法重写QThread::run()moveToThreadQRunnable使用QtConcurrent使用 完整代码 引言 多线程不应该是一个复杂而令人生畏的东西&#xff0c;它应该只是程序员的一个工具&#xff0c;不应该是调用者过多记忆相关概念&#xff0c;而应该是被调用方应该尽可能的简化调…
阅读更多...
Java网络开发（Tomcat）——登陆和注册功能 的 迭代升级 从Jsp到JavaScript + axios + vue 同步到异步

Java网络开发（Tomcat）——登陆和注册功能 的 迭代升级 从Jsp到JavaScript + axios + vue 同步到异步

目录 引出前置工作vueaxiosresp0.vue版本的jsp模板1.导包--Json&#xff1a;pom.xml文件&#xff1a;2.新建一个专门用来处理响应的实体类ResData3.在axios中&#xff0c;所有响应必须是 resp.getWriter().write() 的方式&#xff0c;核心代码如下4.在jsp前端代码中导包&#x…
阅读更多...
浅谈一级机电管道设计中的压力与介质温度

浅谈一级机电管道设计中的压力与介质温度

管道设计是工程设计中的一个非常重要的部分&#xff0c;管道的设计需要考虑到许多因素&#xff0c;其中就包括管道设计压力分类和介质温度分类。这两个因素是在设计管道时必须非常严格考虑的&#xff0c; 首先是管道设计压力分类。在管道设计中&#xff0c;根据工作要求和要传输…
阅读更多...
详解 Ansible 自动化运维，提升工作效率

详解 Ansible 自动化运维，提升工作效率

概要 Ansible 是一个模型驱动的配置管理器&#xff0c;支持多节点发布、远程任务执行。默认使用 SSH 进行远程连接。无需在被管理节点上安装附加软件&#xff0c;可使用各种编程语言进行扩展。 一、Ansible基本架构 上图为ansible的基本架构&#xff0c;从上图可以了解到其由以…
阅读更多...
算法刷题-关于链表，你该了解这些！

算法刷题-关于链表，你该了解这些！

关于链表&#xff0c;你该了解这些&#xff01; 什么是链表&#xff0c;链表是一种通过指针串联在一起的线性结构&#xff0c;每一个节点由两部分组成&#xff0c;一个是数据域一个是指针域&#xff08;存放指向下一个节点的指针&#xff09;&#xff0c;最后一个节点的指针域…
阅读更多...
mybatis-plus分页查询（springboot中实现单表和多表查询）

mybatis-plus分页查询（springboot中实现单表和多表查询）

一、mybatis-plus单表查询 使用mybatis-plus实现单表分页查询 非常方便&#xff0c;主要操作步骤如下&#xff1a; 配置分页查询拦截器进行分页查询 1.首先&#xff0c;打开mybatis-plus官网的插件&#xff08;插件主体&#xff09; 或者点击mybatis-plus插件 我是配置在s…
阅读更多...
KameAI：探索AI驱动的未来，体验聊天GPT与AI绘画的奇妙世界

KameAI：探索AI驱动的未来，体验聊天GPT与AI绘画的奇妙世界

人工智能的崛起与发展随着科技的飞速发展&#xff0c;人工智能(AI)已经逐渐成为我们生活中不可或缺的一部分。它的出现不仅改变了我们与世界的互动方式&#xff0c;还为各行各业带来巨大的便利。今天&#xff0c;我们就来聊一聊一个类似ChatGPT的人工智能网站—KameAI&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023