【AtCoder】AtCoder Regular Contest 098 题解

最新推荐文章于 2020-11-22 13:18:54 发布

cz_xuyixuan

最新推荐文章于 2020-11-22 13:18:54 发布

阅读量506

点赞数

分类专栏：【OJ】AtCoder 【类型】做题记录【比赛】AtCoder 【算法】差分与前缀和思想【算法】倍增与二分【算法】贪心【数据结构】树状数组【数据结构】平衡树【算法】动态规划

本文链接：https://blog.csdn.net/qq_39972971/article/details/80621828

版权

【类型】做题记录同时被 3 个专栏收录

767 篇文章 2 订阅

订阅专栏

【算法】动态规划

239 篇文章 6 订阅

订阅专栏

【算法】倍增与二分

80 篇文章 0 订阅

订阅专栏

【比赛链接】

点击打开链接

【题解链接】

点击打开链接

【C】Attention

【思路要点】

用前/后缀和分别统计头领在每个位置时前后需要转向的人数。
时间复杂度\(O(N)\)。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 300005;
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 l[MAXN], r[MAXN];
int main() {
	int n; read(n);
	scanf("%s", s + 1);
	for (int i = 2; i <= n; i++)
		l[i] = l[i - 1] + (s[i - 1] == 'W');
	for (int i = n - 1; i >= 1; i--)
		r[i] = r[i + 1] + (s[i + 1] == 'E');
	int ans = n;
	for (int i = 1; i <= n; i++)
		chkmin(ans, l[i] + r[i]);
	writeln(ans);
	return 0;
}

【D】Xor Sum 2

【思路要点】

注意到\(a\ xor\ b≤a+b\)，因此对于每一个左端点，满足条件的右端点一定是一个区间。
预处理原数组的前缀和/前缀异或和，对于每个左端点二分出其满足条件的最靠右的右端点。
时间复杂度\(O(NLogN)\)。

【代码】

#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("");
}
int x[MAXN], sor[MAXN];
long long sum[MAXN];
int main() {
	int n; read(n);
	for (int i = 1; i <= n; i++) {
		read(x[i]);
		sum[i] = sum[i - 1] + x[i];
		sor[i] = sor[i - 1] ^ x[i];
	}
	long long ans = 0;
	for (int i = 1; i <= n; i++) {
		int l = i, r = n;
		while (l < r) {
			int mid = (l + r + 1) / 2;
			if ((sum[mid] - sum[i - 1]) == (sor[mid] ^ sor[i - 1])) l = mid;
			else r = mid - 1;
		}
		ans += l - i + 1;
	}
	writeln(ans);
	return 0;
}

【E】Range Minimum Queries

【思路要点】

假设我们已经确定了要删除的数的集合。
我们发现若存在合法的删除方式，也一定存在一种删除方式使得集合中的数被从小到大删除。
因此我们可以不失一般性地认为被删除的数是按照大小升序排列的。
枚举被删除的最小的数，那么小于它的数均已不能够出现在选取的区间内，我们不妨视为它们将序列截断了。
从小到大扫描大于等于该数的位置，若该位置能够被删除，则删除之，否则将其视为一个新的截断点。
实现时需要用一个平衡树（std::set）来维护截断点的位置以及截断点之间剩余数的个数。
时间复杂度\(O(N^2LogN)\)。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2005;
const int INF = 2e9;
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 BinaryIndexTree {
	int a[MAXN], n;
	void init(int x) {
		n = x;
		memset(a, 0, sizeof(a));
	}
	void modify(int pos, int d) {
		for (int i = pos; i <= n; i += i & -i)
			a[i] += d;
	}
	int query(int l, int r) {
		int ans = 0;
		for (int i = r; i >= 1; i -= i & -i)
			ans += a[i];
		for (int i = l - 1; i >= 1; i -= i & -i)
			ans -= a[i];
		return ans;
	}
} BIT; 
struct info {int val, home; } a[MAXN];
bool cmp(info a, info b) {
	return a.val < b.val;
}
int main() {
	int n, k, q;
	read(n), read(k), read(q);
	for (int i = 1; i <= n; i++) {
		int x; read(x);
		a[i] = (info) {x, i};
	}
	sort(a + 1, a + n + 1, cmp);
	int ans = INF;
	for (int i = 1; i <= n; i++) {
		BIT.init(n);
		static set <int> st;
		st.clear(); st.insert(0), st.insert(n + 1);
		for (int j = 1; j <= i - 1; j++)
			st.insert(a[j].home);
		BIT.init(n + 1);
		for (int j = i; j <= n; j++)
			BIT.modify(a[j].home, 1);
		int rit = INF, req = q;
		for (int j = i; j <= n; j++) {
			set <int> :: iterator tmp = st.lower_bound(a[j].home);
			int r = *tmp; tmp--; int l = *tmp;
			if (BIT.query(l, r) >= k) {
				if (--req == 0) {
					rit = a[j].val;
					break;
				}
			} else st.insert(a[j].home);
			BIT.modify(a[j].home, -1);
		}
		if (req != 0) break;
		chkmin(ans, rit - a[i].val);
	}
	writeln(ans);
	return 0;
}

