Codeforces Round #798 (Div. 2)

已于 2022-06-17 18:10:51 修改
阅读量257 收藏 1
点赞数 2
分类专栏： cf vp 文章标签： 算法 贪心算法 c++
于 2022-06-16 22:12:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a12377978/article/details/125324274
版权

Codeforces Round #798 (Div. 2)

[Link](Dashboard - Codeforces Round #798 (Div. 2) - Codeforces)

A. Lex String

思路

  • 贪心

前面的字符具有决定性，因此贪心来看直接对 a , b a, b a,b​排序后，类似于归并排序每次选满足限制的最小的即可。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
	e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;

int main() {
	ios::sync_with_stdio(false), cin.tie(0);
	int T;
	cin >> T;
	while (T -- ) {
		cin >> n >> m >> k;
		string a, b; cin >> a >> b;
		sort(a.begin(), a.end());
		sort(b.begin(), b.end());
		string res = "";
		int pa = 0, pb = 0, ida = 0, idb = 0;
		for (int i = 0; i < a.size() + b.size(); i ++) {
			if (ida < a.size() && idb < b.size()) {
				if (a[ida] < b[idb]) {
					if (pa < k) {
						pb = 0, pa ++;
						res += a[ida ++];
					}
					else {
						pa = 0, pb ++;
						res += b[idb ++];
					}
				}
				else {
					if (pb < k) {
						pa = 0, pb ++;
						res += b[idb ++];
					}
					else {
						pb = 0, pa ++;
						res += a[ida ++];
					}
				}								
			}
			else break;
		}

		cout << res << '\n';
	}
	return 0;
}

B. Mystic Permutation

思路

  • 贪心

排序后，每次找到当前可以的最小的，要特别注意有能最后一个数剩下的是他本身，因此最后两位特判一下即可。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
	e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N], res[N];
int main() {
	ios::sync_with_stdio(false), cin.tie(0);
	int T;
	cin >> T;
	while (T -- ) {
		cin >> n;
		for (int i = 1; i <= n; i ++) cin >> a[i];
		if (n == 1) {
			cout << - 1 << '\n';
			continue ;
		}
		if (n == 2) {
			cout << a[2] << ' ' << a[1] << '\n';
			continue ;
		}
		vector<bool> st(n + 1);
		for (int i = 1; i <= n - 2; i ++) {
			int k = 1;
			while (st[k] || k == a[i]) k ++;
			res[i] = k;
			st[k] = true;
		}
		int aa, bb;
		int k = 1;
		while (st[k]) k ++;
		aa = k, st[k] = true, k = 1;
		while (st[k]) k ++;
		bb = k;
		
		if (aa == a[n - 1] || a[n] == bb) res[n - 1] = bb, res[n] = aa;
		else res[n - 1] = aa, res[n] = bb;

		for (int i = 1; i <= n; i ++) cout << res[i] << " \n"[i == n];
	}
	return 0;
}

C. Infected Tree

思路

  • 树形 d p dp dp

​ 观察发现对于 u u u，假设他有两个子结点 s 1 , s 2 s_1,s_2 s1​,s2​，因此只有两种选择，砍 s 1 s_1 s1​烧 s 2 s_2 s2​或者砍 s 2 s_2 s2​烧 s 1 s_1 s1​，由于无法判断哪种情况更优，因此考虑 d p dp dp

​ 设 f [ u ] : u 点 正 在 燃 烧 且 以 u 为 根 的 子 树 能 留 下 的 最 大 值 f[u]:u点正在燃烧且以u为根的子树能留下的最大值 f[u]:u点正在燃烧且以u为根的子树能留下的最大值， s i z e [ u ] : 以 u 为 根 的 子 树 的 结 点 数 size[u]:以u为根的子树的结点数 size[u]:以u为根的子树的结点数，然后直接递归转移每次两种情况里取最优解，即 f [ u ] = m a x ( s i z e [ s 1 ] − 1 + f [ s 2 ] , s i z e [ s 2 ] − 1 + f [ s 1 ] ) f[u]=max(size[s_1] - 1 + f[s_2],size[s_2]-1+f[s_1]) f[u]=max(size[s1​]−1+f[s2​],size[s2​]−1+f[s1​])。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 3e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
	e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N], f[N];
