Codeforces Round #854 by cybercats (Div. 1 + Div. 2)

news2025/1/15 22:45:17

A. Recent Actions

给出n个格子,从上到下是1~n,其他的n+1~。。。不在格子内。给出m个操作,若该操作的数字不在格子内,那就将它拿到格子的第一个位置,同时格子第n个位置的数被挤下去;若操作的数字在格子内,仅将它拿到格子第一个位置,问原来数组的每个数什么时候被挤下去,若不会被挤下去,则输出-1。

思路:模拟,记录一下时间即可。

AC Code:

#include <bits/stdc++.h>

typedef long long ll;
const int N = 1e5 + 5;
int t, n, m;
int ans[N], a[N];

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> n >> m;
        memset(ans, -1, sizeof(ans));
        for(int i = 1; i <= m; i ++) {
            std::cin >> a[i];
        }
        int cnt = n, pos = 0;
        std::map<int, int> mp;
        for(int i = 1; i <= m; i ++) {
            if(!mp[a[i]])
                ans[cnt] = ++ pos, cnt --, mp[a[i]] ++;
            else
                pos ++;
        }
        for(int i = 1; i <= cnt; i ++) {
            if(!ans[i])
                ans[i] = -1;
        }
        for(int i = 1; i <= n; i ++) {
            std::cout << ans[i] << " \n"[i == n];
        }
    }
    return 0;
}

os:a题就搞这么难搞的题面,离大谱

B. Equalize by Divide

给出一个数组a,每次可以选择两个位置的数,按照上述方式赋值,问是否可以使得数组中所有的数都变为相同的,输出操作方式,且操作数不能大于30n。

思路:每次选择最小的数,用其他数除以这个最小的数,每次更新最小的数;若数组中存在1且不全为1,则一定不可以。

代码看看就好啦,写的一堆什么东西我也不知道。

AC Code:

#include <bits/stdc++.h>

typedef long long ll;
typedef std::pair<int, int> PII;
const int N = 105;
int t, n;
int a[N];

struct node {
    int num, pos;
} e[N];

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

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> n;
        int cnt = 0, min = 1e9 + 5, tot = 0;
        for(int i = 1; i <= n; i ++) {
            std::cin >> a[i];
            e[++tot] = {a[i], i};
            min = std::min(min, a[i]);
            if(a[i] == 1) cnt ++;
        }
        if(cnt && cnt != n) {
            std::cout << -1 << '\n';
            continue;
        }
        std::sort(e + 1, e + 1 + n, cmp);
        int cc = e[1].pos;
        std::vector<PII> vec;
        while(e[1].num != e[n].num && e[1].num != 1) {
            for(int i = 1; i <= n; i ++) {
                if(e[i].num == min) continue;
                while(e[i].num > min) {
                    int res = e[i].num % min;
                    e[i].num /= min;
                    if(res) e[i].num ++;
                    vec.push_back({e[i].pos, cc});
                }
                if(e[i].num < min) {
                    min = e[i].num;
                    cc = e[i].pos;
                } 
                if(min == 1) break;
            }
            std::sort(e + 1, e + 1 + n, cmp);
        }
        std::sort(e + 1, e + 1 + n, cmp);
        if(e[1].num != e[n].num) {
            std::cout << -1 << '\n';
            continue;
        }
        std::cout << vec.size() << '\n';
        for(auto [x, y] : vec)
            std::cout << x << ' ' << y << '\n';
    }
    return 0;
}

C. Double Lexicographically Minimum

给出一个字符串,重新排列这个字符串,使得排列后的字符串和它的逆序的字典序最大值最小。

思路:容易想到,对于成对的同一字母来说,最好的是前面一个,后面一个,而且是字典序比较小的在外围更优;如果遇到奇数个的字母呢?可以分以下情况讨论:只剩下一个字母,那一定是放在最中间;剩下两种字母,其中一个只剩一个,且这一个是字典序较小的,那就尽可能将这个最小的尽可能放在中间位置;若剩下的大于两种字母,若要保证这个最大值最下,那应该把现存的最下的放在后面,让它成为某个字符串和它的逆序字典序中较大的那个,然后剩下的按照顺序加到前面就可以了。

