【CodeForces】Codeforces Global Round 9

于 2020-07-10 16:20:33 发布
阅读量1.2k 收藏 1
点赞数 2
分类专栏： 【OJ】CodeForces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39972971/article/details/107253481
版权

比赛链接

点击打开链接

官方题解

点击打开链接

Problem A. Sign Flipping

将奇数位的数取非正值，偶数位的数取非负值即可。

单组数据时间复杂度 O ( N ) O(N) O(N) 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
int main() {
	int T; read(T);
	while (T--) {
		int n; read(n);
		for (int i = 1; i <= n; i++) {
			int x; read(x);
			if (i & 1) printf("%d ", -abs(x));
			else printf("%d ", abs(x));
		}
		printf("\n");
	}
	return 0;
}

Problem B. Neighbor Grid

若一个格子上初始时的数大于与其相邻的格子数，则答案显然为 No 。
否则，将所有格子上的数增加至与其相邻的格子数一定会形成一组合法解。

单组数据时间复杂度 O ( N × M ) O(N\times M) O(N×M) 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 305;
const int dx[4] = {0, 0, 1, -1};
const int dy[4] = {1, -1, 0, 0};
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
int n, m, a[MAXN][MAXN], d[MAXN][MAXN];
int main() {
	int T; read(T);
	while (T--) {
		read(n), read(m);
		for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			read(a[i][j]), d[i][j] = 0;
		for (int i = 1; i <= n - 1; i++)
		for (int j = 1; j <= m; j++)
			d[i][j]++, d[i + 1][j]++;
		for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m - 1; j++)
			d[i][j]++, d[i][j + 1]++;
		bool ans = true;
		for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			if (a[i][j] > d[i][j]) ans = false;
		if (ans) {
			puts("YES");
			for (int i = 1; i <= n; i++) {
				for (int j = 1; j <= m; j++)
					printf("%d ", d[i][j]);
				printf("\n");
			}
		} else puts("NO");
	}
	return 0;
}

Problem C. Element Extermination

答案为 Yes 当且仅当 a 1 ≤ a N a_1\leq a_N a1​≤aN​ 。

考虑其必要性，若 a 1 > a N a_1>a_N a1​>aN​ ，则无论如何操作，序列中第一个元素将始终大于最后一个元素，从而不可能使序列的长度减少至 2 2 2 以下。考虑其充分性，则在保证 a 1 ≤ a N a_1\leq a_N a1​≤aN​ 的情况下任意操作即可构造出一组消除方案，由于 a 1 ≤ a N a_1\leq a_N a1​≤aN​ ，序列长度 ≥ 2 \geq2 ≥2 的时候，一定存在可以操作的位置。

单组数据时间复杂度 O ( N ) O(N) O(N) 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
int main() {
	int T; read(T);
	while (T--) {
		int n; read(n);
		int x = 0, y = 0;
		for (int i = 1; i <= n; i++) {
			int z; read(z);
			if (i == 1) x = z;
			else y = z;
		}
		if (x < y) puts("YES");
		else puts("NO");
	}
	return 0;
}

Problem D. Replace by MEX

考虑通过操作序列使得 a i = i − 1 a_i=i-1 ai​=i−1 。

令序列当前的 Mex 为 x   ( x ≤ N ) x\ (x\leq N) x (x≤N) ，显然，序列中此时不存在元素 x x x 。
若 x < N x<N x<N ，则说明 a x + 1 ≠ x a_{x+1}\ne x ax+1​​=x ，令 a x + 1 = x a_{x+1}=x ax+1​=x 即可。
若 x = N x=N x=N ，则任意操作一个尚不满足 a i = i − 1 a_i=i-1 ai​=i−1 的位置。