【F】Donation

【思路要点】

若我们经过了一个点多次，那么我们不必在最后一次经过该点之前对其进行捐献，而可以等到最后一次经过它时再进行捐献。
因此，令\(C_i=max\{A_i-B_i,0\}\)，如果我们默认只有最后一次经过一个点时才会对其进行捐献，对\(A_i\)的限制可以等价地表示为在任何时刻，一个处于\(i\)点的人必须持有\(C_i\)单位的货币。
考虑\(C_x\)最大的点\(x\)，对\(x\)进行捐献后，我们将不再经过\(x\)，也就是说，我们会进入删去\(x\)所分割出的一个连通分量中，不再出来，不妨设该连通分量为\(G\)。
我们发现，在对\(x\)进行捐献之前对\(G\)内部的点进行的捐献可以推迟到对\(x\)进行捐献之后，因此我们不失一般性地认为我们只会先对删去\(x\)所分割出的其他连通分量捐献，然后对\(x\)捐献，最后对\(G\)捐献。
我们建出如下树形结构：将当前连通分量内\(C_i\)最大的点作为根，并将其在原图中删去，对于新产生的各个连通分量分别建树，将它们的根部连向当前联通分量的根部。
这棵树可以通过按\(C_i\)从小到大考虑所有的点在\(O(NLogN)\)的时间内构建出来。
然后记\(dp_i\)表示完成对当前连通分量的捐献需要具有的最少资金数，\(sum_i\)表示完成对当前连通分量的捐献将会花费的最少资金数，简单树形DP即可。
时间复杂度\(O(NLogN)\)。

【代码】

#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, m, root, a[MAXN], b[MAXN], f[MAXN], pos[MAXN], fa[MAXN];
vector <int> e[MAXN], t[MAXN];
long long dp[MAXN], sum[MAXN];
void work(int pos) {
	if (t[pos].size() == 0) {
		dp[pos] = a[pos] + b[pos];
		sum[pos] = b[pos];
		return;
	}
	sum[pos] = b[pos];
	for (unsigned i = 0; i < t[pos].size(); i++) {
		work(t[pos][i]);
		sum[pos] += sum[t[pos][i]];
	}
	dp[pos] = 1e18;
	for (unsigned i = 0; i < t[pos].size(); i++)
		chkmin(dp[pos], max(dp[t[pos][i]], 1ll * a[pos]) + sum[pos] - sum[t[pos][i]]);
}
bool cmp(int x, int y) {
	return a[x] < a[y];
}
int F(int x) {
	if (f[x] == x) return x;
	else return f[x] = F(f[x]);
}
int main() {
	read(n), read(m);
	for (int i = 1; i <= n; i++) {
		read(a[i]), read(b[i]);
		a[i] = max(a[i] - b[i], 0);
		pos[i] = i;
	}
	sort(pos + 1, pos + n + 1, cmp);
	for (int i = 1; i <= m; i++) {
		int x, y;
		read(x), read(y);
		e[x].push_back(y);
		e[y].push_back(x);
	}
	memset(fa, -1, sizeof(fa));
	for (int i = 1; i <= n; i++) {
		int tmp = pos[i];
		f[tmp] = tmp;
		for (unsigned j = 0; j < e[tmp].size(); j++)
			if (fa[F(e[tmp][j])] == 0) fa[F(e[tmp][j])] = tmp, f[F(e[tmp][j])] = tmp;
		fa[tmp] = 0;
	}
	for (int i = 1; i <= n; i++)
		if (fa[i]) t[fa[i]].push_back(i);
		else root = i;
	work(root);
	writeln(dp[root]);
	return 0;
}

cz_xuyixuan

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【AtCoder】AtCoder Regular Contest 098 题解

【比赛链接】点击打开链接【题解链接】点击打开链接【C】Attention【思路要点】用前/后缀和分别统计头领在每个位置时前后需要转向的人数。时间复杂度\(O(N)\)。【代码】#include&lt;bits/stdc++.h&gt;using namespace std;const int MAXN = 300005;template &lt;typename T&gt; void chk...
复制链接

扫一扫

专栏目录