AC Code:

#include <bits/stdc++.h>

typedef long long ll;
const int N = 105;
int t, n;
int cnt[30];
std::string s;

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> s;
        memset(cnt, 0, sizeof(cnt));
        for(int i = 0; i < s.length(); i ++) {
            cnt[s[i] - 'a'] ++;
        }
        std::string l = "", r = "";
        for(int i = 0; i < 26; i ++) {
            while(cnt[i] > 1) {
                l += (char)('a' + i);
                r += (char)('a' + i);
                cnt[i] -= 2;
            }
            if(cnt[i]) break;
        }
        int cc = 0;
        for(int i = 0; i < 26; i ++) {
            if(cnt[i]) cc ++;
        }
        if(cc <= 2) {
            for(int i = 25; i >= 0; i --) {
                while(cnt[i] > 1) {
                    l += (char)('a' + i);
                    r += (char)('a' + i);
                    cnt[i] -= 2;
                }
                if(cnt[i])
                    l += (char)('a' + i);
            }
        }
        else {
            int flag = true;
            for(int i = 0; i < 26; i ++) {
                while(cnt[i]) {
                    if(flag)
                        r += (char)('a' + i), cnt[i] --, flag = 0;
                    else
                        l += (char)('a' + i), cnt[i] --;
                }

            }
        }
        reverse(r.begin(), r.end());
        std::cout << l << r << '\n';
    }
    return 0;
}

D1. Hot Start Up (easy version)

有两个cpu,可以处理程序,只有前一个程序处理完才可以处理下一个,如果上一个和当前处理的程序相同,则耗时是hot[i]否则就是cold[i],问所需最少的时间。

思路:设f[i][j]是处理到第i个,以j为结尾所用的最少时间,具体看代码:

AC Code:

#include <bits/stdc++.h>

typedef long long ll;
#define INF 0x3f3f3f3f3f3f3f3f
const int N = 5e3 + 5;
int t, n, k;
ll a[N], b[N], c[N], e[N];
ll f[N][N];

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    std::cin >> t;
    while(t --) {
        std::cin >> n >> k;
        // memset(f, INF, sizeof(f));
        for(int i = 0; i <= n; i ++) {
            a[i] = 0, b[i] = 0, c[i] = 0;
            for(int j = 0; j <= k; j ++)
                f[i][j] = INF;
        }
        for(int i = 1; i <= n; i ++) {
            std::cin >> a[i];
        }
        for(int i = 1; i <= k; i ++) {
            std::cin >> b[i];
        }
        for(int i = 1; i <= k; i ++) {
            std::cin >> c[i];
        }
        //f[i][j]进行到第i个,以j结尾的最小答案
        f[0][0] = 0;
        for(int i = 1; i <= n; i ++) {
            if(a[i] == a[i - 1]) {
                for(int j = 0; j <= k; j ++) {
                    f[i][j] = std::min(f[i][j], f[i - 1][j] + c[a[i]]);
                }
            }
            else {
                for(int j = 0; j <= k; j ++) {
                    f[i][j] = std::min(f[i][j], f[i - 1][j] + b[a[i]]);
                }
            }
            f[i][a[i]] = std::min(f[i][a[i]], f[i - 1][a[i]] + c[a[i]]);
            for(int j = 0; j <= k; j ++) {
                f[i][a[i - 1]] = std::min(f[i][a[i - 1]], f[i][j]);
            }
        }
        ll ans = INF;
        for(int i = 0; i <= k; i ++)
            ans = std::min(ans, f[n][i]);
        std::cout << ans << '\n';
    }
    return 0;
}

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

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

相关文章

Java简单的生成/解析二维码(zxing qrcode)

Hi I’m Shendi Java简单的生成/解析二维码&#xff08;zxing qrcode&#xff09; 在之前使用 qrcode.js 方式生成二维码&#xff0c;但在不同设备上难免会有一些兼容问题&#xff0c;于是改为后端&#xff08;Java&#xff09;生成二维码图片 这里使用 Google 的 zxing包 Jar…

