Codeforces Round #310 (Div. 1) 完整题解

最新推荐文章于 2024-05-21 20:22:55 发布
最新推荐文章于 2024-05-21 20:22:55 发布
阅读量683 收藏
点赞数
分类专栏： Codeforces 文章标签： codeforces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blankcqk/article/details/46682997
版权

A题：看懂题意后，只要找到从1开始连续的长度就行了，其他的套娃都要全拆开。

#include <iostream>
#include <queue> 
#include <stack> 
#include <map> 
#include <set> 
#include <bitset> 
#include <cstdio> 
#include <algorithm> 
#include <cstring> 
#include <climits>
#include <cstdlib>
#include <cmath>
#include <time.h>
#define maxn 100005
#define maxm 2000005
#define eps 1e-7
#define mod 1000000007
#define INF 0x3f3f3f3f
#define PI (acos(-1.0))
#define lowbit(x) (x&(-x))
#define mp make_pair
#define ls o<<1
#define rs o<<1 | 1
#define lson o<<1, L, mid 
#define rson o<<1 | 1, mid+1, R
#define pii pair<int, int>
#pragma comment(linker, "/STACK:16777216")
typedef long long LL;
typedef unsigned long long ULL;
//typedef int LL;
using namespace std;
LL qpow(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base;base=base*base;b/=2;}return res;}
LL powmod(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base%mod;base=base*base%mod;b/=2;}return res;}
// head

int a[maxn];
int n, m;

void work()
{
	int k, t2 = 0;
	int ans = 0, t = 1;
	for(int i = 1; i <= m; i++) {
		scanf("%d", &k);
		for(int j = 1; j <= k; j++) scanf("%d", &a[j]);
		if(a[1] == 1) {
			for(int j = 2; j <= k; j++) {
				if(a[j] == a[j-1] + 1) t++;
				else {
					t2 = 1;
					break;
				}
			}
		}
	}
	ans = (n - t) - (m - 1) + (n - t);

	printf("%d\n", ans);
}

int main()
{
	while(scanf("%d%d", &n, &m)!=EOF) {
		work();
	}
	
	
	return 0;
<span style="font-size:24px;">}</span>

B题：贪心，先预处理出n-1条桥的长度，设每条桥的区间为[l,r]，那么可以证明找到比l大的且长度最小的桥是最优的。证明如下：1.设第l[i] > l[i+1] r[i] < r[i+1]，那么先满足第i个桥的条件必然是最优的。2.l[i] < l[i+1]  r[i] < r[i+1]，画个图就知道找比l[i]大的最小值也是最优的。 

#include <iostream>
#include <queue> 
#include <stack> 
#include <map> 
#include <set> 
#include <bitset> 
#include <cstdio> 
#include <algorithm> 
#include <cstring> 
#include <climits>
#include <cstdlib>
#include <cmath>
#include <time.h>
#define maxn 200005
#define maxm 2000005
#define eps 1e-7
#define mod 1000000007
#define INF 0x3f3f3f3f
#define PI (acos(-1.0))
#define lowbit(x) (x&(-x))
#define mp make_pair
#define ls o<<1
#define rs o<<1 | 1
#define lson o<<1, L, mid 
#define rson o<<1 | 1, mid+1, R
#define pii pair<int, int>
#pragma comment(linker, "/STACK:16777216")
typedef long long LL;
typedef unsigned long long ULL;
//typedef int LL;
using namespace std;
LL qpow(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base;base=base*base;b/=2;}return res;}
LL powmod(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base%mod;base=base*base%mod;b/=2;}return res;}
// head

struct node
{
	LL l, r;
	int id;
}p[maxn];

set<pair<LL, int> > s;
set<pair<LL, int> >::iterator it;
LL l[maxn];
LL r[maxn];
int ans[maxn];
int n, m;

int cmp(node a, node b)
{
	if(a.r == b.r) return a.l > b.l;
	return a.r < b.r;
}

