Codeforces Round #697 (Div. 3) 1/25

最新推荐文章于 2022-12-22 14:57:57 发布

朝阳学长

最新推荐文章于 2022-12-22 14:57:57 发布

阅读量66

点赞数

分类专栏： Codeforces题解

本文链接：https://blog.csdn.net/sunrise_129075/article/details/113460002

版权

Codeforces题解专栏收录该内容

16 篇文章 0 订阅

订阅专栏

本文介绍了多项算法竞赛中的解题策略，包括数论、贪心、动态规划等方法的应用。针对不同的题目类型，如判断奇数因子、序列构成、情侣配对、背包问题和序列最大子序列等，提供了高效的解决方案。通过二分图、二分查找、异或运算等技术，确保在限制时间内找到最优解。

摘要由CSDN通过智能技术生成

比赛链接

T1

给你一个n，判断n是不是可以被除了1以外的奇数整除。可以输出YES，否则输出NO。
$2\leq n\leq10^{14}$

依次除2，判断是否存在奇因子即可。

void solve() {
	n = read();
	do {
		if (n & 1) {
			puts("YES");
			return;
		}
		n = n >> 1;
	} while (n != 1);
	puts("NO");
}

T2

给出整数n，判断n是不是可以只由2020和2021相加得到。 $1\leq n\leq10^6$

计算最多可以添加几个2020使得和最接近n这里看成是有x个盘子，再看还差多少，能不能用1把盘子补齐差的元素即可。

void solve() {
	n = read();
	int cnt = 0;
	while (n >= 2020) { // 直接除也行
		++cnt;
		n -= 2020;
	}
	if (cnt >= n)	puts("YES");
	else puts("NO");
}

T3

T组输入，每组输入告诉有n个男生，m个女生，k对关系。并且下面第一行给出第i个男生喜欢那个女生。第二行给出第i个女生喜欢那个男生。现在要你从这些关系中找出两对合法的情侣去参加舞会。问你有几种安排方案。
$T\leq10^4,n,m,k\leq2*10^5$ 。

二分图问题，把男生放在一边，女生放在另外一边，并且只有男女之间才存在边，那么我们使用一个cnt1数组记录每个男生有几个女生喜欢，cnt2数组记录每个女生有几个男生喜欢。那么我们就可以枚举每一对关系了，如果我们选择了第i对关系，那么它对答案的贡献就是 $k - c n t 1 [u] - c n t 2 [v] + 1$ 。假设u代表男生，v代表女生。这样运算之后就是选择这对关系之后还合法的全部关系数，依次累加最终还要除以2，因为重复计算了一遍。

const int N = 2e5 + 7;
 
struct Node {
	int u, v;
}edge[N];
int cnt[2][N];
 
void solve() {
	ms(cnt, 0);
	int a = read(), b = read(), k = read();
	rep(i, 1, k) {
		edge[i].u = read();
		++cnt[0][edge[i].u];
	}
	rep(i, 1, k) {
		edge[i].v = read();
		++cnt[1][edge[i].v];
	}
	ll ans = 0;
	rep(i, 1, k)
		ans += k - cnt[0][edge[i].u] - cnt[1][edge[i].v] + 1;
	print(ans >> 1);
}

T4

给出n件物品，每件物品有对应的花费w和价值p，再给出现在要求价值数m。问你购买下价值总和大于等于m的最小花费是多少，如果不存在输出-1。
$n\leq2*10^5,1\leq m,w\leq10^9,1\leq p\leq2$ 。

仔细读题，每间物品价值p的取值只有1和2两种，那么就可以使用二分处理了。我们把物品排个序，p=1放在2的前面，相同p的按照w大的放在前面，枚举当前我们选取1的物品数量，二分求解我们最少还需要多少件2才可以大于等于m。-1的输出条件是全部买下都小于m。

const int N = 2e5 + 7;
 
ll n, m;
struct Node {
	int x, y;
	bool operator < (const Node& opt) const {
		return y<opt.y or y == opt.y and x>opt.x;
	}
}p[N];
ll sum[N];
 
void solve() {
	n = read(), m = read();
	rep(i, 1, n)	p[i].x = read();
	rep(i, 1, n)	p[i].y = read();
	sort(p + 1, p + 1 + n);
	int pos = 0;
	ms(sum, 0);
	rep(i, 1, n) {
		if (p[i].y == 1)	pos = i;
		sum[i] = sum[i - 1] + p[i].x;
	}
	if (sum[n] < m) { print(-1); return; }
	int ans = INF;
	rep(i, 0, pos) {
		int l = pos, r = n, tmp = -1;
		while (l <= r) {
			int mid = l + r >> 1;
			if (sum[i] + sum[mid] - sum[pos] >= m)
				tmp = mid, r = mid - 1;
			else
				l = mid + 1;
		}
		if (~tmp)	ans = min(ans, i + (tmp - pos) * 2);
	}
	print(ans);
}

T5

给出长度为n的序列，假设长度为m的最大子序列=mx，问你mx有多少种取法。取法之间有一个下标不同就算一种新的取法。答案对 $10^9+7$ 取模。
$n\leq 1000，a_i\leq n$ 。