基于STM32的DHT11温湿度控制系统仿真设计

基于STM32的DHT11温湿度控制系统仿真设计(仿真程序报告讲解&#xff09;演示视频1.主要功能2.仿真3. 程序4. 设计报告1主控制器选择5.设计内容 百度云网盘下载链接仿真图proteus 8.9程序编译器&#xff1a;keil 5 编程语言&#xff1a;C语言 设计编号&#xff1a;C0076 演示…

Android Qcom Display学习(十三)

该系列文章总目录链接与各部分简介&#xff1a; Android Qcom Display学习(零) 在上一篇中dump GraphicBuffer中&#xff0c;知道了护眼模式中调用setColorTransform应用于每一层Layer&#xff0c;于是想往上了解一些&#xff0c;color是针对屏幕的&#xff0c;不是对单个Layer…

[YOLO] yolo博客笔记汇总(自用

pip下载速度太慢&#xff0c;国内镜像&#xff1a; 国内镜像解决pip下载太慢https://blog.csdn.net/weixin_51995286/article/details/113972534​​​​​​​ YOLO v2和V3 关于设置生成anchorbox&#xff0c;Boundingbox边框回归的过程详细解读 YOLO v2和V3 关于设置生成an…

Airbnb系列三《Managing Diversity in Airbnb Search》 搜索多样性

abstract 搜索系统中一个长期的问题是结果多样性。从产品角度讲&#xff0c;给用户多种多样的选择&#xff0c;有助于提升用户体验及业务指标。 多样性需求和模型的目标是相矛盾的&#xff0c;因为传统ctr模型是 point wise&#xff0c;只看单个相关性不管相邻之间item差异。 …

Jvisualvm监控Tomcat以及相关参数优化

Tomcat阻塞模式 阻塞模式&#xff08;BIO&#xff09; 客户端和服务器创建一个连接&#xff0c;它就会创建一个线程来处理这个连接&#xff0c;以为这客户端创建了几个连接&#xff0c;服务端就需要创建几个线程来处理你&#xff0c;导致线程会产生很多&#xff0c;有很多线程…

数学小课堂:无穷小(平均速度和瞬间速度的关系)

文章目录 引言I 速度1.1 平均速度1.2 瞬间速度(某一时刻特定的速度)1.3 解释飞箭是静止的悖论II 导数2.1 概念2.2 导数的现实影响2.3 微积分的意义III 无穷小3.1 贝克莱挑战牛顿(无穷小悖论)3.2 无穷小的定义引言 柯西和魏尔斯特拉斯给出的无穷小的定义: 它不是零;它的绝对…

vue2+element封装rules, 支持json多层级

一、封装介绍 封装前景&#xff1a;表单内容多、表单类型重复且校验项较多 下面就参考element的例子写个实例 element地址&#xff1a;https://element.eleme.cn/2.15/#/zh-CN/component/form 实现效果如下: 今天给大家写三种表单校验实现方式 普通表单实现、正常定义rules…

【svg】引入svg(非图标)

这里写目录标题直接插入页面—— 有各层svg内容并可赋值属性css 背景图 ——不可更改各层svg属性创建标签&#xff08;动态添加&#xff09;——可改属性但是还不如直接插入不常用&#xff08;没弄明白&#xff09;目的&#xff1a;如果直接以图片的方式引用svg 不能改变内层sv…

【C++基础入门】初识C++、数据类型

一&#xff1a;C简介 1.1 介绍 C&#xff08;c plus plus&#xff09;是一种计算机高级程序设计语言&#xff0c;由C语言扩展升级而产生 [17] &#xff0c;最早于1979年由本贾尼斯特劳斯特卢普在AT&T贝尔工作室研发。C既可以进行C语言的过程化程序设计&#xff0c;又可以…

深度学习 <实战Kaggle比赛:预测房价> 代码分析 跟李沐学AI

4.10. 实战Kaggle比赛&#xff1a;预测房价 — 动手学深度学习 2.0.0 documentation 若有错误请指出 一.数据处理部分 1.下载部分 没啥好说的 import hashlib import os import tarfile import zipfile import requests#save DATA_HUB dict() DATA_URL http://d2l-data.…

2-8 SpringCloud快速开发入门: Eureka 注册中心高可用集群搭建

Eureka 注册中心高可用集群搭建 Eureka 注册中心高可用集群就是各个注册中心相互注册 Eureka Server的高可用实际上就是将自己作为服务向其他服务注册中心注册自己&#xff0c;这样就会形成一组互相注册的服务注册中心&#xff0c;进而实现服务清单的互相同步&#xff0c;往注…

【博学谷学习记录】超强总结,用心分享丨人工智能 机器学习 逻辑回归模型遗漏知识点总结

目录激活函数逻辑回归的优缺点总结LR可以进行多分类吗&#xff1f;激活函数 h(w)表示输入的线性方程 逻辑回归的优缺点总结 优点&#xff1a; 形式简单&#xff0c;模型的可解释性非常好。从特征的权重可以看到不同的特征对最后结果的影响&#xff0c;某个特征的权重值比较高…

Docker搭建redis-cluster集群

以下是搭建redis-cluster集群&#xff0c;该集群是redis3.0引进了的&#xff0c;该集群比redis-sentinel哨兵架构有以下优点 可以配置多主多从&#xff0c;在redis设置内存可以更大&#xff0c;而哨兵只能配置一主多从&#xff0c;且单个主节点内存不宜设置过大&#xff0c;否…

操作系统内核与安全分析课程笔记【0】环境搭建

本学期选择了游伟和黄建军老师的操作系统内核分析与安全&#xff0c;目前已经试听了第一节课。这门的授课老师建了一个网页用于收录本次课程的幻灯片材料&#xff0c;录屏材料&#xff0c;以及软件安装包等一系列课程用得到的材料。对于学生而言&#xff0c;这是一门既硬核能够…

【机器学习】机器学习实验三:集成算法1(详细代码展示)

文章目录一、实验介绍1.1 简单介绍1.2 Breast Cancer 数据实验1.3 Boston 数据实验二、项目地址三、算法结果展示一、实验介绍 1.1 简单介绍 AdaBoost 和 Random Forest 算法的原理 1.2 Breast Cancer 数据实验 对 Breast Cancer 数据进行探索性数据分析&#xff1b; 数据预…

VMware虚拟机安装ubuntu系统在虚拟机中全屏以及主机和虚拟机之间文件的复制

一、从Wndows复制文字到VMware&#xff08;Linux&#xff09; List item 今天需要用到了Linux操作系统。在VMware装上linux之后经常面临这样一个问题&#xff0c;那就是很多指令很长&#xff0c;逐字去敲显然费时费力。 按照惯例我也查了几种方法&#xff0c;然而要么就是需要…

API 接口测试经验分享

接口开发完成后&#xff0c;我们需要调用接口来测试接口的表现&#xff0c;当表现符合预期时&#xff0c;则代表接口可用。 在测试中我们可能会关注状态码、响应体以及响应时间&#xff0c;这些数据 Postcat 通通都会展示给你&#xff0c;判断 API 是否正常。 开始测试之前&…

pytorch-把线性回归实现一下。原理到实现,python到pytorch

线性回归 线性回归输出是一个连续值&#xff0c;因此适用于回归问题。回归问题在实际中很常见&#xff0c;如预测房屋价格、气温、销售额等连续值的问题。 与回归问题不同&#xff0c;分类问题中模型的最终输出是一个离散值。所说的图像分类、垃圾邮件识别、疾病检测等输出为离…

ModStartBlog v6.8.0 博客置顶功能,界面样式优化

ModStart 是一个基于 Laravel 模块化极速开发框架。模块市场拥有丰富的功能应用&#xff0c;支持后台一键快速安装&#xff0c;让开发者能快的实现业务功能开发。 系统完全开源&#xff0c;基于 Apache 2.0 开源协议。 功能特性 丰富的模块市场&#xff0c;后台一键快速安装 …