void work()
{
	LL x;
	for(int i = 1; i <= n; i++) scanf("%I64d%I64d", &l[i], &r[i]);
	for(int i = 1; i <= m; i++) {
		scanf("%I64d", &x);
		s.insert(mp(x, i));
	}
	for(int i = 1; i < n; i++) {
		p[i].l = l[i+1] - r[i];
		p[i].r = r[i+1] - l[i];
		p[i].id = i;
	}
	
	int ok = 1;
	sort(p+1, p+n, cmp);
	for(int i = 1; i < n; i++) {
		it = s.lower_bound(mp(p[i].l, 0));
		if(it == s.end()) {
			ok = 0;
			break;
		}
		if(it->first > p[i].r) {
			ok = 0;
			break;
		}
		ans[p[i].id] = it->second;
		s.erase(it);
	}
	if(!ok) printf("No\n");
	else {
		printf("Yes\n");
		for(int i = 1; i < n; i++) printf("%d%c", ans[i], i == n - 1 ? '\n' : ' ');
	}

}

int main()
{
	while(scanf("%d%d", &n, &m)!=EOF) {
		work();
	}
	
	return 0;
}

C题：线段树可以做，当然用set做也是可以的，U就找x比他大的， L就找x比他小的。 

#include <iostream>
#include <queue> 
#include <stack> 
#include <map> 
#include <set> 
#include <bitset> 
#include <cstdio> 
#include <algorithm> 
#include <cstring> 
#include <climits>
#include <cstdlib>
#include <cmath>
#include <time.h>
#define maxn 200005
#define maxm 2000005
#define eps 1e-7
#define mod 1000000007
#define INF 0x3f3f3f3f
#define PI (acos(-1.0))
#define lowbit(x) (x&(-x))
#define mp make_pair
#define ls o<<1
#define rs o<<1 | 1
#define lson o<<1, L, mid 
#define rson o<<1 | 1, mid+1, R
#define pii pair<int, int>
#pragma comment(linker, "/STACK:16777216")
typedef long long LL;
typedef unsigned long long ULL;
//typedef int LL;
using namespace std;
LL qpow(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base;base=base*base;b/=2;}return res;}
LL powmod(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base%mod;base=base*base%mod;b/=2;}return res;}
// head

set<pii> s;
set<pii>::iterator it;
int x[maxn];
int y[maxn];
char ss[maxn];
int n, m;

void work()
{
	x[0] = y[0] = 0;
	s.insert(mp(0, m+1));
	s.insert(mp(n+1, m+1));
	for(int i = 1; i <= m; i++) {
		scanf("%d%d%s", &x[i], &y[i], ss);
		if(ss[0] == 'U') it = s.lower_bound(mp(x[i], -1));
		else {
			it = s.upper_bound(mp(x[i], m+1));
			it--;
		}
		if(it->first == x[i]) {
			printf("0\n");
			continue;
		}
		s.insert(mp(x[i], i));
		if(ss[0] == 'U') {
			printf("%d\n", y[i] - y[it->second]);
			y[i] = y[it->second];
		}
		else {
			printf("%d\n", x[i] - x[it->second]);
			x[i] = x[it->second];
		}
	}
}

int main()
{
	while(scanf("%d%d", &n, &m)!=EOF) {
		work();
	}
	
	
	return 0;
}

D题：不是很难的数学题，但是情况有很多。基本思想就是每次找出剩下的线能到达的最远的点，然后每次这样做。找用二分查找，碰到有循环就就取模。 