单组数据时间复杂度 O ( N 2 ) O(N^2) O(N2) ，操作次数不超过 2 N 2N 2N 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
int n, a[MAXN];
int cur() {
	static int vis[MAXN], tag = 0; tag++;
	for (int i = 1; i <= n; i++)
		vis[a[i]] = tag;
	int ans = 0;
	while (vis[ans] == tag) ans++;
	return ans;
}
bool check() {
	for (int i = 2; i <= n; i++)
		if (a[i - 1] > a[i]) return false;
	return true;
}
int main() {
	int T; read(T);
	while (T--) {
		read(n);
		for (int i = 1; i <= n; i++)
			read(a[i]);
		vector <int> ans;
		while (!check()) {
			int val = cur();
			if (val != n) {
				a[val + 1] = val;
				ans.push_back(val + 1);
			} else {
				int pos = 0;
				for (int i = 1; i <= n; i++)
					if (a[i] != i - 1) pos = i;
				a[pos] = val;
				ans.push_back(pos);
			}
		}
		cout << ans.size() << endl;
		for (auto x : ans) printf("%d ", x);
		printf("\n");
	}
	return 0;
}

Problem E. Inversion SwapSort

考虑在不破坏后续元素的相对大小关系的情况下，将最小的元素移动至 a 1 a_1 a1​ ，同时消耗掉所有的包含位置 1 1 1 的逆序对 ( 1 , x i ) (1,x_i) (1,xi​) 贡献的操作。

则按照 a x i a_{x_i} axi​​ 从大到小的顺序依次操作 ( 1 , x i ) (1,x_i) (1,xi​) 即可。
由此，我们将问题缩小了规模，可以递归解决。

时间复杂度 O ( N 2 L o g N ) O(N^2LogN) O(N2LogN) 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
int n, a[MAXN];
int main() {
	read(n);
	vector <pair <int, int>> ans;
	for (int i = 1; i <= n; i++)
		read(a[i]);
	for (int i = 1; i <= n; i++) {
		vector <int> p;
		for (int j = i + 1; j <= n; j++)
			if (a[j] < a[i]) p.push_back(j);
		sort(p.begin(), p.end(), [&] (int x, int y) {
			if (a[x] != a[y]) return a[x] > a[y];
			else return x > y;
		});
		for (auto x : p) ans.emplace_back(i, x);
	}
	cout << ans.size() << endl;
	for (auto x : ans) printf("%d %d\n", x.first, x.second);
	return 0;
}

Problem F. Integer Game

令 a < b < c a<b<c a<b<c ，考虑 1 1 1 号玩家的将军局面。
则 1 1 1 号玩家可以直接取胜当且仅当 2 2 2 号玩家上一次操作了 c c c ，且
b − a = c − b b-a=c-b b−a=c−b

1 1 1 号玩家可以采取如下策略保证自己获胜：
( 1 ) (1) (1) 、令 x = 1 0 9 + 7 x=10^9+7 x=109+7 ，保证在 2 2 2 号玩家完成操作后，被操作的数是最大的。
( 2 ) (2) (2) 、令 a < b < c , x = 2 c − b − a a<b<c,x=2c-b-a a<b<c,x=2c−b−a ，由于 2 2 2 号玩家无法操作 c c c ，此时其无论如何操作，三个数都将形成一个等差数列，或是 b , c , 2 c − b b,c,2c-b b,c,2c−b ，或是 a , c , 2 c − a a,c,2c-a a,c,2c−a 。
( 3 ) (3) (3) 、令 a < b < c , x = c − b a<b<c,x=c-b a<b<c,x=c−b ，可以保证 2 2 2 号玩家无法操作。

时间复杂度 O ( 1 ) O(1) O(1) 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
ll a[4]; int res;
void getres(int &res) {
	cin >> res;
	if (res == 0) exit(0);
}
ll gety() {
	ll Max = 0, ans = 0;
	for (int i = 1; i <= 3; i++)
		chkmax(Max, a[i]);
	for (int i = 1; i <= 3; i++)
		if (Max == a[i]) ans += a[i] * 2;
		else ans -= a[i];
	return ans;
}
int main() {
	read(a[1]), read(a[2]), read(a[3]);
	puts("First");
	int x = 1e9 + 7; cout << x << endl;
	getres(res); a[res] += x;
	ll y = gety(); cout << y << endl;
	getres(res); a[res] += y;
	sort(a + 1, a + 4);
	assert(a[2] - a[1] == a[3] - a[2]);
	cout << a[2] - a[1] << endl;
	getres(res), assert(false);
	return 0;
}

