AtCoder Beginner Contest 255 题解

AtCoder Beginner Contest 255 Solution

目录

• AtCoder Beginner Contest 255 Solution
  • 更好的阅读体验戳此进入
  • 题面链接
  • 题面 Luogu 链接
    • abcd 跳了
  • [ABC255E] Lucky Numbers
    • 题面
    • Solution
    • Code
  • [ABC255F] Pre-order and In-order
    • 题面
    • Solution
    • Code
  • [ABC255G] Constrained Nim
    • 题面
    • Solution
    • Code
  • [ABC255Ex] Range Harvest Query
    • 题面
    • Solution
    • Code
  • UPD

更好的阅读体验戳此进入

题面链接

题面 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^{2}m)$ 的做法显然。考虑优化，以 $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)$，若 $\underset{i=1}{\overset{n}{⨁}}SG(a_i)=0$ 则先手必输，反之必胜。关于 SG函数 的详解：SG函数学习笔记。

本题的区别即为 $m$ 条限制，考虑如何处理。显然一般 Nim 游戏的 SG 函数有转移 $SG(i)=\mathrm{mex}SG(j)\mid j\in [1,i-1]$，本题的区别不难想到就是在一般的 SG函数 基础上，在求 $\mathrm{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] } $。\mathrm{考}\mathrm{虑}\mathrm{维}\mathrm{护}，\mathrm{显}\mathrm{然}\mathrm{值}\mathrm{域}\mathrm{过}\mathrm{大}\mathrm{无}\mathrm{法}\mathrm{硬}\mathrm{做}。\mathrm{发}\mathrm{现}\mathrm{每}\mathrm{次}\mathrm{从}\mathrm{中}\mathrm{去}\mathrm{掉}\mathrm{一}\mathrm{些}\mathrm{值}\mathrm{后}，$ \operatorname{mex} $\mathrm{的}\mathrm{值}\mathrm{就}\mathrm{会}\mathrm{变}\mathrm{为}\mathrm{最}\mathrm{小}\mathrm{的}\mathrm{被}\mathrm{全}\mathrm{部}\mathrm{删}\mathrm{除}\mathrm{的}\mathrm{元}\mathrm{素}。\mathrm{然}\mathrm{后}\mathrm{在}\mathrm{这}\mathrm{个}\mathrm{位}\mathrm{置}\mathrm{以}\mathrm{后}，\mathrm{下}\mathrm{一}\mathrm{条}\mathrm{限}\mathrm{制}\mathrm{以}\mathrm{前}，\mathrm{每}\mathrm{次}\mathrm{的}$ SG(i) = SG(i - 1) + 1 $。\mathrm{发}\mathrm{现}\mathrm{整}\mathrm{个}\mathrm{值}\mathrm{的}\mathrm{分}\mathrm{布}\mathrm{实}\mathrm{际}\mathrm{上}\mathrm{就}\mathrm{是}\mathrm{一}\mathrm{些}\mathrm{特}\mathrm{殊}\mathrm{点}\mathrm{和}\mathrm{很}\mathrm{多}\mathrm{条}\mathrm{斜}\mathrm{率}\mathrm{为}$ 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 初稿