#include <iostream>
#include <queue> 
#include <stack> 
#include <map> 
#include <set> 
#include <bitset> 
#include <cstdio> 
#include <algorithm> 
#include <cstring> 
#include <climits>
#include <cstdlib>
#include <cmath>
#include <time.h>
#define maxn 200005
#define maxm 2000005
#define eps 1e-7
#define mod 1000000007
#define INF 0x3f3f3f3f
#define PI (acos(-1.0))
#define lowbit(x) (x&(-x))
#define mp make_pair
#define ls o<<1
#define rs o<<1 | 1
#define lson o<<1, L, mid 
#define rson o<<1 | 1, mid+1, R
#define pii pair<int, int>
#pragma comment(linker, "/STACK:16777216")
typedef long long LL;
typedef unsigned long long ULL;
//typedef int LL;
using namespace std;
LL qpow(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base;base=base*base;b/=2;}return res;}
LL powmod(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base%mod;base=base*base%mod;b/=2;}return res;}
// head

map<int, int> mpp;
pii b[maxn];
int a[maxn];
int n, m;

void calc(int pos, int x, int dir)
{
	if(dir == 0 && a[pos] + x < a[pos+1]) {
		printf("%d\n", b[pos].second);
		return;
	}
	if(dir == 1 && a[pos] - x > a[pos-1]) {
		printf("%d\n", b[pos].second);
		return;
	}
	if(dir == 0) {
		int t, nxt;
		if(a[pos] + x >= a[n]) {
			t = a[n] - a[pos];
			nxt = n;
		}
		else {
			nxt = upper_bound(a+1, a+n+1, a[pos]+x) - a - 1;
			t = a[nxt] - a[pos];
		}
		int tt = x / t;
		if(tt % 2 == 0) calc(pos, x - tt * t, 0);
		else calc(nxt, x - tt * t, 1);
	}
	else {
		int t, nxt;
		if(a[pos] - x <= a[1]) {
			t = a[pos] - a[1];
			nxt = 1;
		}
		else {
			nxt = lower_bound(a+1, a+n+1, a[pos]-x) - a;
			t = a[pos] - a[nxt];
		}
		int tt = x / t;
		if(tt % 2 == 0) calc(pos, x - tt * t, 1);
		else calc(nxt, x - tt * t, 0);
	}
}

void work()
{
	int t, x;
	for(int i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = mp(a[i], i);
	sort(b+1, b+n+1);
	sort(a+1, a+n+1);
	for(int i = 1; i <= n; i++) mpp[b[i].second] = i;
	while(m--) {
		scanf("%d%d", &t, &x);
		t = mpp[t];
		if(n == 1) {
			printf("1\n");
			continue;
		}
		if(a[t] + x >= a[n]) calc(n, x - (a[n] - a[t]), 1);
		else {
			int nxt = upper_bound(a+1, a+n+1, a[t]+x) - a - 1;
			if(nxt == t && nxt == 1) {
				printf("%d\n", b[1].second);
				continue;
			}
			t = a[nxt] - a[t];
			calc(nxt, x - t, 1);
		}
	}
}

int main()
{
	while(scanf("%d%d", &n, &m)!=EOF) {
		work();
	}


	return 0;
}

E题：先用边双连通缩点，因为对于一个边双连通分量，改变其中的边的方向，一定能把这个双连通变成强连通分量。那么一个边双连通对于这个题就完全符合了。因此我们缩点。缩点以后对于每一个连通块都是一颗树，先预处理出各个树的lca。对于每个s，t，s到t的边的方向一定是确定的。也就是说树上每一个点走出去的方向是确定的。用up，down记录方向，每个询问用标记法处理。最后对于每个树dfs，如果有一个点up和down都有值，那么这是不合法的。 

#include <iostream>
#include <queue> 
#include <stack> 
#include <map> 
#include <set> 
#include <bitset> 
#include <cstdio> 
#include <algorithm> 
#include <cstring> 
#include <climits>
#include <cstdlib>
#include <cmath>
#include <time.h>
#define maxn 200005
#define maxm 400005
#define eps 1e-7
#define mod 1000000007
#define INF 0x3f3f3f3f
#define PI (acos(-1.0))
#define lowbit(x) (x&(-x))
#define mp make_pair
#define ls o<<1
#define rs o<<1 | 1
#define lson o<<1, L, mid 
#define rson o<<1 | 1, mid+1, R
#define pii pair<int, int>
#pragma comment(linker, "/STACK:16777216")
typedef long long LL;
typedef unsigned long long ULL;
//typedef int LL;
using namespace std;
LL qpow(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base;base=base*base;b/=2;}return res;}
LL powmod(LL a, LL b){LL res=1,base=a;while(b){if(b%2)res=res*base%mod;base=base*base%mod;b/=2;}return res;}
// head