void dfs(int u, int fa) {
	a[u] = 1;
	vector<int> ve;
	for (int i = h[u]; ~i; i = ne[i]) {
		int j = e[i];
		if (j == fa) continue ;
		dfs(j, u);
		ve.push_back(j);
		a[u] += a[j];
	}
	if (ve.size() == 1) f[u] = a[ve[0]] - 1;
	else if (ve.size() == 2) f[u] = max(a[ve[0]] + f[ve[1]] - 1, a[ve[1]] + f[ve[0]] - 1);
	else f[u] = 0;
}
int main() {
	ios::sync_with_stdio(false), cin.tie(0);
	int T;
	cin >> T;
	while (T -- ) {
		cin >> n;
		for (int i = 1; i <= n; i ++) h[i] = -1, f[i] = 0;
		for (int i = 1; i < n; i ++) {
			int x, y; cin >> x >> y;
			add(x, y), add(y, x);
		}
		dfs(1, -1);

		cout << f[1] << '\n';
	}
	return 0;
}

D. Lena and Matrix

思路

  • 枚举， d p dp dp

​ 一个很暴力的想法是枚举每个位置再枚举每个黑棋子求当前情况的 m x mx mx，所有情况再取个 m n mn mn。很明显这样的复杂度是很高的，换一个角度来枚举，对于 ( i , j ) (i,j) (i,j)这个点我们只有四种情况，上下左右去找黑棋子，设 f [ i ] [ j ] : ( i , j ) 到 最 远 黑 色 格 子 的 距 离 f[i][j]:(i,j)到最远黑色格子的距离 f[i][j]:(i,j)到最远黑色格子的距离，它可以从上下左右四个方向转移过来，这样其实是不好一下转移的，我们进行分类讨论，对于 ( i , j − 1 ) (i,j-1) (i,j−1)可以是从左上角到 ( i , j − 1 ) (i,j-1) (i,j−1)或左下角到 ( i , j − 1 ) (i,j-1) (i,j−1)，其他三个方向同理，因此我们可以分别从四个角落开始往对角 d p dp dp，然后对于每个位置的最大值这四种情况取 m a x max max。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
	e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N];
char g[1010][1010];
int d[4][1010][1010];
int main() {
	ios::sync_with_stdio(false), cin.tie(0);
	int T;
	cin >> T;
	while (T -- ) {
		cin >> n >> m;
		for (int i = 1; i <= n; i ++)
			for (int j = 1; j <= m; j ++) {
				cin >> g[i][j];
				for (int k = 0; k < 4; k ++) d[k][i][j]	= -1;			
			}

		idx = 0;		
		
		for (int i = 1; i <= n; i ++)
			for (int j = 1; j <= m; j ++)  {
				if (g[i][j] == 'B') d[idx][i][j] = max(d[idx][i][j], 0);
				if (~d[idx][i][j])  d[idx][i + 1][j] = max(d[idx][i + 1][j], d[idx][i][j] + 1), d[idx][i][j + 1] = max(d[idx][i][j + 1], d[idx][i][j] + 1);
			}
				
		idx ++;		
		for (int i = 1; i <= n; i ++)
			for (int j = m; j; j --)  {
				if (g[i][j] == 'B') d[idx][i][j] = max(d[idx][i][j], 0);
				if (~d[idx][i][j])  d[idx][i + 1][j] = max(d[idx][i + 1][j], d[idx][i][j] + 1), d[idx][i][j - 1] = max(d[idx][i][j - 1], d[idx][i][j] + 1);	
			}
				
		idx ++;
		
		for (int i = n; i; i --)
			for (int j = 1; j <= m; j ++)  {
				if (g[i][j] == 'B') d[idx][i][j] = max(d[idx][i][j], 0);
				if (~d[idx][i][j])  d[idx][i - 1][j] = max(d[idx][i - 1][j], d[idx][i][j] + 1), d[idx][i][j + 1] = max(d[idx][i][j + 1], d[idx][i][j] + 1);	
			}
			 
		idx ++;
		
		for (int i = n; i; i --)
			for (int j = m; j; j --)  {
				if (g[i][j] == 'B') d[idx][i][j] = max(d[idx][i][j], 0);
				if (~d[idx][i][j])  d[idx][i - 1][j] = max(d[idx][i - 1][j], d[idx][i][j] + 1), d[idx][i][j - 1] = max(d[idx][i][j - 1], d[idx][i][j] + 1);	
			}
		LL res = INF;
		PII t;		
		for (int i = 1; i <= n; i ++) 
			for (int j = 1; j <= m; j ++) {
				int v = -1;
				for (int k = 0; k < 4; k ++)
					v = max(v, d[k][i][j]);
				if (v < res) res = v, t = {i, j};
			}
		//cout << res << '\n';
		cout << t.x << ' ' << t.y << '\n';
					
	}
	return 0;
}

