【CodeForces】CodeForces Round #505 (Div. 1 + Div. 2) 题解

最新推荐文章于 2022-08-17 17:50:22 发布
最新推荐文章于 2022-08-17 17:50:22 发布
阅读量550 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 【OJ】CodeForces 【类型】做题记录 【比赛】CodeForces 【算法】数学 【算法】Two Pointers 【算法】动态规划 【算法】构造与证明 【算法】Meet in the Middle 【算法】计算几何 【算法】势能分析 【算法】概率与期望
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_39972971/article/details/81980095
本文提供了CodeForces Round #505 (Div. 1 + Div. 2) 比赛的详细题解，包括每道题目的思路要点和代码实现。涉及的问题包括字符串处理、数论、图论等算法知识，时间复杂度从O(N)到O(N^3)不等。

【比赛链接】

【题解链接】

**【A】**Doggo Recoloring

【思路要点】

  • 首先当 N = 1 N=1 N=1，答案为 Y e s Yes Yes。
  • 否则，当且仅当存在一个字符出现了至少两次，答案为 Y e s Yes Yes。
  • 时间复杂度 O ( N ) O(N) O(N)。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
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;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
int n, cnt[256]; char s[MAXN];
int main() {
	int n; read(n);
	bool ans = n == 1;
	scanf("\n%s", s + 1);
	for (int i = 1; i <= n; i++) {
		if (cnt[s[i]]) ans = true;
		cnt[s[i]]++;
	}
	if (ans) printf("Yes\n");
	else printf("No\n");
	return 0;
}

**【B】**Weakened Common Divisor

【思路要点】

  • 令 c i = a i ∗ b i c_i=a_i*b_i ci​=ai​∗bi​，令所有 c i c_i ci​的 g c d gcd gcd为 g g g，当且仅当 g = 1 g=1 g=1，答案为 − 1 -1 −1。
  • 否则， g g g的每一个质因数一定都可以作为答案，我们只需要找到 g g g的任意一个可以作为答案的因数即可，注意这里 g g g可能是两个大质数的乘积，因此不能直接质因数分解。
  • 实际上我们只需要通过判断 g c d ( g , a i ) gcd(g,a_i) gcd(g,ai​)是否为 1 1 1来判断 a i a_i ai​是不是可取的，若 g c d ( g , a i ) ≠ 1 gcd(g,a_i)\ne1 gcd(g,ai​)̸​=1，则令 g = g c d ( g , a i ) g=gcd(g,a_i) g=gcd(g,ai​)，否则令 g = g c d ( g , b i ) g=gcd(g,b_i) g=gcd(g,bi​)，最终得到的 g g g即为答案。
  • 时间复杂度 O ( N L o g V ) O(NLogV) O(NLogV)。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 150005;
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;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
long long x[MAXN], y[MAXN];
long long gcd(long long x, long long y) {
	if (y == 0) return x;
	else return gcd(y, x % y);
}
int main() {
	long long ans = 0;
	int n; read(n);
	for (int i = 1; i <= n; i++) {
		read(x[i]), read(y[i]);
		ans = gcd(x[i] * y[i], ans);
	}
	if (ans == 1) {
		printf("-1\n");
		return 0;
	}
	for (int i = 1; i <= n; i++) {
		if (gcd(ans, x[i]) != 1) ans = gcd(ans, x[i]);
		else ans = gcd(ans, y[i]);
	}
	writeln(ans);
	return 0;
}

**【C】**Plasticine zebra

【思路要点】

  • 考虑将序列首尾相接，形成一个环。
  • 题目中给出的操作实际上就是将环在某处断开，重新形成一个序列。
  • 因此用 T w o P o i n t e r s Two Pointers TwoPointers求出环上最长的合法序列即可。
  • 时间复杂度 O ( N ) O(N) O(N)。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
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;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
char s[MAXN];
int main() {
	scanf("\n%s", s + 1);
	int n = strlen(s + 1);
	for (int i = 1; i <= n; i++)
		s[i + n] = s[i];
	int ans = 0, nxt = 1;
	for (int i = 1; i <= n; i++) {
		chkmax(nxt, i);
		while (nxt - i + 1 < n && s[nxt + 1] != s[nxt]) nxt++;
		chkmax(ans, nxt - i + 1);
	}
	writeln(ans);
	return 0;
}

