AtCoder Beginner Contest 255 题解
AtCoder Beginner Contest 255 Solution
更好的阅读体验戳此进入
题面链接
题面 Luogu 链接
abcd 跳了
[ABC255E] Lucky Numbers
题面
给定长度为 $ n - 1 $ 的序列 $ S $，存在序列 $ a_n $ 满足 $ a_i + a_{i + 1} = S_i $，给定 $ m $ 个幸运数字 $ x_1, x_2, \cdots, x_m $。你需要确定一个合法序列 $ a $ 使其中有最多的数字为幸运数字，求最大值。
Solution
首先不难发现，对于序列 $ a_n $ 存在 $ n - 1 $ 个等式，故仅需确定一个数就可确定其它的数，则 $ O(n^2m) $ 的做法显然。考虑优化，以 $ a_1 $ 为指标，$ O(nm) $ 枚举之后计算 $ a_1 $ 然后把对应贡献加上最后统计一下最大值即可。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW(arr) void* Edge::operator new(size_t){static Edge* P = arr; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
template < typename T = int >
inline T read(void);
int N, M;
int S[110000];
int lucky[20];
ll sum[110000];
int ans(-1);
unordered_map < ll, int > mp;
int main(){
N = read(), M = read();
for(int i = 1; i <= N - 1; ++i)
S[i] = read(), sum[i] = sum[i - 1] + (i & 1 ? 1 : -1) * S[i];
for(int i = 1; i <= M; ++i)lucky[i] = read();
for(int i = 1; i <= N; ++i)
for(int j = 1; j <= M; ++j)
mp[(i & 1 ? 1 : -1) * lucky[j] + sum[i - 1]]++;
for(auto v : mp)ans = max(ans, v.second);
printf("%d\n", ans);
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
[ABC255F] Pre-order and In-order
题面
给定一棵二叉树的先序遍历和中序遍历，请构造一棵以 $ 1 $ 节点为根的二叉树。第 $ i $ 行输出节点 $ i $ 的左右儿子，儿子为空则输出 $ 0 $。无解输出 -1。
Solution
也是一道水题，考虑先序和中序的意义即可。
众所周知，先序遍历的顺序是根、左子树、右子树。中序遍历是左子树、根、右子树。
于是不难发现，在当前的先序遍历中取第一个数即为当前的根，然后在中序遍历中找到根的位置，其左侧即为整个左子树，右侧为整个右子树。于是不难想到 dfs 即可，参数维护当前的整个子树属于先序遍历的 $ [lp, rp] $，属于中序遍历的 $ [li, ri] $，然后需要记录每个数的位置，通过中序遍历根和左右之间的数的个数，可计算左右子树的大小，以此即可确定先序遍历左右子树的下一个区间，以此递归下去即可。
考虑无解的情况，要么先序遍历的第一个值不为 $ 1 $，说明二叉树根不为 $ 1 $。要么就是在递归过程中，确定先序的第一位为根之后，根在中序中的位置超出了当前的限制位置，在这两种特殊情况记录一下无解即可。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW(arr) void* Edge::operator new(size_t){static Edge* P = arr; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
template < typename T = int >
inline T read(void);
int N;
int Pre[210000], In[210000];
int posP[210000], posI[210000];
pair < int, int > son[210000];
int dfs(int lp = 1, int rp = N, int li = 1, int ri = N){
// printf("In dfs(%d ~ %d, %d ~ %d)\n", lp, rp, li, ri);
if(lp > rp)return 0;
int rt = Pre[lp];
if(posI[rt] < li || posI[rt] > ri)puts("-1"), exit(0);
if(lp == rp)return rt;
int lsiz = (posI[rt] - 1) - li + 1;
son[rt].first = dfs(lp + 1, lp + lsiz, li, posI[rt] - 1);
son[rt].second = dfs(lp + lsiz + 1, rp, posI[rt] + 1, ri);
return rt;
}
int main(){
N = read();
for(int i = 1; i <= N; ++i)posP[Pre[i] = read()] = i;
for(int i = 1; i <= N; ++i)posI[In[i] = read()] = i;
if(Pre[1] != 1)puts("-1"), exit(0);
dfs();
for(int i = 1; i <= N; ++i)printf("%d %d\n", son[i].first, son[i].second);
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
[ABC255G] Constrained Nim
题面
一般 Nim 游戏基础上增加 $ m $ 条限制，限制当石子数为 $ x_i $ 时不能拿走其中的 $ y_i $ 个。
Solution
显然博弈论，考虑 SG函数。Nim 游戏标准套路，对于多个石子堆求出每个石子堆石子数 $ a_i $ 的 $ SG(a_i) $，若 $ \bigoplus_{i = 1}^n SG(a_i) = 0 $ 则先手必输，反之必胜。关于 SG函数 的详解：SG函数学习笔记。
本题的区别即为 $ m $ 条限制，考虑如何处理。显然一般 Nim 游戏的 SG 函数有转移 $ SG(i) = \operatorname{mex}{SG(j) \mid j \in [1, i - 1]} $，本题的区别不难想到就是在一般的 SG函数 基础上，在求 $ \operatorname{mex} $ 的时候需要从中去掉一些值，也就是去掉 $ SG(x_i) $ 转移中的 $ SG(x_i - y_i) $。严谨点叙述就是 $ SG(i) = \operatorname{mex}{SG(j) \mid j \in [1, i - 1] \land (i, j) \neq (x_k, x_k - y_k), k \in[1, m] } \(。考虑维护，显然值域过大无法硬做。发现每次从中去掉一些值后，\) \operatorname{mex} $ 的值就会变为最小的被全部删除的元素。然后在这个位置以后，下一条限制以前，每次的 $ SG(i) = SG(i - 1) + 1 $。发现整个值的分布实际上就是一些特殊点和很多条斜率为 $ 1 $ 的线段。所以我们对于答案，考虑开个 map 记录转折点，每次查询对应的所在位置然后增加对应数量的 $ 1 $ 即可。
具体实现过程也不难理解，开个 map 里套 basic_string 维护对应 $ x_i $ 的所有 $ x_i - y_i $，然后遍历，显然升序遍历过程中 $ x_i $ 以内的 $ SG $ 均已确定。然后考虑如何确定当前的 $ SG(i) $，不难发现对于没有限制的 $ SG $ 值即为其之前的所有 $ SG $ 的最大值，也就是前缀最大值 $ +1 $。对于有限制的，我们枚举其所有限制，找到最小的一个被删没的值（注意这里比较的时候要 $ +1 $，原因是遍历到此时的时候一般情况下会有一个 $ SG(i) = i $），将其设为这个。此为特殊点，然后在其之后的点依然按照一般的斜率为 $ 1 $ 地增长，用前缀最大值更新，记录一下即可。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW(arr) void* Edge::operator new(size_t){static Edge* P = arr; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
template < typename T = int >
inline T read(void);
int N, M;
ll A[210000];
ll oplus(0);
map < ll, basic_string < ll > > rest;
map < ll, ll > SG, repeat;
ll CalSG(ll x){
auto sp = *prev(SG.upper_bound(x));
return sp.second + (x - sp.first);
}
int main(){
N = read(), M = read(); SG.insert({0, 0});
for(int i = 1; i <= N; ++i)A[i] = read < ll >();
for(int i = 1; i <= M; ++i){
ll p = read < ll >(), v = read < ll >();
rest[p] += p - v;
}
ll preMx(-1);
for(auto &mp : rest){
preMx = max(preMx, CalSG(mp.first - 1));
map < ll, ll > tmp;
for(auto val : mp.second)tmp[CalSG(val)]++;
for(auto cur : tmp){
if(cur.second >= repeat[cur.first] + 1){
repeat[cur.first]++;
SG[mp.first] = cur.first;
break;
}
}preMx = max(preMx, CalSG(mp.first));
SG[mp.first + 1] = preMx + 1;
}
for(int i = 1; i <= N; ++i)oplus ^= CalSG(A[i]);
printf("%s\n", oplus ? "Takahashi" : "Aoki");
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
[ABC255Ex] Range Harvest Query
题面
给定一片 \(N\) 格的农田，从第 \(0\) 天开始，第 \(i\) 格农田每天会长出 \(i\) 的作物。
给出 \(Q\) 个询问，每次询问以 \(D,L,R\) 的格式给出，表示询问在第 \(D\) 天，收割 \([L,R]\) 的农田，会获得多少作物？答案对 \(998244353\) 取模。注意询问相互依赖，即在每一次收割后，\([L,R]\) 的作物应当清零。
Solution
ODT 随便搞一下即可，没有任何难度，处理一下细节即可。一下子居然没看出来，日常身败名裂。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW(arr) void* Edge::operator new(size_t){static Edge* P = arr; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
#define MOD (998244353ll)
template < typename T = int >
inline T read(void);
struct Node{
ll l, r;
mutable ll lst;
friend const bool operator < (const Node &a, const Node &b){
return a.l < b.l;
}
};
class ODT{
private:
set < Node > tr;
public:
auto Insert(Node p){return tr.insert(p);}
auto Split(ll p){
auto it = tr.lower_bound(Node{p});
if(it != tr.end() && it->l == p)return it;
advance(it, -1);
ll l = it->l, r = it->r, lst = it->lst;
tr.erase(it);
Insert(Node{l, p - 1, lst});
return Insert(Node{p, r, lst}).first;
}
ll Assign(ll l, ll r, ll days){
ll ret(0);
auto itR = Split(r + 1), itL = Split(l);
for(auto it = itL; it != itR; ++it)
(ret += ((__int128_t)(it->l + it->r) * (it->r - it->l + 1) / 2ll) % MOD * (days - it->lst) % MOD) %= MOD;
tr.erase(itL, itR);
Insert(Node{l, r, days});
return ret;
}
}odt;
ll N; int Q;
int main(){
N = read < ll >(), Q = read();
odt.Insert(Node{1, N, 0});
while(Q--){
ll D = read < ll >(), L = read < ll >(), R = read < ll >();
printf("%lld\n", odt.Assign(L, R, D));
}
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
UPD
update-2022_12_07 初稿
浙公网安备 33010602011771号