Educational Codeforces Round 158 (Rated for Div. 2)

已于 2023-11-25 16:56:09 修改
阅读量546 收藏 8
点赞数 11
文章标签： 算法
于 2023-11-25 00:47:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lanthamum/article/details/134609470
版权

A.找到距离最大，就是最小的汽油存储量。

// Problem: A. Line Trip
// Contest: Codeforces - Educational Codeforces Round 158 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1901/problem/A
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <iostream>
#include <cstring>
#include <iomanip>
#include <ctime>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <queue>
#define eps 1e-5
#define INF 1e9
using namespace std;
typedef long long ll;
const int N = 2e6 + 9;
int a[N];
void solve() {
	int n,x;
	cin>>n>>x;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	int ans=0;
	for(int i=2;i<=n;i++){
		ans=max(ans,a[i]-a[i-1]);
	}
	ans=max(ans,2*(abs(a[n]-x)));
	ans=max(ans,a[1]);
	cout<<ans<<'\n';


}

int main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int q;
	cin >> q;
	while (q--) {
		solve();
	}

	return 0;
}

#############################################################################

B.P5019 [NOIP2018 提高组] 铺设道路,P1969 [NOIP2013 提高组] 积木大赛类似

ans 开long long 

1.模拟题意+贪心，如果左边标记的次数比右边边多就让ans+=左边，右边少，左边标记完，右边肯定就标记完了,ans=-1.

// Problem: B. Chip and Ribbon
// Contest: Codeforces - Educational Codeforces Round 158 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1901/problem/B
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <iostream>
#include <cstring>
#include <iomanip>
#include <ctime>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <queue>
#define eps 1e-5
#define INF 1e9
using namespace std;
typedef long long ll;
const int N = 2e6+ 9;
ll a[N];
void solve() {
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	ll res=-1;
	for(int i=1;i<=n;i++){
		if(a[i]>a[i-1]){
			res+=a[i]-a[i-1];
		}
	}
	cout<<res<<'\n';
}

signed main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int q;
	cin >> q;
	while (q--) {
		solve();
	}

	return 0;
}

2.差分+贪心，与1做差分如果大于1就ans+=.

// Problem: B. Chip and Ribbon
// Contest: Codeforces - Educational Codeforces Round 158 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1901/problem/B
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <iostream>
#include <cstring>
#include <iomanip>
#include <ctime>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <queue>
#define eps 1e-5
#define INF 1e9
using namespace std;
typedef long long ll;
const int N = 2e6+ 9;
ll a[N];
ll diff[N];
void solve() {
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	ll res=0;
	diff[1]=a[1]-1;
	for(int i=2;i<=n;i++){
		diff[i]=a[i]-a[i-1];
	}
	for(int i=1;i<=n;i++){
		if(diff[i]>0){
			res+=diff[i];
		}
	}
	cout<<res<<'\n';
}

signed main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int q;
	cin >> q;
	while (q--) {
		solve();
	}

	return 0;
}

3.学长思路：观察发现如果c[i] >= c[i + 1]那么每次使用操作2传送回 i 的时候能用操作1把格子i + 1也给走了。也就是说如果有这么一个连续子数组c[i] >= c[i + 1] >= c[i + 2] ...答案就是芯片传送回第i个格子的次数。可以将整个数组划分为若干段这样不上升的子数组。一旦c[i] < c[i + 1]就是新的一段的开始。需要注意的细节是我们在走c[i]的时候能把c[i + 1]也给走了，也就是新的一段需要减去上一段的最后一个元素。由于最开始就在第一个位置，所以需要将最开始的上一段置为1方便统计答案。

#include <bits/stdc++.h>
 
#define ll long long
#define db double
typedef std::pair<int, int > PII;
typedef std::pair<int, std::pair<int, int>> PIII;
typedef std::pair<ll, ll> Pll;
typedef std::pair<double, double> PDD;
using ld = double long;
const long double eps = 1e-9;
int d1[] = {0, 0, 1, -1};
int d2[] = {1, -1, 0, 0};
const int N = 2e5 + 10, M = N << 1;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
#define ls u << 1
#define rs u << 1 | 1