**【D】**Recovering BST

【思路要点】

  • 记 d p i , j , 0 / 1 dp_{i,j,0/1} dpi,j,0/1​表示用 a i , a i + 1 , a i + 2 , . . . , a j a_i,a_{i+1},a_{i+2},...,a_j ai​,ai+1​,ai+2​,...,aj​是否能够构成一棵满足条件的二叉树，并且其根节点与 a i − 1 / a j + 1 a_{i-1}/a_{j+1} ai−1​/aj+1​互质。
  • 预处理数字之间的互质关系，简单区间 D P DP DP即可。
  • 时间复杂度 O ( N 3 ) O(N^3) O(N3)。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 705;
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;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
int n, a[MAXN];
bool mp[MAXN][MAXN];
bool dp[MAXN][MAXN][2];
int gcd(int x, int y) {
	if (x == 0 || y == 0) return x + y;
	else return gcd(y, x % y);
}
int main() {
	read(n);
	for (int i = 1; i <= n; i++)
		read(a[i]);
	for (int i = 0; i <= n + 1; i++)
	for (int j = 0; j <= n + 1; j++)
		mp[i][j] = gcd(a[i], a[j]) >= 2;
	for (int i = 0; i <= n; i++)
		dp[i + 1][i][0] = dp[i + 1][i][1] = true;
	for (int len = 1; len <= n; len++) {
		for (int i = 1, j = len; j <= n; i++, j++) {
			for (int k = i; k <= j; k++) {
				dp[i][j][0] |= mp[i - 1][k] && dp[i][k - 1][1] && dp[k + 1][j][0];
				dp[i][j][1] |= mp[j + 1][k] && dp[i][k - 1][1] && dp[k + 1][j][0];
			}
		}
	}
	if (dp[1][n][0]) printf("Yes\n");
	else printf("No\n");
	return 0;
}

**【E】**Colored Cubes