Problem G. Tree Modification

枚举最终形成的菊花的中心 x x x ，考虑如何以最少的操作次数完成转化。

令距离 x x x 为偶数的节点数为 A n s Ans Ans ，则不难构造出一种 A n s − 1 Ans-1 Ans−1 次操作的方案。并且，考虑图的二分图染色，可以发现，一次操作仅改变了一个点的颜色，因此 A n s − 1 Ans-1 Ans−1 也是操作次数的下界。

由此，答案即为将图二分图染色后，点数较少的颜色的点数 − 1 -1 −1 。
由于写程序的时候没有分析透彻，下文的代码使用了换根树形 DP 的方式计算了以上数值。

时间复杂度 O ( N ) O(N) O(N) 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
int ans, dp[MAXN][2], sum[MAXN][2];
vector <int> a[MAXN];
void update(int pos) {
	dp[pos][0] = sum[pos][1] + 1;
	dp[pos][1] = sum[pos][0];
}
void getdp(int pos, int fa) {
	for (auto x : a[pos])
		if (x != fa) {
			getdp(x, pos);
			sum[pos][0] += dp[x][0];
			sum[pos][1] += dp[x][1];
		}
	update(pos);
}
void getans(int pos, int fa) {
	chkmin(ans, dp[pos][0] - 1);
	for (auto x : a[pos])
		if (x != fa) {
			sum[pos][0] -= dp[x][0];
			sum[pos][1] -= dp[x][1];
			update(pos);
			sum[x][0] += dp[pos][0];
			sum[x][1] += dp[pos][1];
			update(x);
			getans(x, pos);
			sum[x][0] -= dp[pos][0];
			sum[x][1] -= dp[pos][1];
			update(x);
			sum[pos][0] += dp[x][0];
			sum[pos][1] += dp[x][1];
			update(pos);
		}
}
int main() {
	int n; read(n);
	for (int i = 1; i <= n - 1; i++) {
		int x, y; read(x), read(y);
		a[x].push_back(y);
		a[y].push_back(x);
	}
	ans = n + 1;
	getdp(1, 0);
	getans(1, 0);
	cout << ans << endl;
	return 0;
}

Problem H. Set Merging

首先，考虑一个操作次数 N 2 N^2 N2 的解法，我们需要对所有区间，求出对应的集合。

考虑对权值分治，令 M = ⌊ N 2 ⌋ M=\lfloor\frac{N}{2}\rfloor M=⌊2N​⌋ ，首先求出数组 a i a_i ai​ 权值在 [ 1 , M ] [1,M] [1,M] 内的子序列所有区间对应的集合，以及数组 a i a_i ai​ 权值在 [ M + 1 , N ] [M+1,N] [M+1,N] 内的子序列所有区间对应的集合。此时，原数组的任意一个区间对应的集合都可以通过不少于一次操作获得。

考虑分析其操作次数 T ( N ) T(N) T(N) ，有
T ( N ) = ( N + 1 2 ) + T ( ⌊ N 2 ⌋ ) + T ( ⌈ N 2 ⌉ ) ≈ N 2 T(N)=\binom{N+1}{2}+T(\lfloor\frac{N}{2}\rfloor)+T(\lceil\frac{N}{2}\rceil)\approx N^2 T(N)=(2N+1​)+T(⌊2N​⌋)+T(⌈2N​⌉)≈N2

对于原问题，考虑对权值进行分块处理，令块长为 B B B ，则总操作次数约为
N B × B 2 + Q × N B \frac{N}{B}\times B^2+Q\times \frac{N}{B} BN​×B2+Q×BN​