首先，我们既然要找的是最大子序列，那么最大的元素一定不能跳过，如果有多个最大的元素那么我们就要尽可能都选上，那么我可以做决策的也就是最后一次选取元素了。具体做法就是使用桶对每个数的出现进行计数，如果当前数的出现次数已经小于m了，说明这些数我一定要取完，那么对答案贡献只能是1，如果已经选取的数和+选择选取出现次数大于等于m，说明我要从 $cnt[a_i]$ 中取剩下的那么多个，直接组合数处理即可。

const int N = 1000 + 7;
 
ll n, m;
ll a[N], jc[N], inv[N];
 
void init() {
	jc[0] = 1;
	rep(i, 1, 1000)	jc[i] = jc[i - 1] * i % MOD;
	inv[1000] = qpow(jc[1000], MOD - 2, MOD);
	repp(i, 999, 0)
		inv[i] = inv[i + 1] * (i + 1) % MOD;
}
 
int C(int n, int m) {
	return jc[n] * inv[n - m] % MOD * inv[m] % MOD;
}
 
void solve() {
	n = read(), m = read();
	ms(a, 0);
	rep(i, 1, n) {
		int x = read();
		++a[x];
	}
	repp(i, n, 1) {
		if (a[i] >= m) {
			ll ans = C(a[i], m);
			print(ans);
			return;
		}
		else m -= a[i];
	}
}
 
int main() {
	init();
	int T = read();	while (T--)
		solve();
	return 0;
}

T6

给你一个 $n * n$ 的起始01矩阵S，你可以选取某一行或者某一列做任意次和1的异或运算，问能否变成矩阵T。
$n\leq 1000$ 。

根据异或的性质，我们可以知道异或的先后没有关系，并且异或两次之后相当于没变，那么如果要让第一行对齐T矩阵，要么就是行异或0次和1次，首先使得第一行不变，如果 $s [1] [j]! = t [1] [j]$ ，说明要做一次列异或，把它对齐，先把第一行处理完之后，再去检查下面行是不是对齐了，如果还有没对齐的情况，那么我们可以把第一行做一次行异或，全部翻转一遍重新做上方操作，如果两次都不行，说明达不到T矩阵。

const int N = 1000 + 7;
 
ll n, m;
char s[N];
 
bool check(vector<vector<int>> a, vector<vector<int>> b) {
	rep(i, 1, n) {
		if (a[1][i] != b[1][i]) {
			rep(j, 1, n)	a[j][i] ^= 1;
		}
	}
	rep(i, 1, n) {
		int now = a[i][1] ^ b[i][1];
		rep(j, 2, n) {
			if (now != (a[i][j] ^ b[i][j]))
				return false;
		}
	}
	return true;
}
 
void solve() {
	n = read();
	vector<vector<int>> mp1(n + 1, vector<int>(n + 1));
	vector<vector<int>> mp2(n + 1, vector<int>(n + 1));
	rep(i, 1, n) {
		scanf("%s", s + 1);
		rep(j, 1, n)	mp1[i][j] = s[j] - '0';
	}
	rep(i, 1, n) {
		scanf("%s", s + 1);
		rep(j, 1, n)	mp2[i][j] = s[j] - '0';
	}
	rep(i, 1, 2) {
		if (check(mp1, mp2)) {
			puts("YES");
			return;
		}
		rep(i, 1, n)	mp1[1][i] ^= 1;
	}
	puts("NO");
}

T7

给出长度为n的数组，并且好数组的定义是数组中每一个位置都可以被除它以外的元素整除或者整除其他元素。就是 $a_i=k*a_j$ 或者 $k*a_i=a_j\ \ \ \ \ i！=j$ 。
问你最少需要从原数组删除几个元素可以使得原数组变成一个好数组。
$n\leq2*10^5,a_i\leq2*10^5$ 。

如果我们开一个桶对数组进行计数的话，再把原数组进行从小到大排序，使用 $d p [i]$ 代表最大值是i的好数组最大长度。那么转移方程就是
$dp[i]=\max\limits_{i\%k==0}(dp[k])+cnt[i]$
那么只要把每一个数的因子处理一下就行了，时间复杂度 $O (n * l n (n) + n * l o g (n))$ ，求因子加排序。

const int N = 2e5 + 7;

int n, m, a[N];
int cnt[N], dp[N]; // dp[i] 代表 i 是好数组最大值的最大容量
bool vis[N];
vector<int> p[N];

void solve() {
	n = read(), m = 0;
	rep(i, 1, n) {
		a[i] = read();
		++cnt[a[i]];
		m = max(m, a[i]);
	}
	rep(i, 1, m) // O(nln(n))
		for (int j = 2 * i; j <= m; j += i)	p[j].push_back(i);
	int ans = INF;
	sort(a + 1, a + 1 + n);
	rep(i, 1, n) {
		if (vis[a[i]])	continue;
		dp[a[i]] = cnt[a[i]];
		for (auto& it : p[a[i]])
			dp[a[i]] = max(dp[a[i]], dp[it] + cnt[a[i]]);
		ans = min(ans, n - dp[a[i]]);
		vis[a[i]] = 1;
	}
	print(ans);
	rep(i, 1, m) {
		cnt[i] = vis[i] = dp[i] = 0;
		p[i].clear();
	}
}