struct Edge
{
	int v, next;
	Edge(int v = 0, int next = 0) : v(v), next(next) {} 
}E[maxm << 1];

const int M = 20;

stack<int> s;
pii tpair[maxn];
int H[maxn], cntE, h[maxn];
bool used[maxn];
int bcc[maxn];
int block[maxn];
int dep[maxn];
int dfn[maxn];
int vis[maxn];
int low[maxn];
int anc[maxn][M];
int up[maxn];
int down[maxn];
int n, m, q, ok, dfs_clock, T, bcc_cnt;

void addedges(int u, int v, int *HH)
{
	E[cntE] = Edge(v, HH[u]);
	HH[u] = cntE++;
}

void init()
{
	T = 0;
	dfs_clock = cntE = bcc_cnt = 0;
	memset(H, -1, sizeof H);
	memset(h, -1, sizeof h);
	memset(vis, 0, sizeof vis);
	memset(dfn, 0, sizeof dfn);
	memset(used, 0, sizeof used);
}

void tarjan(int u)
{
	dfn[u] = low[u] = ++dfs_clock;
	s.push(u), block[u] = T;
	for(int e = H[u]; ~e; e = E[e].next) if(!used[e / 2]) {
		used[e / 2] =true;
		int v = E[e].v;
		if(!dfn[v]) {
			tarjan(v);
			low[u] = min(low[u], low[v]);
		}
		else low[u] = min(low[u], dfn[v]);
	}
	if(low[u] == dfn[u]) {
		int t;
		bcc_cnt++;
		do {
			t = s.top();
			bcc[t] = bcc_cnt;
			s.pop();
		}while(t != u);
	}
}

void dfs(int u, int fa)
{
	vis[u] = true;
	anc[u][0] = fa;
	for(int e = h[u]; ~e; e = E[e].next) {
		int v = E[e].v;
		if(vis[v]) continue;
		dep[v] = dep[u] + 1;
		dfs(v, u);
	}
}

void DFS(int u)
{
	vis[u] = true;
	for(int e = h[u]; ~e; e = E[e].next) {
		int v = E[e].v;
		if(vis[v]) continue;
		DFS(v);
		up[u] += up[v];
		down[u] += down[v];
	}
	if(up[u] && down[u]) ok = 0;
}

int to(int u, int d)
{
	for(int i = M - 1; i >= 0; i--) if(dep[anc[u][i]] >= d) u = anc[u][i];
	return u;
}

int lca(int u, int v)
{
	if(dep[u] < dep[v]) swap(u, v);
	u = to(u, dep[v]);
	for(int i = M - 1; i >= 0; i--) if(anc[u][i] != anc[v][i]) u = anc[u][i], v = anc[v][i];
	return u == v ? u : anc[u][0];
}