【思路要点】

  • 本题主要的思想在于 M e e t I n T h e M i d d l e MeetInTheMiddle MeetInTheMiddle。
  • 我们可以将初始状态通过一种方式移动到一个比较有规律的状态（例如所有棋子都在对角线上，或者所有棋子都在最左边一排）。
  • 同样的，我们可以将目标状态通过一种方式移动到一个比较有规律的状态，这个操作序列倒过来就是从一个比较有规律的状态移动到目标状态的方式。
  • 剩余的工作就在于衔接两个比较有规律的状态了。
  • 下面的代码实现了将初始状态移动到第一行，将目标状态移动到最后一行，再将两个状态进行衔接。
  • 时间复杂度 O ( N 2 ) O(N^2) O(N2)，操作次数 O ( 4 ∗ N 2 ) O(4*N^2) O(4∗N2)。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 55;
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;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
struct point {int x, y; };
point a[MAXN], b[MAXN];
int n, m, homea[MAXN], homeb[MAXN];
bool vis[MAXN];
vector <point> ansx, ansy, bnsx, bnsy;
void getans() {
	memset(vis, 0, sizeof(vis));
	for (int i = 1; i <= m; i++) {
		//pos -> (1, i);
		int pos = 0, val = 1e9;
		for (int j = 1; j <= m; j++)
			if (!vis[j]) {
				int tmp = abs(a[j].x - 1) + abs(a[j].y - i);
				if (tmp < val) {
					val = tmp;
					pos = j;
				}
			}
		vis[pos] = true;
		homea[pos] = i;
		while (a[pos].y < i) {
			ansx.push_back(a[pos]);
			a[pos].y++;
			ansy.push_back(a[pos]);
		}
		while (a[pos].y > i) {
			ansx.push_back(a[pos]);
			a[pos].y--;
			ansy.push_back(a[pos]);
		}
		while (a[pos].x > 1) {
			ansx.push_back(a[pos]);
			a[pos].x--;
			ansy.push_back(a[pos]);
		}
	}
}
void getbns() {
	memset(vis, 0, sizeof(vis));
	for (int i = 1; i <= m; i++) {
		//pos -> (1, n);
		int pos = 0, val = 1e9;
		for (int j = 1; j <= m; j++)
			if (!vis[j]) {
				int tmp = abs(b[j].x - n) + abs(b[j].y - i);
				if (tmp < val) {
					val = tmp;
					pos = j;
				}
			}
		vis[pos] = true;
		homeb[pos] = i;
		while (b[pos].y < i) {
			bnsy.push_back(b[pos]);
			b[pos].y++;
			bnsx.push_back(b[pos]);
		}
		while (b[pos].y > i) {
			bnsy.push_back(b[pos]);
			b[pos].y--;
			bnsx.push_back(b[pos]);
		}
		while (b[pos].x < n) {
			bnsy.push_back(b[pos]);
			b[pos].x++;
			bnsx.push_back(b[pos]);
		}
	}
}
int main() {
	read(n), read(m);
	for (int i = 1; i <= m; i++)
		read(a[i].x), read(a[i].y);
	for (int i = 1; i <= m; i++)
		read(b[i].x), read(b[i].y);
	if (n == 1) {
		printf("0\n");
		return 0;
	}
	getans();
	getbns();
	if (n == 2 && homea[1] != homeb[1]) {
		ansx.push_back((point) {1, 1});
		ansy.push_back((point) {2, 1});
		ansx.push_back((point) {2, 1});
		ansy.push_back((point) {2, 2});
		ansx.push_back((point) {1, 2});
		ansy.push_back((point) {1, 1});
		ansx.push_back((point) {1, 1});
		ansy.push_back((point) {2, 1});
	} else {
		for (int i = 1; i <= m; i++) {
			ansx.push_back(a[i]);
			a[i].x++;
			ansy.push_back(a[i]);
			while (a[i].y < b[i].y) {
				ansx.push_back(a[i]);
				a[i].y++;
				ansy.push_back(a[i]);
			}
			while (a[i].y > b[i].y) {
				ansx.push_back(a[i]);
				a[i].y--;
				ansy.push_back(a[i]);
			}
			while (a[i].x < n) {
				ansx.push_back(a[i]);
				a[i].x++;
				ansy.push_back(a[i]);
			}
		}
	}
	writeln(ansx.size() + bnsx.size());
	for (unsigned i = 0; i < ansx.size(); i++)
		printf("%d %d %d %d\n", ansx[i].x, ansx[i].y, ansy[i].x, ansy[i].y);
	reverse(bnsx.begin(), bnsx.end());
	reverse(bnsy.begin(), bnsy.end());
	for (unsigned i = 0; i < bnsx.size(); i++)
		printf("%d %d %d %d\n", bnsx[i].x, bnsx[i].y, bnsy[i].x, bnsy[i].y);
	return 0;
}

**【F】**Disjoint Triangles

【思路要点】

  • 在题目限制的三点不共线条件下，一对相离的三角形间有且仅有两条内公切线。
  • 考虑枚举内公切线，在左边和右边任取两点就能够形成一个合法的三角形对。
  • 那么只需要按照两点之间向量的极角序枚举点对（公切线），并且动态维护所有点到当前直线的偏序关系即可，当我们枚举到 ( x , y ) (x,y) (x,y)时，由于题目保证了不存在三点共线， x x x和 y y y在偏序关系中一定是相邻的两个点，在枚举后交换两点的排名即可。
  • 时间复杂度 O ( N 2 L o g N ) O(N^2LogN) O(N2LogN)。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2005;
