AtCoder ABC 336（A~F）

已于 2024-01-19 16:13:45 修改
阅读量448 收藏 8
点赞数 9
文章标签： 算法 蓝桥杯 c++ 数据结构
于 2024-01-19 16:10:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61825750/article/details/135700120
版权

A - Long Loong

        模拟

// Problem: A - Long Loong
// Contest: AtCoder - AtCoder Beginner Contest 336
// URL: https://atcoder.jp/contests/abc336/tasks/abc336_a
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n;
	string s = "";
	s += 'L';
	for(int i = 0 ; i < n ; i ++){
		s += 'o';
	}
	s += "ng";
	cout << s;
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
//	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

B - CTZ

        还是模拟

// Problem: B - CTZ
// Contest: AtCoder - AtCoder Beginner Contest 336
// URL: https://atcoder.jp/contests/abc336/tasks/abc336_b
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	int ans = 0;
	cin >> n;
	while(n){
		if(n & 1)
			break;
		else
			ans++;
		n/=2;
	}	
	cout << ans;
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	//cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

C - Even Digits

        找出由0 , 2 , 4 , 6 , 8 组成的第x大数，模拟（注意一开始不能取0 ， 因此其实是一个开头为4，其余都是5的进制数）。

// Problem: C - Even Digits
// Contest: AtCoder - AtCoder Beginner Contest 336
// URL: https://atcoder.jp/contests/abc336/tasks/abc336_c
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
int mask[5] = {0 , 2 , 4 , 6 , 8};
void solve() 
{
	LL n;
	cin >> n;
	n--;
	LL k = 1;
	while(k * 5 <= n){
		k *= 5;
	}
	while(k > 0){
		int t = n / k;
		cout << mask[t];
		n -= t * k;
		k /= 5;
	}
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	//cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

D - Pyramid

        定义1, 2, 3...k-1, k, k-1...3,2,1为长度为k的好序列，现给定一组数组，你可以选中其子序列，同时将其中的数减去若干，组成一组好序列。求好序列的最大长度。

        二分求长度，从头开始遍历，然后判断能否形成这个好序列，首先从头到尾尽可能的组成一组好序列，若到某个数时无法和前面的数组成好序列，那就将这个数变成新序列的第a_{i}位，其中a_{i}为这个数的值，这样做必然是最优的。

        

// Problem: D - Pyramid
// Contest: AtCoder - AtCoder Beginner Contest 336
// URL: https://atcoder.jp/contests/abc336/tasks/abc336_d
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	int n;
	cin >> n;
	for(int i = 0 ; i < n ; i ++){
		cin >> a[i];
	}	
	int l = 1 , r = (n + 1) / 2;
	auto check = [&] (int len){
		int cnt = 0;
		for(int i = 0 ; i < n ; i ++){
			if(cnt < len){
				if(a[i] >= cnt + 1){
					cnt++;
				}
				else{
					cnt = a[i];
				}
			}
			else{
				if(a[i] >= len - (cnt - len + 1)){
					cnt++;
				}
				else{
					cnt = a[i];
				}
			}
			if(cnt >= len * 2 - 1){
				return true;
			}
		}
		return false;
	};
	while(l < r){
		int mid = (l + r + 1) / 2;
		if(check(mid)){
			l = mid;
		}
		else{
			r = mid - 1;
		}
	}
	cout << l << endl;
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
//	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

E - Digit Sum Divisible

        题意：从1~N，输出其中各个位数之和能够整除其的数量。

        思路：数位DP，首先可以发现N\leq 1e14，因此位数之和应当小于9 * 14。所以我们可以钦定位数和，然后求出每个位数和分别有多少个数满足条件。

        定义dp[i][sum][res][st]代表了数的前i位，各个位数之和为sum，余数为res的和。其中st表示是否为上界（其中0代表未达到上界，1代表还处于上界之中）。每一轮都是将新的数插入之前数的最后，假设加的数为num，那么新的余数res就变成了res * 10 + num 模上位数和。最终答案加上第N的位数位，总和为钦定的位数和，余数为0，状态为0或者1的总数。

// Problem: E - Digit Sum Divisible
// Contest: AtCoder - AtCoder Beginner Contest 336
// URL: https://atcoder.jp/contests/abc336/tasks/abc336_e
// Memory Limit: 1024 MB
// Time Limit: 10000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
#define int long long 
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
int dp[20][200][200][2];//第i位,和为x,余数为y的个数,是否为上界的情况
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	string n;
	cin >> n;
	int len = n.size();
	LL ans = 0;
	for(int i = 1 ; i <= 9 * 14 ; i ++){//钦定位数和
		memset(dp , 0 , sizeof dp);
		dp[0][0][0][1] = 1;
		for(int j = 1 ; j <= len ; j ++){//14
			for(int k = 0 ; k <= 9 * 14 ; k ++){//总和100
				for(int num = 0 ; num <= 9 ; num ++){
					if(k + num > i){
						continue;
					}
					for(int st = 0 ; st < 2 ; st ++){
						if(st && num > (n[j - 1] - '0')){
							continue;
						}
						for(int res = 0 ; res < i ; res ++){
							int now_res = (res * 10 + num) % i;
							dp[j][k + num][now_res][(st && (num == n[j - 1] - '0'))] += dp[j - 1][k][res][st];
						}
					}
				}
			}	
		}
		ans += dp[len][i][0][0] + dp[len][i][0][1];
	}
	cout <<ans;
}            
signed main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
//	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