int n, m, k;
int a[N];

int main(void){
   	std::ios::sync_with_stdio(false);
   	std::cin.tie(0);
   	std::cout.tie(0);
   	
   	int _ = 1;
   	
	std::cin >> _;
	while(_ --) {
		
		std::cin >> n;
	
		for (int i = 1; i <= n; i ++) std::cin >> a[i];
		
		ll ans = 0;
		
		int i = 1, j = 2;
		int last = 1;
		for (; j <= n; j ++) {
			if (a[j] > a[j - 1]) {
				ans += a[i] - last;
				i = j;
				last = a[j - 1];
			}
		}
		ans += a[i] - last;
		
		std::cout << ans << '\n';
		
	}

    return 0;
}

4.维护一个单调栈（*）

#include<iostream>
#include<stack>
typedef long long ll;
using namespace std;
const int N=2e6+9;
ll n, a[N]; 
void solve(){
	cin >> n;
	stack<int> q;
	ll ans = 0;
	for(int i = 0; i < n; ++ i){
		cin >> a[i];
		int pre = -1;
		while(q.size() && q.top() > a[i]){
			if(pre != -1)
				ans += pre - q.top();
			pre = q.top();
			q.pop();
		}
		if(pre != -1) ans += pre - a[i];
		if(q.empty() || q.top() < a[i]){
			q.push(a[i]);
		}
	}
	int pre = -1;
	while(q.size()){
		if(pre != -1)
			ans += pre - q.top();
		pre = q.top();
		q.pop();
	}
	if(pre != 0 && pre != -1) ans += pre;
	cout << ans-1<< '\n';
	return;
}
int main(){
	int q;
	cin>>q;
	while(q--){
		solve();
	}
	return 0;
}

C.将ai改成ceil（ai+x/2）（向下取整），思考怎么样让2个数越来越近，直到相等.我们可以分析数是奇数还是偶数。（向下取整如果是奇数不仅可以让其按2的倍数减少，还可以让奇数+1，让其下降后数慢慢向上移动（与相邻数距离再次变小）（适用于小的数）），（向下取整如果是偶数，+1还是+0都是按2的倍数减少）.

因此x取（0，1）就可以解决这个问题。因为如果靠外的数字都相等了，那么中间的数字肯定相等。所以我们只需要考虑最小值和最大值。

分析：4种情况列举（保险）

1.最大值是奇数，最小值是奇数.x=1,x=0都可以.

2.最大值是偶数，最小值是奇数.x=1

3.最大值是奇数，最小值是偶数.x=0

4.最大值是偶数，最小值是偶数.x=0

在每次记录完x后记得要对最大值和最小值进行操作.

// Problem: C. Add, Divide and Floor
// Contest: Codeforces - Educational Codeforces Round 158 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1901/problem/C
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <iostream>
#include <cstring>
#include <iomanip>
#include <ctime>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <queue>
#define eps 1e-5
#define INF 1e9
using namespace std;
typedef long long ll;
const int N = 2e6 + 9;
int a[N];
int ans[N];
void solve() {
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	int cnt=0;
	sort(a+1,a+1+n);
	int minn=a[1];
	int maxn=a[n];
	while(maxn>minn){
		if(maxn-minn==1){
			if(minn%2!=0){
				ans[++cnt]=1;
			}else{
				ans[++cnt]=0;
			}	
			break;
		}else if(maxn-minn>1){
			if(minn%2!=0 && maxn%2==0){
				minn/=2;
				minn++;
				maxn/=2;
				ans[++cnt]=1;
			}else if(minn%2==0 && maxn%2==0){
				minn/=2;
				maxn/=2;
				ans[++cnt]=0;
			}else if(minn%2!=0 && maxn%2!=0){
				minn/=2;
				maxn/=2;
				maxn++;
				minn++;
				ans[++cnt]=1;
			}else{
				minn/=2;
				maxn/=2;
				ans[++cnt]=0;
			}
			
		}
	}
	if(cnt==0){
		cout<<0<<'\n';
		return;
	}
	if(cnt>n){
		cout<<cnt<<'\n';
		return;
	}else{
		cout<<cnt<<'\n';
		for(int i=1;i<=cnt;i++){
		cout<<ans[i]<<" ";
		}
		cout<<'\n';
	}
		
}