const int MAXM = 4e6 + 5;
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;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
struct point {int x, y; };
point operator + (point a, point b) {return (point) {a.x + b.x, a.y + b.y}; }
point operator - (point a, point b) {return (point) {a.x - b.x, a.y - b.y}; }
point operator * (point a, int b) {return (point) {a.x * b, a.y * b}; }
long long operator * (point a, point b) {return 1ll * a.x * b.y - 1ll * a.y * b.x; }
bool operator < (point a, point b) {
	if (a.y == b.y) return a.x > b.x;
	else return a.y < b.y;
}
struct posi {point pos; int num; };
struct info {long double angle; int x, y; };
long long ans; int n, home[MAXN]; 
posi a[MAXN]; info b[MAXM];
void Swap(int x, int y) {
	long long tmp = home[x] - 1;
	long long tnp = n - home[y];
	ans += tmp * (tmp - 1) / 2 * tnp * (tnp - 1) / 2;
	swap(home[x], home[y]);
}
bool cmp(posi a, posi b) {
	return a.pos < b.pos;
}
bool cnp(info a, info b) {
	return a.angle < b.angle;
}
int main() {
	read(n);
	for (int i = 1; i <= n; i++)
		read(a[i].pos.x), read(a[i].pos.y);
	sort(a + 1, a + n + 1, cmp);
	for (int i = 1; i <= n; i++)
		a[i].num = i, home[i] = i;
	int tot = 0;
	for (int i = 1; i <= n; i++)
	for (int j = 1; j <= n; j++)
		if (i != j) {
			point tmp = a[j].pos - a[i].pos;
			b[++tot] = (info) {atan2l(tmp.y, tmp.x), i, j};
		}
	sort(b + 1, b + tot + 1, cnp);
	for (int i = 1; i <= tot; i++)
		Swap(b[i].y, b[i].x);
	writeln(ans / 2);
	return 0;
}

**【G】**Company Acquisitions