那么，令 B = Q B=\sqrt{Q} B=Q ​ 即可。
时间复杂度 O ( N 2 + N Q ) O(N^2+N\sqrt{Q}) O(N2+NQ ​) ，操作次数约为 2 N Q 2N\sqrt{Q} 2NQ ​ 。

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 5005;
const int MAXQ = 2e5 + 5;
const int Limit = 2.2e6;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
struct info {
	int l[MAXN], r[MAXN];
	vector <vector <int>> home;
	void init(int x) {
		home.resize(x + 1);
		for (int i = 0; i <= x; i++)
			home[i].resize(x + 1);
	}
	int query(int ql, int qr) {
		if (l[ql] > r[qr]) return 0;
		else return home[l[ql]][r[qr]];
	}
} res[MAXN];
int n, q, size, a[MAXN], b[MAXN], k[MAXQ];
int tot, block, ql[MAXN], qr[MAXN], belong[MAXN];
vector <pair <int, int>> ans;
int merge(int x, int y) {
	if (x == 0 || y == 0) return x + y;
	ans.emplace_back(x, y);
	assert(++size <= Limit);
	return size;
}
info getres(int l, int r) {
	if (l == r) {
		info ans;
		for (int i = 1; i <= n; i++) {
			ans.l[i] = 1 + (i > b[l]);
			ans.r[i] = (i >= b[r]);
		}
		ans.init(1);
		ans.home[1][1] = b[l];
		return ans;
	}
	int mid = (l + r) / 2;
	info ans, ansl, ansr;
	ansl = getres(l, mid);
	ansr = getres(mid + 1, r);
	for (int i = 1, j = 1, k = 0; i <= n; i++) {
		k += (l <= a[i] && a[i] <= r);
		ans.l[i] = j, ans.r[i] = k;
		j += (l <= a[i] && a[i] <= r);
	}
	ans.init(r - l + 1);
	for (int i = 1; i <= n; i++)
		if (l <= a[i] && a[i] <= r) {
			for (int j = i; j <= n; j++)
				if (l <= a[j] && a[j] <= r) {
					ans.home[ans.l[i]][ans.r[j]] = merge(ansl.query(i, j), ansr.query(i, j));
				}
		}
	return ans;
}
int main() {
	read(n), read(q), size = n;
	for (int i = 1; i <= n; i++)
		read(a[i]), b[a[i]] = i;
	block = 1 << 8;
	for (int i = 1; i <= n; i++) {
		if (i % block == 1 % block) ql[++tot] = i;
		qr[tot] = i, belong[i] = tot;
	}
	for (int i = 1; i <= tot; i++)
		res[i] = getres(ql[i], qr[i]);
	for (int i = 1; i <= q; i++) {
		int ql, qr, cur = 0; read(ql), read(qr);
		for (int j = 1; j <= tot; j++)
			cur = merge(cur, res[j].query(ql, qr));
		k[i] = cur;
	}
	printf("%d\n", size);
	for (auto x : ans)
		printf("%d %d\n", x.first, x.second);
	for (int i = 1; i <= q; i++)
		printf("%d ", k[i]);
	printf("\n");
	return 0;
}
cz_xuyixuan
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces global round 10_Codeforces_
10-01
9. **提交与评判**：在Codeforces平台上，参赛者将源代码提交后，由自动评测系统进行运行和测试，根据输出结果判定是否正确，给出相应的得分。 10. **竞赛策略**：除了技术层面，参赛者还需要考虑比赛策略，如先解...
Codeforces Global Round 9 - A. Sign Flipping (思维，贪心)
give it a try
07-05 423
题目传送 题意: 给你一个n大小的数组(n一定为奇数)，现在你可以改变其中元素的符号，现在要求你在操作后，使得有至少一半的ai <= ai+1，至少有一半ai >= ai+1，现在让你构造出这个数组 思路: 我们直接正负正负的一直下去，由于n为奇数，那么肯定就满足条件了 AC代码 #include <bits/stdc++.h> inline long long read(){char c = getchar();long long x = 0,s = 1; while(c <
Codeforces Global Round 9全题解
Kuricip的博客
07-07 987
A. Sign Flipping 题面： 给你一个n大小的数组(n一定为奇数)，现在你可以改变其中元素的符号（+/-） 在操作后，使得有至少一半的ai <= ai+1，至少有一半ai >= ai+1，现在让你构造出这个数组 思路： 1、直接正负正负（或者负正负正）的一直下去，由于n为奇数，那么肯定就满足条件 2、直接在全取绝对值，然后正负正负（或者负正负正）。 代码： #include<stdio.h> #include<iostream> using namespa
Codeforces Global Round 9（A~D题解）
LucyHolmes的博客
07-07 246
暑假要好好训练了 昨日补题（虽然好像只补了简单题，但是思维真的生涩 啊） 题目链接：Global Round 9 目录A. Sign FlippingB. Neighbor GridC. Element ExterminationD. Replace by MEX A. Sign Flipping 思路：可以理解为翻牌子一样，有正反两种情况，不用考虑初始状态，直接暴力将牌子安排成正反交错即可。 #include<bits/stdc++.h> using namespace std; #defin
Codeforces Global Round 9——A.B.C
Celavia_yu的博客
07-06 289
Codeforces Global Round 9 A. Sign Flipping 题目描述 You are given nn integers a1,a2,…,an, where nn is odd. You are allowed to flip the sign of some (possibly all or none) of them. You wish to perform these flips in such a way that the following conditions hold
Codeforces Global Round 9 A~D题解
Sivannn的博客
07-05 593
传送门 A.Sign FlippingB.Neighbor GridC.Element ExterminationD.Replace by MEX A.Sign Flipping        题意：给一个包含nnn个整数的数组，可以随意改变他们的正负号使得至少有n−12\frac{n-1}{2}2n−1​个相邻数字的差≥0\ge0≥0，且至少有n−12\frac{n-1}{2}2n−1​个相邻数字的差≤0\leq0≤0。  
Codeforces round 678 D2_Codeforces_
10-01
本次提及的是Codeforces round 678的第二部分（division 2），通常这类比赛会包含四道题目，分别标记为A、B、C和D，难度逐渐递增。 在提供的压缩包文件中，我们看到了四个文件：d.cpp、c.cpp、b.cpp和a.out。这代表...
Codeforces Global Round 7 C. Permutation Partitions
01-03
C. Permutation Partitions 题目链接-C. Permutation Partitions 题目大意 给定一个 1−n 上的全排列，将这个全排列分成不相交的 k 段，定义该划分的value为各段最大值的和，求该全排列所有可能划分中 value的...
Codeforces Global Round 7 A. Bad Ugly Numbers
01-03
A. Bad Ugly Numbers 题目链接-A. Bad Ugly Numbers 题目大意 输出一个位数为n的数s，且该数每一位数字都不能被s整除 解题思路 贪心 如果n为1，那么无论s是哪个数字都必定能整除自身 如果n不为n，那么577…77和233...
Codeforces Global Round 7 C. Permutation Partitions（思维）
01-03
传送门 题意： 给两个数n,k 把长度为n的数组分成k个不相交的区间 把分成每个区间的最大值加在一起 找到和的最大值，并输出共有多少种分法等于该最大值 思路： 要想值最大，那前k大的数肯定在不同的区间 ...
Codeforces Global Round 9 ABCD
hrdate(菜菜菜带带带)
07-05 351
比赛连接:Codeforces Global Round 9 传送门 目录A - Sign FlippingB - Neighbor GridC - Element ExterminationD - Replace by MEX A - Sign Flipping 题意：可以随意改变a[i]的正负符号，要求至少有(n-1)/2个a[i]-a[i+1]≥0和至少有(n-1)/2个a[i]-a[i+1]≤0 题解：相邻两个数的正负符号不同 #pragma GCC optimize(2) #include &lt
Codeforces Global Round 1（solve7/8）
passer__的博客
02-21 286
题目链接:https://codeforces.com/contest/1110 A题 题意:给你一个多项式，求最后是奇数还是偶数 思想:假如进制是偶数的话，只需要考虑最后*1的即可。进制是奇数的话，考虑下有多少位是奇数即可。 B题 题意:给你一个长度为m的杆子，有n个断了，然后最多粘粘k次，问你最小花费是多少，花费是粘连的距离和。 思想:先考虑每个点都粘上了，那么粘了n个点，然后在计...
Codeforces Global Round 9-A Sign Flipping
ACkingdom的博客
07-06 142
题目链接 题意： 给你一个数组，你可以改变任意数字的正负号来使该数组一半的数满足a[i]>=a[i+1]。 思路： 因为只需要一半满足，所以我们只需要把数组中的数不考虑原来符号直接正负正负正的输出即可。 代码： #include<bits/stdc++.h> using namespace std; #define int long long #define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0); const int
Codeforces Global Round 8 B. Codeforces Subsequences
untilyouydc
06-19 280
题目链接 思路：最少的字符数量，必然是利用组合数进行乘法运算。codeforces一共10个字符，当每个字符都增加一个的话，有2^10种选择，同理，每个字符都增加2个的话，有3^10种选择..... 所以首先需要找到x^10 >k 。然后，按位数减小x即可。 #include <bits/stdc++.h> using namespace std; long long get(long long k) { int j=k; for(int i=1;i<10;i
Codeforces Global Round 7 （A~D）
wait
03-20 414
昨晚没报上名导致没打，不过我这菜鸡，打不打貌似都一样...... A：Bad Ugly Numbers 题意：让你找出来一个n位数s，对于s的每一位，s都不是其倍数，并且不含0； 找到特殊组合即可；我找的2333333....... #include <bits/stdc++.h> using namespace std; int main() { int t,n; ci...
Codeforces Global Round 8 D. AND, OR and square sum 题解（位运算）
hunxuewangzi的博客
06-19 349
题目链接 题目大意 给你长为n的a数组，你可以进行任意多次的操作，操作为选择a[i],a[j]使a[i]=a[i]|a[j]，a[j]=a[i]&a[j]. 求 题目思路 显然无论怎么操作把他们转换为二进制后，二进制每一位对应的1的个数不变。 直接把每个位的1算出来，然后分配，尽可能要大的数最大即可 代码 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int maxn=2e5+5; int
Codeforces Global Round 9 解题报告
Andrewzdm的小窝
07-06 266
CF1375A Sign Flipping 非常简单的一道构造题。 首先，nnn 必定为奇数，那么 n−1n-1n−1 必定为偶数，即相邻两数差的个数也是偶数。 题目里说了至少有 n−12\dfrac{n-1}{2}2n−1​ 个差为非负，也至少有 n−12\dfrac{n-1}{2}2n−1​ 个差为非正。 注意到相邻两数计算的方法为 ai+1−aia_{i+1}-a_iai+1​−ai​，那么不难想到我们只要让 aia_iai​ 的符号按“正、负、正、负、正……”的顺序排列就可以了。这样一来，差的正负就
Codeforces Global Round 8 A. C+= (思维)
give it a try
06-19 280
题目传送 题意: 给你俩个数a，b现在你能进行 += 操作，比如 a += b，那么a的值会加上b，而b不会变，现在给的a，b都是整数，再给一个正整数n，问最少进行几次操作使得其中的一个数大于n? 思路: 友情提示，一定要认真读题，第一次看成了俩个数都要大于n，第二次看成了，只要一个数大于等于n即可。。。。其实题目就是一个数严格大于n即可。。。 要最少操作次数，那么每次我加上最大的那个数就好啦(使得价值的增加更快) AC代码 #include <bits/stdc++.h> inline lon
Codeforces Global Round 8 A-D
bjfu170203101的博客
06-21 220
A:显然 交替加 增大最快 #include <bits/stdc++.h> using namespace std; typedef long long ll; #define ls (o<<1) #define rs (o<<1|1) #define pb push_back const double PI= acos(-1.0); const int M = 1e5+7; /* int head[M],cnt=1; void init(){cnt=1,memse
codeforces global round 16
最新发布
03-16
好的，Codeforces 全球赛第 16 场已于 2022 年 7 月 31 日举行。这是一场由 Codeforces 组织的在线编程比赛，涉及算法和数据结构等方面的知识，吸引了来自全球各地的编程爱好者参加。 比赛包括 6 个问题，难度从 A ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值