Mynavi Programming Contest 2021（AtCoder Beginner Contest 201）题解

Mynavi Programming Contest 2021（AtCoder Beginner Contest 201）

A - Tiny Arithmetic Sequence

$if-else$直接判

B - Do you know the second highest mountain?

$sort$排序

C - Secret Number

本来以为要计数$DP$/生成函数，但是仔细一看密码位数固定只有$4$位，直接暴力枚举判断

D - Game in Momotetsu World

考试时一直正着跑两人交替，总是错；考虑过倒着跑回去，但是没有实现出来（自己想要的效果）

每个人都是聪明的，都想尽可能拉开与对方的正差距，缩小与对方的负差距

$c_{i,j}-d{p}_{i,j}$写得真的很妙

#include <cstdio>
#include <iostream>
using namespace std;
#define maxn 2005
int dp[maxn][maxn], c[maxn][maxn];
char s[maxn];
int n, m;

int main() {
	scanf( "%d %d", &n, &m );
	for( int i = 1;i <= n;i ++ ) {
		scanf( "%s", s + 1 );
		for( int j = 1;j <= m;j ++ )
			c[i][j] = ( s[j] == '+' ? 1 : -1 );
	}
	for( int i = n;i;i -- )
		for( int j = m;j;j -- ) {
			if( i == n && j == m ) continue;
			else if( i == n ) dp[i][j] = c[i][j + 1] - dp[i][j + 1];
			else if( j == m ) dp[i][j] = c[i + 1][j] - dp[i + 1][j];
			else dp[i][j] = max( c[i + 1][j] - dp[i + 1][j], c[i][j + 1] - dp[i][j + 1] );
		}
	if( dp[1][1] > 0 ) printf( "Takahashi\n" );
	else if( dp[1][1] < 0 ) printf( "Aoki\n" );
	else printf( "Draw\n" );
	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

E - Xor Distances

$E$竟然比$D$简单凸(艹皿艹 )eggs

$d_{i,j}=d_{j,i}\Rightarrow d_{i,j}=d_{k,i}⨁d_{k,j}=d_{k,i}⨁d_{k,j}⨁d_{x,k}⨁d_{x,k}=d_{x,i}⨁d_{x,j}$

两个点之间的最短距离异或等于任选一个点做超级点，超级点到两个点的最短距离异或和(不妨就设为$1$)

异或是二进制操作，各位独立，考虑拆解每一位$i$

如果$i$位有贡献$2^i$，那么一定是两个点到$1$的距离第$i$位异或为$1^0=1$

所以拆开每位分别统计有多少个点的距离该位为$1$，乘法原理，任何一个都可以和该位不是$1$的任何一个组起来

#include <cstdio>
#include <vector>
using namespace std;
#define maxn 200005
#define int long long
#define mod 1000000007
vector < pair < int, int > > G[maxn];
int n;
int dep[maxn];

void dfs( int u, int fa ) {
	for( int i = 0;i < G[u].size();i ++ ) {
		int v = G[u][i].first, w = G[u][i].second;
		if( v == fa ) continue;
		else dep[v] = dep[u] ^ w, dfs( v, u );
	}
}

signed main() {
	scanf( "%lld", &n );
	for( int i = 1, u, v, w;i < n;i ++ ) {
		scanf( "%lld %lld %lld", &u, &v, &w );
		G[u].push_back( make_pair( v, w ) );
		G[v].push_back( make_pair( u, w ) );
	}
	dfs( 1, 0 );
	int ans = 0;
	for( int j = 0;j < 60;j ++ ) {
		int cnt = 0;
		for( int i = 1;i <= n;i ++ )
			if( 1ll << j & dep[i] ) cnt ++;
			else;
		ans = ( ans + ( 1ll << j ) % mod * cnt % mod * ( n - cnt ) % mod ) % mod;
	}
	printf( "%lld\n", ans );
	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

F - Insertion Sort

显然，对于每个数最多只会操作一次，假设不动数的集合为$S$，且$S_1<S_2<...<S_x$

那么其必定满足$po{s}_{S_1}<po{s}_{S_2}<...<po{s}_{S_x}$且对于某个点$i,i\notin S$

• $i:A_i$
• $po{s}_i<S_1:B_i$
• $S_x<po{s}_i:C_i$

设$d{p}_i:S$中最大下标为$i$时的最小操作数

$d{p}_i=min({\sum }_{j=1}^{i-1}min(A_j,B_j),{\min }_{j<i,po{s}_j<po{s}_i}(d{p}_j+{\sum }_{k=j+1}^{i-1}{A}_k)$

对$po{s}_i$建线段树，$log$查询

最后的答案即为$min(d{p}_i+{\sum }_{j=i+1}^{n}min(A_j,C_j))$

#include <cstdio>
#include <iostream>
using namespace std;
#define inf 1e15
#define maxn 200005
#define int long long
int n;
int P[maxn], A[maxn], B[maxn], C[maxn];
int Asum[maxn], Bsum[maxn], Csum[maxn], pos[maxn];
int dp[maxn], t[maxn << 2];

void modfiy( int num, int l, int r, int p, int v ) {
	if( l == r ) {
		t[num] = v;
		return;
	}
	int mid = ( l + r ) >> 1;
	if( p <= mid ) modfiy( num << 1, l, mid, p, v );
	else modfiy( num << 1 | 1, mid + 1, r, p, v );
	t[num] = min( t[num << 1], t[num << 1 | 1] );
}

int query( int num, int l, int r, int L, int R ) {
	if( L <= l && r <= R ) return t[num];
	int mid = ( l + r ) >> 1, ans = inf;
	if( L <= mid ) ans = min( ans, query( num << 1, l, mid, L, R ) );
	if( mid < R ) ans = min( ans, query( num << 1 | 1, mid + 1, r, L, R ) );
	return ans;
}

signed main() {
	scanf( "%lld", &n );
	for( int i = 1;i <= n;i ++ ) {
		scanf( "%lld", &P[i] );
		pos[P[i]] = i;
	}
	for( int i = 1;i <= n;i ++ )
		scanf( "%lld %lld %lld", &A[i], &B[i], &C[i] );
	for( int i = 1;i <= n;i ++ ) {
		Asum[i] = Asum[i - 1] + A[i];
		Bsum[i] = Bsum[i - 1] + min( A[i], B[i] );
		Csum[i] = Csum[i - 1] + min( A[i], C[i] );
	}
	int ans = inf;
	for( int i = 1;i <= n;i ++ ) {
		dp[i] = min( Bsum[i - 1], query( 1, 1, n, 1, pos[i] ) + Asum[i - 1] );
		ans = min( ans, dp[i] + Csum[n] - Csum[i] );
		modfiy( 1, 1, n, pos[i], dp[i] - Asum[i] );
	}
	printf( "%lld\n", ans );
	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