int main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int q;
	cin >> q;
	while (q--) {
		solve();
	}

	return 0;
}

用动态数组实现.(学长)

#include <bits/stdc++.h>
 
#define ll long long
#define db double
typedef std::pair<int, int > PII;
typedef std::pair<int, std::pair<int, int>> PIII;
typedef std::pair<ll, ll> Pll;
typedef std::pair<double, double> PDD;
using ld = double long;
const long double eps = 1e-9;
int d1[] = {0, 0, 1, -1};
int d2[] = {1, -1, 0, 0};
const int N = 2e5 + 10, M = N << 1;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
#define ls u << 1
#define rs u << 1 | 1

int n, m, k;
int a[N];


int main(void){
   	std::ios::sync_with_stdio(false);
   	std::cin.tie(0);
   	std::cout.tie(0);
   	
   	int _ = 1;
   	
	std::cin >> _;
	while(_ --) {
		std::cin >> n;
	
		for (int i = 1; i <= n; i ++) std::cin >> a[i];
		
		std::sort(a + 1, a + n + 1);
		
		int mn = a[1], mx = a[n];
		
		int ans = 0;
		std::vector<int> tmp;
		while (mn < mx) {
			if (mx - mn == 1) {
				if (mn % 2 == 1) tmp.push_back(1);
				else tmp.push_back(0);
				break;
			}
			if (mn % 2 == 1) {
				mn = (mn + 1) / 2;
				mx = (mx + 1) / 2;
				tmp.push_back(1);
			} else {
				mn = mn / 2;
				mx = mx / 2;
				tmp.push_back(0);
			}
		}
			
		std::cout << tmp.size() << '\n';
		if (tmp.size() <= n && tmp.size()) {
			for (int i = 0; i < tmp.size(); i ++) std::cout << tmp[i] << ' ';
			std::cout << '\n';
		}
		
	}

    return 0;
}

D.枚举第一个被击中的目标（k），做最坏的打算(a[i]刚好为第i个被击中的目标)

假设都是先击中后面的再击中前面的.

分析2种情况，

i>k,最坏是第i个目标会受到x-(i)+1的伤害，要求伤害要大于等于a[i].

i<k,最坏是第i个目标会受到x-(n-i+1)+1的伤害，要求伤害要大于等于a[i].

因此处理前缀和（prefix）和后缀和(suffix)的最大值，再进行比较取min.

ans开long long .
 

// Problem: D. Yet Another Monster Fight
// Contest: Codeforces - Educational Codeforces Round 158 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1901/problem/D
// Memory Limit: 256 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <iostream>
#include <cstring>
#include <iomanip>
#include <ctime>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <queue>
#define eps 1e-5
#define INF 1e9
using namespace std;
typedef long long ll;
const int N = 3e5 + 9;
ll a[N];
ll prefix[N],suffix[N];
void solve() {
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	prefix[0]=suffix[n+1]=0;
	for(int i=1;i<=n;i++){
		prefix[i]=max(prefix[i-1],a[i]-i+n);
	}
	for(int i=n;i>=1;i--){
		suffix[i]=max(suffix[i+1],a[i]+i-1);	
	}
	ll ans=1e18;
	for(int i=1;i<=n;i++){
		//1.从前面开始攻击2.从后面开始攻击
		ans=min(ans,max({prefix[i-1],suffix[i+1],a[i]}));
	}
	cout<<ans<<'\n';	
}

int main() {
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int q=1;
	while (q--) {
		solve();
	}

	return 0;
}