E. ANDfinity

思路

  • 位运算，并查集

​ 由于 & > 0 \&>0 &>0的点可以连边，如果某个数是 0 0 0则一定要对其加一，并且如果两个点权都是奇数一定可以连边因为他们二进制第零位一定都是 1 1 1，对于其他的数就不一定了。这里有一个结论是当数组均非零后，再做的操作最多是2。

​ 证明这个结论，设 l o w b i t ( x ) : x 二 进 制 从 低 往 高 第 一 个 为 1 的 位 置 ， m x = m a x ( l o w b i t ( a 1 ) , . . . , l o w b i t ( a n ) ) lowbit(x):x二进制从低往高第一个为1的位置，mx=max(lowbit(a_1),...,lowbit(a_n)) lowbit(x):x二进制从低往高第一个为1的位置，mx=max(lowbit(a1​),...,lowbit(an​))，分类来看如果本身就连通则操作为0，如果不连通且有一个 m x mx mx，我们将 m x mx mx这个数减一那么这个数就可以和所有的数相连，图就联通了，如果有大于等于两个 m x mx mx存在，我们任选两个，一个加一一个减一，这样所有的也连通了，因此操作最多两次。

​ 查看是否连通可以用并查集来做，然后按结论分类来试即可。

Code

#include <bits/stdc++.h>
#define x first
#define y second
#define debug(x) cout<<#x<<":"<<x<<endl;
using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8, pi = acos(-1), inf = 1e20;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
	e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