void work()
{
	int u, v;
	for(int i = 1; i <= m; i++) {
		scanf("%d%d", &u, &v);
		tpair[i] = mp(u, v);
		addedges(u, v, H);
		addedges(v, u, H); 
	}
	for(int i = 1; i <= n; i++) if(!dfn[i]) {
		T++;
		tarjan(i);
	}

	for(int i = 1; i <= m; i++) {
		u = bcc[tpair[i].first];
		v = bcc[tpair[i].second];
		if(u == v) continue;
		addedges(u, v, h);
		addedges(v, u, h);
	}
	
	for(int i = 1; i <= bcc_cnt; i++) if(!vis[i]) dfs(i, i);
	for(int i = 1; i < M; i++)
		for(int j = 1; j <= n; j++)
			anc[j][i] = anc[anc[j][i-1]][i-1];
	ok = 1;
	for(int i = 1; i <= q; i++) {
		scanf("%d%d", &u, &v);
		if(block[u] != block[v]) ok = 0;
		u = bcc[u];
		v = bcc[v];
		int c = lca(u, v);
		up[u]++;
		up[c]--;
		down[v]++;
		down[c]--;
	}
	memset(vis, 0, sizeof vis);
	for(int i = 1; i <= bcc_cnt; i++) if(!vis[i]) DFS(i);
	printf("%s\n", ok ? "Yes" : "No");
}

int main()
{
	while(scanf("%d%d%d", &n, &m, &q)!=EOF) {
		init();
		work();
	}
	
	return 0;
}



