codeforces 训练_codeforces训练

• Codeforces Round #805 F
• 思路:
  1 如果a $=$ b,无需操作,直接跳过去
  2 如果a $\ne$ b,两种操作第一种 a = b * 2, a 一定是偶数,这时 b = a / 2也成立; 第二种 a = b / 2, b是偶数或者奇数,
  3 从2知道我们可以用大根堆来维护两个序列,如果说堆顶a 大于堆顶b 并且a是奇数的话,就无法使得 a = b * 2,所以错误
• 代码

#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define int long long 
#define PII pair<int,int>
#define ios ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)

using namespace std;
const int N = 1e4 + 100,M = 1e5 + 100,mod = 1e9 + 7,INF = 0x3f3f3f3f;

void solve()
{
	int n; cin >> n;
	priority_queue<int,vector<int>,less<int> > A,B;

	for(int i = 1;i <= n;i ++ )
	{
		int x; cin >> x;
		A.push(x);
	}
	
	for(int i = 1;i <= n;i ++ )
	{
		int x; cin >> x;
		B.push(x);
	}
	int f = 0;
	while(A.size())
	{
		int a = A.top();
		int b = B.top();
		if(a == b)
		{
			 A.pop();B.pop();
			 continue;
		}
		
		if(a > b && (a & 1))
		{
			f = 1;
			break;
		}
		
		if(a > b) A.push(a / 2),A.pop();
		else B.push(b / 2),B.pop();
	}
	
	if(f) cout << "NO" << endl;
	else cout << "YES" << endl; 

}
signed main() 
{
	ios;int T; cin >> T;  
	while(T -- ) solve();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

• 最近公共祖先(lca)
  树上结构,无环,n个点n - 1条边,求u,v的最近公共祖先,
  做法的话 就是先求每一个点的深度(dfs 或者 bfs),然后让u,v处于同一个深度,然后向上找他们的最近公共祖先,

• 两个做法

• 1 时间复杂度为O(n * m)的做法,假如 dep[ u ] > dep[v],让他们处于同一个深度的话就是不断的让 u = fa[ u ],直到u,v在同一层,然后求 lca 的话,如果u == v那就结束循环,否则两个点一起同时向上寻找,就是递归直到u == v

• 2 时间复杂度为O(n * log(n)),这里面的思想是基于二进制的,就是两个点处于同一层的优化,因为我们知道每一个数字都可以用二进制表示,比如dep[u] = 64,dep[v] = 24,想让 u 到 v这一层, 首先可以判断一下直接跳到64行不行 64 - 64 < 24的不行,然后让u跳32 64 - 32 >= 24,可行,然后dep[u] = 32,然后让u跳16 发现 32 - 16 < 24,不行,然后让 u 跳 8发现32 - 8 = 24,此时就让他们处于同一层了,原理是任何一个数字都可以用2的次方和来表示 具体详细

• 关于lca的练习
  1 codeforces #805 g

• 思路

• 确定两个端点的位置,一个端点p1就是层数最深的那个点,端点p2就是该链子上的另一个子树的最深的那个点,在这条链上的其他点p与两个端点的lca,要么是他本身p,要么是两个端点的lca(p1,p2),确定端点以后就判断每一个点p是否符合上述的规则

• 代码：

#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define int long long 
#define PII pair<int,int>
#define ios ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)

using namespace std;
const int N = 2e5 + 100,M = 1e5 + 100,mod = 1e9 + 7,INF = 0x3f3f3f3f;
vector<int> res[N];
int d[N],a[N],fa[N][20],pre[N];

void bfs()
{
	queue<int> q;
	d[1] = 1;
	q.push(1);
	
	while(q.size())
	{
		int t = q.front();q.pop();
		for(int i = 0;i < res[t].size();i ++ )
		{
			int j = res[t][i];
			if(!d[j]) 
			{
				d[j] = d[t] + 1;
				q.push(j);
				fa[j][0] = t;
				pre[j] = t;
				for(int k = 1;k <= 19;k ++ )
				{
					fa[j][k] = fa[fa[j][k - 1]][k - 1];
				}
			}
		}
	}
}

int lca(int u,int v)
{
	if(d[u] < d[v]) swap(u,v);
	for(int i = 19;i >= 0;i -- ) // 倒着来 我明白 假如 i = 4,下一个i就一定不是4,如果是4的话,就代表跳了8,那在上一个i就可以跳了,没必要到i = 4这一层 
	{
		if(d[fa[u][i]] >= d[v])
		{
			u = fa[u][i]; // 让 u 和 v 在一层 
		}
	}
	
	if(u == v) return u;
	
	for(int i = 19;i >= 0;i -- ) // 必须倒着来,因为他跳的时候不是1层1层跳的,是2的i次方层跳的,所以必须从大到小, 
	{
		if(fa[u][i] != fa[v][i])
		{
			u = fa[u][i];v = fa[v][i];
		}
	}
	// 如果u,v跳到第i层是相等的,那就继续跳,如果跳到第i层不相等,就改变u,v,然后继续往上面跳,直到遇到层数最大的才是他们的最近公共祖先 
	return fa[u][0]; // u的上一层就是最近公共祖先 
	 
}

void solve()
{
	int n,m; cin >> n;
	for(int i = 1;i <= n - 1;i ++ )
	{
		int u,v; cin >> u >> v;
		res[u].pb(v); res[v].pb(u);
	}
	
	bfs();
	
	cin >> m;
	
	while(m -- )
	{
		int k; cin >> k;
		int p2 = -1,p1 = -1,len = -1;
		for(int i = 1;i <= k;i ++ )
		{
			cin >> a[i];
			if(d[a[i]] > len)
			{
				len = d[a[i]];
				p1 = a[i];
			}
		}
		
		for(int i = 1;i <= k;i ++ )
		{
			if(p1 != a[i])
			{

				int ans = lca(p1,a[i]);
				if(ans != a[i])
				{
					if(p2 == -1 || d[a[i]] > d[p2]) p2 = a[i];
				}
			}
			
		}
		
		if(p2 == -1) cout << "YES" << endl;
		else
		{
			int u = p1,v = p2;
			int ans = lca(p1,p2);
			int success = 1;
			for(int i = 1;i <= k;i ++ )
			{
				int w1 = lca(p1,a[i]);
				int w2 = lca(p2,a[i]);
				if(!((w1 == ans && w2 == a[i])||(w2 == ans && w1 == a[i])))
				{
					success = 0;
					break;
				}
			}
			
			cout << (success ? "YES" : "NO") << endl;
		}

	}
	
}
signed main() 
{
	ios;int T = 1;  
	while(T -- ) solve();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

• 练习2 洛谷 P5836 [USACO19DEC]Milk Visits S
• 思路:

• 并查集 只要是相连的两个点的字符是一样的那就把他们放到一个连通块里面，然后判断的时候如果在一个连通块里面并且不等给出的字符c，那就一定是不可能的，否则其他情况都是可以的

• lca lca的话就是用一个前缀数组求和，然后差分判断这一段里面有没有与题目给的字符相等的字符

• 并查集简单但是不好想，lca的话代码长，思路简单好想
• lca代码

#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define int long long 
#define PII pair<int,int>
#define ios ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)

using namespace std;
const int N = 1e5 + 100,M = 1e5 + 100,mod = 1e9 + 7,INF = 0x3f3f3f3f;
vector<int> res[N];
int d[N],a[N],fa[N][20];
int g[N],h[N];
char s[N]; 
void bfs(int root)
{
	queue<int> q;
	q.push(root);
	d[root] = 1;
	if(s[root] == 'H')
	h[1] = 1;
	else
	g[1] = 1;
	
	while(q.size())
	{
		int t = q.front();q.pop();
		for(int i = 0;i < res[t].size();i ++ )
		{
			int j = res[t][i];
			if(!d[j])
			{
				d[j] = d[t] + 1;
				fa[j][0] = t;
				q.push(j);
				int H = 0,G = 0;
				if(s[j] == 'H')
				H = 1;
				else 
				G = 1;
				
				h[j] += h[t] + H;
				g[j] += g[t] + G; 
				
				for(int k = 1;k <= 19;k ++ )
				fa[j][k] = fa[fa[j][k - 1]][k - 1]; 			
			}
			 
		}
	} 
}

int lca(int u,int v)
{
	// 1 u 和 v要到达同一层
	if(d[u] < d[v]) swap(u,v);
	
	for(int i = 19;i >= 0;i -- )
	{
		if(d[fa[u][i]] >= d[v])
		{
			u = fa[u][i];
		}
	} 
	
	if(u == v) return u;
	// 同一层同时往上面走 
	for(int i = 19;i >= 0 ;i -- )
	{
		if(fa[u][i] != fa[v][i])
		{
			u = fa[u][i];v = fa[v][i];
		}
	}
	
	return fa[u][0];
}

void solve()
{
	int n,m;cin >> n >> m;
	cin >> s + 1;
	
	for(int i = 1;i <= n - 1;i ++ )
	{
		int u,v; cin >> u >> v;
		res[u].pb(v);res[v].pb(u);
	}
	bfs(1);
	while(m -- )
	{
		int a,b,ans;char c;cin >> a >> b >> c;
		int anc = lca(a,b);
	//	cout << anc << endl;
		if(c == 'H') ans = h[a] + h[b] - h[anc] - h[fa[anc][0]];
		else ans = g[a] +g[b] - g[anc] - g[fa[anc][0]];
		
		if(ans) cout << "1";
		else cout << "0"; 
	}
	
}
signed main() 
{
	ios;int T = 1;  
	while(T -- ) solve();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

• 并查集代码

#include <bits/stdc++.h>
#define fi first
#define se second
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back
#define int long long 
#define PII pair<int,int>
#define ios ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)

using namespace std;
const int N = 1e5 + 100,M = 1e5 + 100,mod = 1e9 + 7,INF = 0x3f3f3f3f;
vector<int> res[N];
int d[N],a[N],fa[N][20];
int pre[N],p[N];
char s[N]; 
void bfs(int root)
{
	queue<int> q;
	q.push(root);
	d[root] = 1;
	
	while(q.size())
	{
		int t = q.front();q.pop();
		for(int i = 0;i < res[t].size();i ++ )
		{
			int j = res[t][i];
			if(!d[j])
			{
				d[j] = d[t] + 1;
				fa[j][0] = t;
				q.push(j);
				pre[j] = t;
				for(int k = 1;k <= 19;k ++ )
				fa[j][k] = fa[fa[j][k - 1]][k - 1]; 			
			}
			 
		}
	} 
}

int lca(int u,int v)
{
	// 1 u 和 v要到达同一层
	if(d[u] < d[v]) swap(u,v);
	
	for(int i = 19;i >= 0;i -- )
	{
		if(d[fa[u][i]] >= d[v])
		{
			u = fa[u][i];
		}
	} 
	
	if(u == v) return u;
	// 同一层同时往上面走 
	for(int i = 19;i >= 0 ;i -- )
	{
		if(fa[u][i] != fa[v][i])
		{
			u = fa[u][i];v = fa[v][i];
		}
	}
}
int find(int x)
{
	if(x != p[x]) p[x] = find(p[x]);
	
	return p[x];
}

void Union(int a,int b)
{
	a = find(a);b = find(b);
	if(a != b)
	{
		p[a] = b;
	}
}
void solve()
{
	int n,m;cin >> n >> m;
	cin >> s + 1;
	for(int i = 1;i <= n;i ++ ) p[i] = i;
	
	for(int i = 1;i <= n - 1;i ++ )
	{
		int u,v; cin >> u >> v;
		if(s[u] == s[v]) Union(u,v);
	}
	
	while(m -- )
	{
		int a,b;char c;cin >> a >> b >> c;
		// 相连的两个字符一样就可以把他们连接到一个联通块里面
		// 如果在一个联通块里面并且字符不相等的话,就一定不可以
		// 其他情况就是不在一个连通块里面,那一定有不一样的两个字符
		 // 或者在一个连通块里面,但是字符是相同的也行 
		if(find(a) == find(b) && c != s[a]) cout << "0"; // 只有路径一样并且这个字符是相反的才不可能 
		else cout << "1";
	}
	
}
signed main() 
{
	ios;int T = 1;  
	while(T -- ) solve();

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111