Lanthanmum
关注
  • 11
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2021-09-12免费的疯狂僵尸机
t888ydro的博客
09-12 151
#include <limits.h>　　　　//定义各种数据类型最值常量 #include <locale.h>　　　　//定义本地化函数 #include <math.h>　　　　　//定义数学函数 #include <stdio.h>　　　　//定义输入／输出函数 #include <stdlib.h>　　　　//定义杂项函数及内存分配函数 #include <string.h>　　　　//字符串处理 #include <.
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m 我们发现内层循环，每次只是j加一，我们就可以只用一次组合数剩下的用差量表示 对于外层循环同理 只有(i-1) * C(n-2,i-1) i会每次加一。我们也只算一次剩下的用差量...
Educational Codeforces Round 83 (Rated for Div. 2) E. Array Shrinking
01-03
葫芦聚聚说可以n^2搞。。 还好没卡我n^3 的做法。。 核心思路就是f[i]表示 前i个数最小能分成几个数。 然后由于前i个数都分好了，我们只需要取min  f[k]+1( 满足k<i>n; for(int i=1;i>a[i],d
Sage：开源数学软件的瑰宝
gitblog_00071的博客
05-09 241
Sage：开源数学软件的瑰宝 项目地址:https://gitcode.com/sagemath/sage-archive-2023-02-01 1、项目介绍 Sage 是一个强大的开源数学软件，旨在创建一个可行的替代方案，与 Magma, Maple, Mathematica 和 MATLAB 竞争。这个项目由全球超过 800 名贡献者共同开发，并且遵循 GNU General Public L...
Educational Codeforces Round 159（Rated for Div. 2）
wyzz_yz的博客
12-06 1100
Educational Codeforces Round 159（Rated for Div. 2）
Educational Codeforces Round 160 (Rated for Div. 2)
maisui12138的博客
12-19 747
思路：首先分别记录01字符的数量，然后遍历字符串s，遍历时需要记录走过的可以交换的0和1，若前方有可交换的字符时，就减去该字符，否则查看剩余01字符，选择交换然后同时减去两字符并将当前字符记录到交换字符中。思路：位运算，每次添加的元素均为二进制的x位，记录二进制中存入的位，当查询时只需要从后往前遍历二进制数，看当前位存储的是否足够，不够就*2累加到下一位尝试减去。将操作后的字符串定为t，字符串t与原字符串s左对齐对每一位进行比较，若均不相等则t为好字符串，空字符串默认为好字符串；
Educational Codeforces Round 155 (Rated for Div. 2)
maisui12138的博客
09-25 364
题意：给出a,b两个大小为n的数组，给出一个n*n的棋盘，向里面填筹码，每行或者每列起码得有一个筹码，填入筹码的成本为棋盘坐标(i, j)—>ai+bj，问最小成本。每一段需要删(t-1)个，那么该段可能的操作数即为t中留一个，即t种选择，每段子序列相乘，还需要乘上所有需要操作字符的全排列，即为最终答案；题意：举重比赛，给出n个人，每个人给出能举的最大重量和单个重量能举起的次数，要让第一个人赢，需要用多大的重量，成绩相同无胜者。​ 找出每列的最小值，填满最小列，保证每一行有筹码，得到成本y；
Educational Codeforces Round 166 (Rated for Div. 2) 题解
最新发布
m0_73788381的博客
05-31 347
3.所以可以依次从后向前遍历，如果该员工不来，则让出他所选择的位置，给后面第一个想要这个位置的人（记为want1/want2）4.而由于第2条，则want1接受1后，会将他的2传递给最后一个人（最后一个人太可怜了呜呜~~~，只能接受别人不要的）2.对于一个员工，如果他相当1，但是被选择了2，那么他后面的所有人都是2。1.一个员工不到来只会影响后面的员工选择，所以可以从后往前依次考虑。注：选择ai的值记为1，选择bi的值记为2。
Educational Codeforces Round 150 (Rated for Div. 2)
qq_61657632的博客
06-13 1619
今晚看完电影再回来补。
Educational Codeforces Round 161 (Rated for Div. 2)补题
m0_74120503的博客
01-19 1008
再次遍历时，就只访问这些元素。思路：这题的考点就在于什么时候出现题目要求的情况，只要有一位满足，哪怕剩下的不满足也无所谓，那么就要看a[i],b[i],c[i]的关系，如果a[i]=b[i]=c[i],那么这一位能与a,b匹配就一定能与c匹配，如果a[i]=b[i]!然后从小到大访问，对于每种长度，如果大于等于2才有讨论的价值，选出两条当前长度的边，假设当前长度的有k条边，那么这两条边的选择的情况就有(k-1)*k/2,然后第三条边的选择为前c条边的总个数+（k-2），那么遍历map就能统计出来。
Educational Codeforces Round 146 (Rated for Div. 2)
WQhuanm的博客
04-09 440
【代码】Educational Codeforces Round 146 (Rated for Div. 2)
Educational Codeforces Round 85 (Rated for Div. 2) B. Middle Class（贪心）
01-03
目录传送门题意：思路：代码： 传送门 题意： 思路： 排个序，然后从最大的开始判断是否合适即可 代码： #include #include #include #include #include #include #include ...#define SZ(x) (
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Educational Codeforces Round 83 (Rated for Div. 2) C. Adding Powers
01-03
传送门 题意： 思路： 每步可加kik^iki，也可以跳过不加，看能否构成给定数组 数组中的0是不需要处理的 ... }// l=3 b[i]=1+9+9^2 if(p[l]!=1){ flag=0; break; } p[l]=
Educational Codeforces Round 145 (Rated for Div. 2)
m0_62676987的博客
03-27 295
Educational Codeforces Round 145 (Rated for Div. 2)部分题解
Leecode---347：输出前k个高频元素（使用unordered_map）
qq_41920323的博客
05-30 315
unordered_map实现输出前k个高频元素
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 550
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
Java多线程（04）—— 保证线程安全的方法与线程安全的集合类
2201_75456895的博客
05-30 1186
其含义为：CAS(M, A, B);M 表示内存，A 和 B 分别表示一个寄存器；如果 M 的值和 A 的值相同，则把 M 和 B 的值交换，如果不同，则无事发生；因为，因此可以基于 CAS 指令，不进行加锁，来编写线程安全代码；CAS 指令操作经过操作系统，JVM 的层层封装，最后 Java 标准库，提供了一些工具类，其中最主要工具类就是由于原子类内部用的是 CAS 实现，所以性能要比加锁实现高很多；在包下；
算法训练营day41
stmfresher的博客
05-27 390
动态规划理论基础（主要就是确定动态规划的几个步骤）
educational codeforces round 103 (rated for div. 2)
09-06
"educational codeforces round 103 (rated for div. 2)"是一个Codeforces平台上的教育性比赛，专为2级选手设计评级。以下是有关该比赛的回答。 "educational codeforces round 103 (rated for div. 2)"是一场Codeforces平台上的教育性比赛。Codeforces是一个为程序员提供竞赛和评级的在线平台。这场比赛是专为2级选手设计的，这意味着它适合那些在算法和数据结构方面已经积累了一定经验的选手参与。 与其他Codeforces比赛一样，这场比赛将由多个问题组成，选手需要根据给定的问题描述和测试用例，编写程序来解决这些问题。比赛的时限通常有两到三个小时，选手需要在规定的时间内提交他们的解答。他们的程序将在Codeforces的在线评测系统上运行，并根据程序的正确性和效率进行评分。 该比赛被称为"educational"，意味着比赛的目的是教育性的，而不是针对专业的竞争性。这种教育性比赛为选手提供了一个学习和提高他们编程技能的机会。即使选手没有在比赛中获得很高的排名，他们也可以从其他选手的解决方案中学习，并通过参与讨论获得更多的知识。 参加"educational codeforces round 103 (rated for div. 2)"对于2级选手来说是很有意义的。他们可以通过解决难度适中的问题来测试和巩固他们的算法和编程技巧。另外，这种比赛对于提高解决问题能力，锻炼思维和提高团队合作能力也是非常有帮助的。 总的来说，"educational codeforces round 103 (rated for div. 2)"是一场为2级选手设计的教育性比赛，旨在提高他们的编程技能和算法能力。参与这样的比赛可以为选手提供学习和进步的机会，同时也促进了编程社区的交流与合作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值