【思路要点】

  • 定义一个有 k k k个白点跟随的红点 i i i的势能函数 f ( i ) = 2 k − 1 f(i)=2^k-1 f(i)=2k−1。

  • 定义一个局面的势能为所有红点的的势能之和。

  • 目标状态的势能为 2 n − 1 − 1 2^{n-1}-1 2n−1−1。

  • 假设在一轮操作中，一个有 p p p个白点跟随的红点和一个有 q q q个白点跟随的红点被选中了，那么势能的期望变化量应该等于

    δ = 1 2 ( ( 2 p + 1 − 1 ) − ( 2 p − 1 ) − ( 2 q − 1 ) ) + 1 2 ( ( 2 q + 1 − 1 ) − ( 2 q − 1 ) − ( 2 p − 1 ) ) = 1 \delta=\frac{1}{2}((2^{p+1}-1)-(2^p-1)-(2^q-1))+\frac{1}{2}((2^{q+1}-1)-(2^q-1)-(2^p-1))=1 δ=21​((2p+1−1)−(2p−1)−(2q−1))+21​((2q+1−1)−(2q−1)−(2p−1))=1

  • 因此期望步数即为目标状态的势能减去当前状态的势能。

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

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int P = 1e9 + 7;
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;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
int n, bit[MAXN], cnt[MAXN], a[MAXN];
int main() {
	read(n), bit[0] = 1;
	for (int i = 1; i <= n; i++) {
		bit[i] = bit[i - 1] * 2 % P;
		read(a[i]);
		if (a[i] != -1) cnt[a[i]]++;
	}
	int ans = bit[n - 1] - 1;
	for (int i = 1; i <= n; i++)
		if (a[i] == -1) ans = (ans - (bit[cnt[i]] - 1)) % P;
	writeln((ans + P) % P);
	return 0;
}
Codeforces Round #758 (Div.1 + Div. 2)
Code_Shark的博客
12-18 436
A. Find Array 题意： 给一个数字nnn要求寻找出一个长为nnn的数组aaa，保证： 1≤ai≤1091\le a_i \le 10^91≤ai​≤109 a1<a2<⋯<ana_1<a_2<\dots<a_na1​<a2​<⋯<an​ 对于i≥2i\ge 2i≥2，aia_iai​不可以被ai−1a_{i-1}ai−1​整除 分析： 直接返回222到n+1n+1n+1即可 代码： #include<bits/stdc++.h&gt
Codeforces Round #838 (Div. 2)题解
Kicamon的博客
12-16 738
这场的状态不太好。
Codeforces Round #505
diebenger6280的博客
08-20 137
Codeforces Round #505 A. Doggo Recoloring 题目描述：给定一个字符串，每次选择一个在字符串里面出现至少两次的字符，然后将这种字符变成那一种指定的字符，问最终这个字符串能否只剩一种字符。 solution 当长度为\(1\)是，答案是\(Yes\)，当长度大于\(1\)时，如果有字符至少出现两次，则答案为\(Yes\)。 时间复杂度：\(O(n)\...
Codeforces Round #505 (rated, Div. 1 + Div. 2, based on VK Cup 2018 Final) B. Weakened Common Divis
pubgoso的博客
03-27 243
题目链接 让你找一个数，使得这个数，可以被每个二元组的两个数中的一个数整除。 先将第一个二元组的两个数质因数分解一下，分解的质数加入set中，然后，对剩下的n-1个二元组进行遍历，每次遍历到的二元组对s中的质数进行判断是否能整除。如果某个质数可以被n-1个二元组整除（两个数中的一个）。 好浅显的思路，，，可是我就是没想到，，，哭辽，xyqnb mdhnb fyznb %大佬 #include&lt...
Codeforces Round #505 (rated, Div. 1 + Div. 2, based on VK Cup 2018 Final) 题解
aozhuan8489的博客
08-21 145
真心简单的一场比赛 就是坑比较多（自己太蠢） A是一个水题 3分钟的时候过了 B也是一个比较简单的题 类似的套路见得多了 但是我当时可能比较困 想了一会才想出来 19分钟的时候过掉了 C同样很显然 性质不难发现 我在30分钟的时候通过了pretest 但是由于自己的愚蠢 忘记写了一句话 导致FST了。。。 D本来是一个简单的dp题 但是我一直没往dp上想 在网络流上刚了1h之后终...
Codeforces Round #505 (rated, Div. 1 + Div. 2, based on VK Cup 2018 Final)
lajiyuan的博客
08-21 241
总结 这场靠着没掉题和其他人疯狂掉题上了分，但是难题还是开不出来，C写完之后等了大概20分钟才敢交，有点太谨慎了，D题如果不放弃思考一个半小时应该能想出n^3但是n^2实在太巧妙了，我的脑子真的想不到啊，在这里%一下010，我也要多补些稍微难点的，以后也能靠出难题上分呀！ A题 Doggo Recoloring 水题，考虑可以靠某个大于二的把所有都改变，注意只有一个颜色的时候，直接上代码。 ...
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
今天CF被D恶心到了，写个题解重新整理下思路，（20开始想，25写完暴力代码，1.30才过，优化后的。。 核心思路就是在暴力的基础上进行组合数等差加速。 C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m 我们发现内层...
题解 Codeforces Round #814 (Div. 1/2)
im_zyINF的博客
08-17 498
Codeforces
Codeforces Round #787 (Div. 3)个人题解
weixin_51767904的博客
05-06 1303
Codeforces Round #787 (Div. 3)个人题解 Codeforces Round #787 (Div. 3) A. Food for Animals B. Make It Increasing C. Detective Task D. Vertical Paths E. Replace With the Previous, Minimize F. Vlad and Unfinished Business G. Sorting Pancakes
Codeforces Round #505 (rated, Div. 1 + Div. 2）C
Y390d的博客
08-20 171
题目链接：http://codeforces.com/contest/1025/problem/C 题意： 题目有几点是没有说明的，第一：如果全部字符相等，答案输出 1（就一种颜色，，和题目的斑马色有点出入），第二：bw输出2； 题目的意思是，可以选择任意一个位置，也可以不切，如果切了的话，两个切开的部分都要反转一次，然后粘上；问所有子字符串中，字符两两不同的字符最多有几个； 思路： 应该...
Weakened Common Divisor - B题（分解质因数） Codeforces Round #505
我们花时间收集，却忘了最重要的其实是花时间去消化
08-20 258
思路： 求出第一组数据的质因数存入set中，然后对后面的数据，就是在这些质因数中筛选。可以边读入边筛选，也可以先存储在vector里面，再遍历处理。int就够了，我为了保险，用了long long. 这道题我在比赛时提交了30遍，都没有AC，赛后还改了好长时间，写代码不难，改代码(debug)才难，呜呜呜。 纤细过程看代码注释。 AC code: #include&amp;lt;bits/stdc...
Codeforces Round #505 C. Plasticine zebra(思维)
Charles_Zaqdt的博客
08-20 471
  题目链接：http://codeforces.com/contest/1025/problem/C        题意是输入一个只有'w','b'的字符串，可以对他的任意位置切割成两个子串，切割后的右边的子串翻转后再和左边的子串拼起来会得到一个新的字符串，操作次数不限，问能得到的字符串中wb交替出现的最大的长度是多少。        其实就是求这个字符串首尾相连成环后的wb交替的最大长度...