yysys
关注
专栏目录
Codeforces Round 969 (Div. 1) 题解
nike0good |Oier&ACMer | 熟能生巧
08-31 1499
题意：给定一棵树，点权为0或1。定义一个叶子的权值为：考虑从根到叶子的这条路径的点权组成的字符 串，权值为其中01作为连续子串出现次数减去10作为连续子串出现次数。定义树的价值为：权值非零 的叶子个数（不包括root节点1）。现在一些点权变成 ？，博弈的两人分别填充，先手最大化，后手最小化树的价值。求最终树的价值。 解法：一条路径计入答案当且仅当叶子和根权值不同。所以只和根和叶子的权值有关。若根的权值确 定，则策略显然；若根的权值不确定，一个思路是看叶子节点填过的0和1哪个多，按自己的目标填；实 际上当叶子
Codeforces Round #839 (Div. 3)题解
Kicamon的博客
12-19 1245
我们可以将数分为三类，一类是只有先手想要染的（数量为a），第二类是只有后手想要染的（数量为b），第三类是两者都要染的（数量为c）。上述例子中，后手想要赢的话，只要将3、4、5都染成蓝色， 那么他就可以将这三个数从新排布得到降序的数组；而先手想要赢的话，就要将所有的都染成蓝色， 所以后手赢。这题的题意有点含糊，其大意是，两个操作，将一个红色染成蓝色， 或者将蓝色的位置之间任意排序。我是撒比，这题开始用二分答案来写，卡了一个半小时。此时可以选择3或者5将其染成蓝色，这里不做演示。，不足的在从大到小标记。
Codeforces Round 946 (Div. 3)题解
最新发布
2301_80475191的博客
05-21 891
题解，水题一个，不过多阐述，就是说，有两种应用，一种是2x2的，另一种是1x1的，问然后有x个1x1的应用，有y个2x2的，问这些应用最少占据多少屏幕（屏幕为5x3），这题显而易见，2x2的应用一个屏幕里最多放两个，那么我们可以先去y/2先去找2x2的应用占据多少个屏幕，然后留下来7*y/2个1x1应用的空间，然后判断y是奇数还是偶数，如果是奇数屏幕+1.留下空间，再+11，最后再去与x比较，>x说明，就是前面的那些屏幕，少了，就去x-留下空间数量再除以15，并且判断余数，是否需要再去+1。
Codeforces Round #838 (Div. 2)题解
Kicamon的博客
12-16 580
这场的状态不太好。
Codeforces Round #803 (Div. 2) 题解
Euphria的博客
06-29 1062
题解
Codeforces Round #804 (Div. 2)题解
Euphria的博客
07-06 687
cf题解
Codeforces Round #829 (Div. 2)题解
yuanxinya_的博客
11-13 563
Codeforces Round #829 (Div. 2)题解
Codeforces Round #802 (Div. 2)题解
weixin_53729021的博客
06-20 733
目录A题：A. Optimal Path思路：AC代码：B题：B. Palindromic Numbers思路：AC代码：C题：C. Helping the Nature题意：思路：AC代码：求最短路径长度一道水题，直接上代码 B题：B. Palindromic Numbers 给一个长数字a，求出另一个长度相等的数字b，使a+b的结果为一个回文字符串。如果给出的数字第一位不为9,我们就让相加后的串为长度为的全9串。如果第一位为9,就令相加后的串为长度为的全1串.然后做个高精度减法即可。高精度减法用的
Codeforces Round 945 (Div. 2) 题解分享
2301_80105412的博客
05-18 1568
Div2 945 A~D
Codeforces Round #788 (Div. 2)题解
SillyGOAT的博客
05-08 992
A- 题目大意：给定一个序列，能够交换任意两个数的正负性，问能否构造出不递减 方法: 负数必须是连续出现在前段，正数连续出现在后段。即构造出的序列是先负数后正数。 代码： #include<iostream> using namespace std; const int N=100010; int p[N]; int main() { cin.tie(0); cout.tie(0); ios::sync_with_stdio(0); int t;cin>>
Codeforces Round #726 (Div. 2)题解A-E1
Arctic_Clam的博客
06-19 505
A. Arithmetic Array 分析： 当sum大于n时，那么添加（sum-n）个0，当sum小于n时，只需要添加一个数即可。 #include <iostream> using namespace std; int main() { int t; cin >> t; while(t--) { int n; cin >> n; int sum = 0; for(int i = 0; i &l
题解 Codeforces Round #814 (Div. 1/2)
im_zyINF的博客
08-17 380
Codeforces
Codeforces Round #787 (Div. 3)个人题解
weixin_51767904的博客
05-06 1083
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 #661 (Div. 3) 题解
qq_46365538的博客
08-06 300
Codeforces Round #661 (Div. 3) A. Remove Smallest #include<bits/stdc++.h> using namespace std; #pragma GCC optimize(2) typedef long long ll; typedef unsigned long long ull; typedef long double ld; const int N=100; int t,n,a[N]; int main() {
Codeforces Round #664 (Div. 2)题解
Adrian099的博客
08-13 301
A Boboniu Likes to Color Balls 题意思路 : 给定四种颜色通过以下操作判断能否组成回文串 操作： 前三个减一 后一个加一 思路 : 判断奇数的个数 若和为奇数 则最多有一个奇数 若为偶数 0个 代码： #include<bits/stdc++.h> using namespace std; int c[4]; bool f(){ int sum1 = 0; int sum2 = 0; for(int i = 0; i < 4; i++){ sum
【线段树】 Codeforces 500E New Year Domino
yysys
12-31 1037
用单调栈维护一下就好啦。。。。 #include #include #include #include #include #include #include #include #include #include #include #include #include #define maxn 200005 #define maxm 2000005 #def
【FFT】 Codeforces Round #296 (Div. 1) D - Fuzzy Search
yysys
03-19 994
先将t串反转，然后对每一个字母做多项式乘法。。。全加起来就是t串匹配的最大字母数。。。 #include #include #include #include #include #include #include #include #include #include #include #include #include #define maxn 700005 #defi
【DP】 codeforces 466D Increase Sequence
yysys
09-14 894
很巧妙的DP。。。转化成每次都jian
【DP】 codeforces 500D New Year Santa Network
yysys
12-31 884
和BC的那个题有点像。。。 #include #include #include #include #include #include #include #include #include #include #include #include #include #define maxn 200005 #define maxm 2000005 #defin
codeforces round #828 (div. 3)
06-06
好的，以下是关于Codeforces Round #828 (Div. 3)的一些信息： Codeforces Round #828 (Div. 3)是Codeforces网站上的一场编程竞赛，属于Div. 3级别的比赛。该比赛于2022年3月1日 15:35 (UTC)开始，比赛时长为2个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值