F - Rotation Puzzle

        题意：给定一个长为h,宽为w的二维数组，其中每次操作能够将长为h-1,宽为w - 1的块翻转180°。求最终能否变成一个1,2,3,4,5....的顺序数组。限定操作最多为20次。

参考图片

        

        思路：（折半搜索）首先肯定考虑DFS遍历所有情况，然后每一轮的情况共有4种，那么总共的复杂度为O(4^{20})肯定是超的。因此考虑从头开始dfs和从尾开始dfs，这样两次dfs的时间复杂度均为 O(4^{10})，然后若有重复的，那么就代表能够从头走到尾，记录一下答案即可。单纯考察折半搜索，就是写起来比较复杂

// Problem: F - Rotation Puzzle
// Contest: AtCoder - AtCoder Beginner Contest 336
// URL: https://atcoder.jp/contests/abc336/tasks/abc336_f
// Memory Limit: 1024 MB
// Time Limit: 5000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
int ans = 25;
map< vector<vector<int>> , int > mp;	
vector<vector<int>>s(9 , vector<int>(9 , 0));
void change(int l_min , int l_max ,int r_min , int r_max){
	for(int i = 0 ; i <= (r_max - r_min) ; i ++){
		int st = r_min + i;
		int en = r_max - i;
		if(st > en)
			break;
		else if(st == en){
			for(int j = 0 ; j <= (l_max - l_min) ; j ++){
				int ss = l_min + j;
				int ee = l_max - j;
				if(ss > ee)
					break;
				swap(s[st][ss] , s[en][ee]);
			}			
		}
		else{
			for(int j = 0 ; j <= (l_max - l_min) ; j ++){
				int ss = l_min + j;
				int ee = l_max - j;
				swap(s[st][ss] , s[en][ee]);
			}
		}
	}
}
void dfs(int step){
	if(step > 10)
		return;
	if(!mp.count(s)){
		mp[s] = step;
	}
	else{
		mp[s] = min(mp[s] , step);
	}

	change(0 , n - 2 , 0 , m - 2);
	dfs(step + 1);
	change(0 , n - 2 , 0 , m - 2);
	
	change(1 , n - 1 , 0 , m - 2);
	dfs(step + 1);
	change(1 , n - 1 , 0 , m - 2);
	
	change(0 , n - 2 , 1 , m - 1);
	dfs(step + 1);
	change(0 , n - 2 , 1 , m - 1);
	
	change(1 , n - 1 , 1 , m - 1);
	dfs(step + 1);
	change(1 , n - 1 , 1 , m - 1);	
}
void dfs2(int step){
	if(step > 10)
		return;
	if(mp.count(s)){
		ans = min(ans , step + mp[s]);
	}
	
	change(0 , n - 2 , 0 , m - 2);
	dfs2(step + 1);
	change(0 , n - 2 , 0 , m - 2);
	
	change(1 , n - 1 , 0 , m - 2);
	dfs2(step + 1);
	change(1 , n - 1 , 0 , m - 2);
	
	change(0 , n - 2 , 1 , m - 1);
	dfs2(step + 1);
	change(0 , n - 2 , 1 , m - 1);	
	
	change(1 , n - 1 , 1 , m - 1);
	dfs2(step + 1);
	change(1 , n - 1 , 1 , m - 1);	
}
void solve() 
{
	cin >> m >> n;
	int id = 1;
	for(int i = 0 ; i < m ; i ++){
		for(int j = 0 ; j <n ; j ++){
			cin >> s[i][j];
		}
	}

	dfs(0);
	id = 1;
	for(int i = 0 ; i < m ; i ++){
		for(int j = 0 ; j < n ; j ++){
			s[i][j] = id++;
		}
	}

	dfs2(0);
	if(ans == 25)
		cout << -1;
	else
		cout << ans;
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	//cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

今天补题了么
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ABC336 A-F
Muelsyse_的博客
01-14 669
E:数位dp？F:双向广搜
学习笔记11：abc336
rrt517的博客
01-16 460
环境很重要，你周围的环境（周围的环境只支持你到达这一高度）和你自己的高度（如果自己不努力那么环境再好也没用）取一个最小值。分析：数据最高是1e14,那么可能的数位之和只有1-9*14，将每一种可能的数位之和dp，求出答案。当然周期的下标是从0开始的，所以我们可以在刚开始把 k--分析：仔细观察我们可以发现所谓第k位的规律。人要有自信，人有了自信才会拥有一切。这是5个为一个周期的循环。用一个数组记录一下周期。
AtCoder ABC336 A-D题解
seanli1008的博客
01-15 485
AtCoder ABC336 题解
AtCoder abc336 A~D题解
zc2000911的博客
01-15 564
的二进制符号末尾连续零的（最大）个数。二进制下末尾连续零的个数，或者算一个。按题目要求做即可……按题目要求做即可……的字符串，由按此顺序排列的。的字符串，由按此顺序排列的。为参数，可以帮你求出。
（C++）AtCoder Beginner Contest 336 C - Even Digits
North_Of_The_Sea的博客
01-15 489
根据题目可知，好整数的定义是：数字的每一位都是一个偶数（即0，2，4，6，8）.比如第五个数是8，而第六个数是20，它的个位上加了一个2，十位上也进了一个二。所以我们可以看出，它的每一位都有五个数，即0 2 4 6 8。那么我们可以采用五进制的思维来编译这道题。
AtCoder abc352 A题题解视频
05-05
AtCoder abc352 A题题解视频
test:atCoder abc141A
03-14
【标题】：“atCoder abc141A”是日本在线编程竞赛平台atCoder举办的一场比赛中的一个问题。在atCoder的abc系列比赛中，通常会包含不同难度级别的算法问题，旨在提升参赛者的编程技能。 【描述】：尽管“test:...
AtCoder Beginner Contest 166 A ~~E
01-03
A 水题： #include using namespace std; int main(){ string s; cin>>s; if(s==ABC) cout<<ARC>>n>>k; int d; for(int i=
AtCoder abc352-C题题解
05-05
AtCoder abc352-C题题解
AtCoder abc352-B题题解
05-05
AtCoder abc352-B题题解
【18】输出字符菱形
2301_78786609的博客
07-19 371
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 306
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
插入和选择排序
c23856的博客
07-20 439
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
2024.7.19 刷题总结
TheJustice_的博客
07-19 231
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
算法刷题笔记 排列数字（C++实现）
hanmo22357的博客
07-17 305
一道简单的深度优先搜索（DFS）模板题，给出了DFS问题的一般思路以及C++代码实现
python实现图像缩放算法
最新发布
qq_42568323的博客
07-20 322
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
(算法)区间调度问题
2202_75519246的博客
07-17 243
此外,参与工作的时间段不能重复(即使是开始的瞬间和结束的瞬间的重叠也是不允许的). 你的目标是参与尽王多的工作,那么最多能参与多少项工作呢?有n项工作,每项工作分别在s时间开始,在t时间结束. 对于每项工作,你都可以选择参与与否,如果选择了参与,那么自始至终都必须全程参与.
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 178
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
【刷题汇总 -- 压缩字符串(一)、chika和蜜柑、 01背包】
m0_69455439的博客
07-19 1129
今日刷题汇总day018 -- 压缩字符串(一)、chika和蜜柑、 01背包
打印图形abcdef abcde abcd abc ab a
05-24
这里是使用 Python 语言打印出该图形的代码： ```python for i in range(6): for j in range(6-i): print(chr(97+j), end='') print() ``` 输出结果为： ``` abcdef abcde abcd abc ab a ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值