Codeforces Round #505 -D-Recovering BST（区间DP）
信仰.的博客
08-23 371
D. Recovering BST time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output Dima the hamster enjoys nibbling different things: cages, sticks...
Codeforces Round #505 D. Recovering BST 区间DP
布呗之路
08-27 278
/** 链接:https://codeforces.com/contest/1025/problem/D 题意:给出n个数 将这些数构造成一颗二叉树 问是否存在这样的二叉树使得树上任意相邻两点的gcd&gt;1; 分析:pre[i][j] 表示点i j是否能构成一条边 pre[i][j]=gcd(a[i],a[j])&gt;1; fl[i][j]:j向左扩展是否能连通i; fr[i][j]::i...
Codeforces Round #505 D. Recovering BST（区间DP）
weixin_30819163的博客
08-21 136
首先膜一发网上的题解。大佬们tql。 给你n个单调递增的数字，问是否能够把这些数字重新构成一棵二叉搜索树（BST），且所有的父亲结点和叶子结点之间的gcd > 1？ 这个题场上是想暴力试试的。结果不行。发现符合最优子结构，可以DP。但是想不出来怎么转移。 看了大佬的题解。 若以第 k 个结点为根节点，用 L[i][k] 表示是否能够向左延伸到 i 点，R[k][...
Codeforces Round #505 D Recovering BST(cf 1025D)
iwi
08-20 931
题目：Recovering BST 题意：给出n个升序排列的数，求是否能用这n个数组成一颗二叉排序树。 思路： 考场上——看标题，BST！看了题面后，我zz的想，这不就是裸的图论题么…然后就一顿敲，交上去一遍AC，心里美滋滋。结果正式测评就在51个点WA了。 其实正解是dp。 令L[i][j]表示以i为根，i的左子树为i的左边j个数 这样的bst是否存在。 同理R[i][j]表示以i为...
【区间DP && bitset && 内存】Codeforces Round #505 D. Recovering BST
ACMer 梁剑锋 的博客
08-20 231
Step1 Problem: 给你 n 个点，升序给出 n 个点的权值，让你判断是否能构成一棵排序树：两个节点权值的 gcd 不等于 1 才能够连边。 数据范围： 2 &amp;lt;= n &amp;lt;= 700, 2 &amp;lt;= a[i] &amp;lt;= 1e9. Step2 Ideas: 扩充知识：通常情况下，1字节 = 8位. C++ 里面 int 占 4字节，char 占...
codeforces505B （思维）
bpdwn2017的博客
08-20 302
（a1,b2） (a2, b2)....这样的数对有n对，问是否存在一个数，使得这个数是每个数对中至少一个数的因子。   我一开始贪心被hack了。。后来又想枚举一个数的所有因子，a[i]太大了放弃。。比赛结束后看别人代码才知道只需要枚举质因子就行了。。而int内的数的质因子不超过十个。。 #include &lt;cstdio&gt; #include &lt;cstring&gt; #...
Codeforces Round 260 (Div. 1)
最新发布
01-12
### Codeforces Round 260 Div. 1 题目及题解 #### A. Vasya and Multisets 在这道题目中，Vasya有一个由n个整数组成的序列。目标是通过将这些数分成若干组，使得每组中的所有数都相同，并且尽可能减少分组的数量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值