int a[N], f[N];
int find(int x) {
	return x == f[x] ? x : f[x] = find(f[x]);
}
void merge(int x, int y) {
	x = find(x), y = find(y);
	if (x != y)
		f[x] = y;
}
bool check() {
	for (int i = 1; i <= n + 31; i ++) f[i] = i;
	for (int i = 1; i <= n; i ++)
		for (int j = 0; j <= 30; j ++)
			if (a[i] >> j & 1)
				merge(n + j + 1, i);
	int cnt = 0;
	for (int i = 1; i <= n; i ++)
		if (i == f[i]) 
			cnt ++;
	return cnt == 1;
}
int main() {
	ios::sync_with_stdio(false), cin.tie(0);
	int T;
	cin >> T;
	while (T -- ) {
		cin >> n;
		int res = 0;
		for (int i = 1; i <= n; i ++) {			
			cin >> a[i];
			if (!a[i]) a[i] ++, res ++;
		}

		if (check()) {
			cout << res << '\n';
			for (int i = 1; i <= n; i ++)
				cout << a[i] << " \n"[i == n];
			continue ;
		}

		bool ok = false;
		for(int i = 1; i <= n; i ++) {
			a[i] ++; 
			if (check()) {
				cout << res + 1 << '\n';
				for (int i = 1; i <= n; i ++)
					cout << a[i] << " \n"[i == n];
				ok = true;
				break;
			}
			a[i] --;
		}
		if (ok) continue;
		for (int i = 1; i <= n; i ++) {
			a[i] --;
			if (check()) {
				cout << res + 1 << '\n';
				for (int i = 1; i <= n; i ++)
					cout << a[i] << " \n"[i == n];
				ok = true;
				break;
			}
			a[i] ++;
		}
		if (ok) continue;

		int mx = 0;
		for (int i = 1; i <= n; i ++) mx = max(mx, a[i] & -a[i]);

		for (int i = 1; i <= n; i ++)
			if (mx == (a[i] & -a[i])) {
				a[i] ++;
				break;
			}
				
		for (int i = 1; i <= n; i ++)
			if (mx == (a[i] & -a[i])) {
				a[i] --;
				break;
			}
				
		
		cout << rs + 2 << '\n';
		for (int i = 1; i <= n; i ++)
			cout << a[i] << " \n"[i == n];			
	}
	return 0;
}
枉玊
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
就是把所有相等的数放到一个vector里，如果他出现大于2次，看最远的间距是否大于2即可，找到一个就可以 代码： #include #include #include #include #include #include #include #include #include #include #...
Codeforces Round #798 (Div. 2)ABCD
qq_52765554的博客
06-12 282
思路： 双指针模拟 B. Mystic Permutation 如果一个数字不在他的下标位置，则先把他放回自己本身的位置。如果本身就在下标位置，将这些数字进行swap，能与后边的swap字典序最小 C. Infected Tree 两种方法，第一种dfs 第二种 树形dp D. Lena and Matrix 离所有黑点的最大距离最小，尽量与左上，左下，右上，右下的中间区域。 点是我们可以提前预处理的黑点，四个方向取max 然后枚举所有点，最后再去max就是最大值最小的点...
【6.15】Codeforces Round #798 (Div. 2)
ZhgDgE的博客
07-08 307
题意：给定一个 [1,n][1,n][1,n] 的排列，要求你构造一个新的 [1,n][1,n][1,n] 的排列，使得这两个排列之间的任意一个相同位置的元素都不相同，且满足这个排列的字典序最小。 如果无法构造出这样的序列则输出 −1-1−1思路：如果全局的去思考的话可能不是那么好想。我们从小到大关注每一位，当前位只可能从未选过的数的最小值和次小值中选择，如果 aaa 当前位等于最小值，那只能放次小值，且次小值一定能放。这样就放置了前 n - 1 个元素。对于最后一个元素，如果冲突，那和 n - 1 个元素
Codeforces Round #798 (Div. 2)（A~D)
weixin_60896526的博客
06-11 358
给出两个字符串，每次从其中一个串取一个字符加到ccc中，同一个串不能连续取kkk次，直到一个串为空，求字典序最小的ccc串。对两个串排序，哪个串的小取拿个，设两个计数器判断是否连续取了kkk个。 B - Mystic Permutation 题意： 给定一个1−n1-n1−n的全排列aaa，构造出一个新的字典序最小的全排列ppp,，使得pi≠aip_i \neq a_ipi​​=ai​。用一个setsetset记录当前还有哪些数没有填，每次填最小即可。 C - Infected Tree 题意： 给定一
Codeforces Round 917 (Div. 2)
Lanthamum的博客
12-24 548
############################################################################B.不会。A.考虑有没有负数，偶数（把没有负数考虑进去了）就要改变一个数为0，为min，如果是奇数就不用考虑
codeforces round 948(div.2）
2301_79426686的博客
05-27 669
codeforces round 948(div.2) AB
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
Codeforces Round #479 (Div. 3) E. Cyclic Components
01-03
E. Cyclic Components 题目链接-E. Cyclic Components 题目大意 给你nnn个点和mmm条边，求所构成图中单圈环的个数 ...并查集并查集并查集 很明显单圈环每个点的度都为222，所以我们可以用数组cnt[]记录每个点的度，...
Codeforces Round #628 (Div. 2)
01-03
给两两节点放一个数字（0~n-2 唯一） 给你一棵树，求所有任意两节点相连的路以外的路上的数字的最小值最小 思路 构造 若一个点连了三条边及以上，则这个点的边从最小值开始赋值。其他边从最大点开始赋值。 证明：一...
Codeforces Round #798 (Div. 2)A~D
fnmdpnmsl的博客
06-11 406
Kuznecov likes art, poetry, and music. And strings consisting of lowercase English letters.Recently, Kuznecov has found two strings, a and b, of lengths n and m respectively. They consist of lowercase English letters and no character is contained in both s
算法力扣刷题记录六【203移除链表元素】
danaaaa的博客
06-21 1105
删除链表节点
189.二叉树：将有序数组转换为二叉搜索树（力扣）
weixin_63779802的博客
06-21 240
代码使用了递归的方法。主要思路是首先找到数组的中间元素，然后以这个中间元素作为根节点，递归地在数组中构建左右子树。左子树包含数组中所有小于中间元素的元素，右子树包含所有大于中间元素的元素。这个算法的时间复杂度是 O(n)，其中 n 是数组中元素的数量。空间复杂度也是 O(n)，因为需要存储递归调用的栈。
面试+算法之回文(Java)：验证回文串、回文数、最长回文子串、回文链表、分割成回文串、最短回文串、
lonelymanontheway的博客
06-20 552
验证回文串、回文数、最长回文子串、分割成回文串、最短回文串、回文链表
【算法】二叉树 - 理论基础
Nanki_的博客
06-23 1148
int val;
【代码随想录】【算法训练营】【第49天】 [300]最长递增子序列 [674]最长连续递增序列 [718]最长重复子数组
最新发布
weixin_54954007的博客
06-24 443
思路及算法思维，指路。题目来自。day 49，周二，坚持不了一点~
力扣1793.好子数组的最大分数
Pisasama的博客
06-21 311
【代码】力扣1793.好子数组的最大分数。
Codeforces Round 798 (Div. 2)
09-08
Codeforces Round 798 (Div. 2)是一个Codeforces竞赛系列中的一场比赛。根据提供的引用内容，我们可以看到一些参赛选手的AC代码链接。这些链接中包含了一些参赛选手在比赛中解答的题目的代码。 其中，AC代码链接是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值