AtCoder Regular Contest 175 A~D

A.Spoon Taking Problem（模拟）

题意：

问题陈述

有$N$人围坐在一张圆桌旁，按逆时针顺序编号为$1$至$N$。每个人都有一只惯用手：左手或右手。

圆桌上有$N$把勺子，编号为$1$至$N$，每对相邻的人之间放一把勺子。在每个人$i$（$1\le i\le N$）的左边和右边，分别有勺子$i$和$(i+1)$。这里，勺子$(N+1)$指的是勺子$1$。

下图是$N=4$的示意图。

给你一个$(1,\dots ,N)$的排列组合$(P_1,\dots ,P_N)$。在$i=1,\dots ,N$的顺序中，第$P_i$个人的行为如下：

• 如果左侧或右侧有剩余的勺子，他们将拿走其中一个。
• 如果两边都有剩余的勺子，他们会拿自己惯用手一边的勺子。
• 否则，他们什么也不会做。

我们还给出了一个长度为$N$的字符串$S$，由L、R和?组成。在$2^N$种可能的惯用手组合中，求有多少种满足以下所有条件，答案对$998244353$取模。

• 如果$S$的$i$个字符是"L"，那么$i$是左撇子。
• 如果$S$的第$i$个字符是"R"，那么$i$就是右撇子。
• 当每个人都表演完后，每个人都拿了一个勺子。

分析：

如果$s[i]=L$，那么$i$这个人就要拿左边的勺子，如果左边没有就拿右边的，右边也没有就无解。当$s[i]=R$时同理。

如果$s[i]=?$，那么代表这个人的惯用手由我们决定。若第一个人拿了右边，那么接下来所有人都必须拿右边，否则一定无解。

考虑$s[i]=?$，如果有一开始拿的是右边，而且轮到?的这个人，只有右边这个勺子，那么这个人是左手和右手都没有关系，总方案就会$\ast 2$。

模拟所有情况即可。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL MOD = 998244353;
const LL N = 2e5 + 5;

int n, p[N];
string s;

int solveL() {
    LL ans = 1;
    bool vis[n + 5];
    for (int i = 0; i <= n + 1; i++)
        vis[i] = false;
    vis[0] = vis[n + 1] = true;
    vis[p[1]] = true;
    for (int i = 2; i <= n; i++) {
        int l = p[i];
        int r = p[i] + 1;
        if (r == n + 1)
            r = 1;
        if (vis[l] && vis[r]) {
            return 0;
        } else if (!vis[l] && !vis[r]) {
            if (s[l] == 'R') {
                return 0;
            }
            vis[l] = true;
        } else if (!vis[l]) {
            vis[l] = true;
            if (s[l] == '?') {
                ans *= 2;
                ans %= MOD;
            }
        } else {
            return 0;
        }
    }
    return ans;
}

int solveR() {
    LL ans = 1;
    bool vis[n + 5];
    for (int i = 0; i <= n + 1; i++)
        vis[i] = false;
    vis[0] = vis[n + 1] = true;
    if (p[1] + 1 == n + 1)
        vis[1] = true;
    else
        vis[p[1] + 1] = true;

    for (int i = 2; i <= n; i++) {
        int l = p[i], r = p[i] + 1;
        if (r == n + 1)
            r = 1;
        if (vis[l] and vis[r]) {
            return 0;
        } else if (!vis[l] and !vis[r]) {
            if (s[l] == 'L') {
                return 0;
            }
            vis[r] = true;
        } else if (!vis[r]) {
            vis[r] = true;
            if (s[l] == '?') {
                ans *= 2;
                ans %= MOD;
            }
        } else {
            return 0;
        }
    }
    return ans;
}


int main() {
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> p[i];
    cin >> s;
    s = "0" + s;
    LL ans;
    if (s[p[1]] == 'L')
        ans = solveL();
    else if (s[p[1]] == 'R')
        ans = solveR();
    else
        ans = solveL() + solveR();
    cout << ans % MOD << endl;
    return 0;
}

B.Parenthesis Arrangement（栈）

题意：

问题陈述

给你一个长度为$2N$的字符串$S$，由字符(和)组成。让$S_i$表示$S$左边的第$i$个字符。

你可以按任意顺序执行以下两种类型的操作零次或多次：

• 选择一对整数$(i,j)$，使得$1\le i<j\le 2N$。交换$S_i$和$S_j$。这一操作的代价是$A$。

• 选择一个整数$i$，使得$1\le i\le 2N$。将$S_i$替换为(或)。这个操作的代价是$B$。

你的目标是使$S$成为一个正确的括号序列。求实现这一目标所需的最小总成本。可以证明，用有限次的运算总能达到目标。

什么是正确的括号序列。正确的括号序列是满足以下任意条件的字符串：

• 它是空字符串。
• 它是由(,$A$,)按此顺序连接而成，其中$A$是一个正确的括号序列。
• 由$A$和$B$依次连接而成，其中$A$和$B$是正确的括号序列。

分析：

由题意得合法的括号不需要修改。

建立一个栈用于遍历括号序列，进栈，如果遇到栈顶是(，当前是)，弹出栈顶，否则当前入栈

然后就会剩下

1. (((((
2. ))))))
3. ))((((

这三种情况。

显然$1$和$2$只能修改一半使序列合法。$3$交换一次相当于修改两个位置。如果$a<=2\ast b$，一定要先执行交换操作。

模拟一下若有))((((，交换一次()((()，发现一次交换产生了两对合法括号。

交换完毕之后如果还有剩下的((((，那么只需要将一半翻转。

如果$a>2\ast b$，那么我们只能翻转。)))(((，左半边翻转一半，右半边翻转一半，如果是奇数还剩下两个括号)(，那么还需要再翻两遍。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;

void solve() {
    LL n, a, b;
    cin >> n >> a >> b;
    string s;
    cin >> s;
    stack<char> s1, s2;
    s1.push(s[0]);
    for (int i = 1; i <= s.length() - 1; i++) {
        if (s1.size() && s1.top() == '(' && s[i] == ')') {
            s1.pop();
        } else {
            s1.push(s[i]);
        }
    }
    LL c9 = 0, c0 = 0;
    while (s1.size()) {
        if (s1.top() == '(')
            c9++;
        else
            c0++;
        s2.push(s1.top());
        s1.pop();
    }
    LL ans = 0;
    if (c9 == 0 || c0 == 0) {
        ans = (c9 + c0) / 2 * b;
    } else {
        if (a <= 2 * b) {
            ans = (min(c0, c9) + 1) / 2 * a + (max(c0, c9) - min(c0, c9)) / 2 * b;
        } else {
            if (c0 & 1) {
                ans = (c0 / 2 + c9 / 2 + 2) * b;
            } else {
                ans = (c0 / 2 + c9 / 2) * b;
            }
        }
    }
    cout << ans << endl;
}

int main() {
    solve();
    return 0;
}

C.Jumping Through Intervals（数学）

题意：

问题陈述

给你$N$对整数$(L_1,R_1),(L_2,R_2),\dots ,(L_N,R_N)$。这里，$L_i\le R_i$代表所有的$1\le i\le N$。

由$N$个整数组成的序列$A=(A_1,A_2,\dots ,A_N)$如果满足以下条件，则称为好整数序列：

• 所有$1\le i\le N$均为$L_i\le A_i\le R_i$。

求使$\sum _{i=1}^{N-1}|A_{i+1}-A_i|$最小的的字典序最小的好整数序列$A$。

分析：

首先，对于$1\le k\le N$ 和整数 $x$ ，我们定义 $f_k(x)$ 如下：

$$f_k(x)=(\text{The minimum value of}\sum _{i=k}^{N-1}|A_{i+1}-A_i|\text{under the constraints}{A}_k=x,L_i\le A_i\le R_i(k+1\le i\le N))$$

从定义可知，$f_N(x)=0$。另外，我们对整数集合$I_k$定义如下：

$$\begin{array}{rl}{I}_k=\underset{x\in [L_k,R_k]\cap \mathbb{Z}}{\mathrm{argmin}}{f}_k(x)& \\ & =\{x\in [L_k,R_k]\cap \mathbb{Z}|f_k(x)=\underset{x^{\prime }\in [L_k,R_k]\cap \mathbb{Z}}{\min }{f}_k(x^{\prime })\}.\end{array}$$

那么，下面的命题成立。

命题 1

$I_k$可以表示为$1\le k\le N$的整数间隔。也就是说，存在整数$l_k,r_k(l_k\le r_k)$这样的$I_k=[l_k,r_k]\cap \mathbb{Z}$。以下我们使用这些$l_k,r_k$。
2. $I_N=[L_N,R_N]$，而对于$k<N$、

• $[L_k,R_k]\cap I_{k+1}\ne \varnothing$，则$I_k=[L_k,R_k]\cap I_{k+1}$。
• I k = { R k } I_k= \lbrace R_k\rbrace Ik​={Rk​}，若$R_k<l_{k+1}$。
• I k = { L k } I_k= \lbrace L_k\rbrace Ik​={Lk​}若$L_k>r_{k+1}$。
  让$m_k=\underset{x\in [L_k,R_k]\cap \mathbb{Z}}{\min }{f}_k(x)$。对于$1\le k<N$、

$$f_k(x)=\{\begin{array}{ll}{m}_{k+1}+l_k-x& (x<l_k)\\ m_{k+1}& (x\in [l_k,r_k])\\ m_{k+1}+x-r_k& (r_k<x)\end{array}$$

这个命题可以用归纳法按$k$的降序证明。根据命题1，存在整数$l_k,r_k$，使得$I_k=[l_k,r_k]$。同时，根据命题1.2，我们可以确定每个$l_k,r_k$按$k$的降序排列。

接下来，我们考虑构建词性最小解。根据$I_1$的定义，设置$A_1=\min I_1=l_1$即可。接下来，对于$k\ge 2$，当$A_1,\dots ,A_{k-1}$确定后，我们考虑确定$A_k$。这里，在能使$|x-A_{k-1}|+f_k(x)$最小化的$x\in [L_k,R_k]$中，应选择最小的$A_k$。利用命题1.3进行计算，可以得出 A k = max ⁡ { min ⁡ { A k − 1 , r k } , L k } A_k=\max\lbrace\min\lbrace A_{k-1},r_k\rbrace,L_k\rbrace Ak​=max{min{Ak−1​,rk​},Lk​}。因此，我们可以按照$k$的升序确定每个$A_k$。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<LL> L(n), R(n);
    for (int i = 0; i < n; i++) cin >> L[i] >> R[i];
    vector<LL> l(n), r(n);
    l.back() = L.back(), r.back() = R.back();
    for (int i = n - 2; i >= 0; i--) {
        if (R[i] < l[i + 1]) {
            l[i] = r[i] = R[i];
        } else if (L[i] > r[i + 1]) {
            l[i] = r[i] = L[i];
        } else {
            l[i] = max(L[i], l[i + 1]);
            r[i] = min(R[i], r[i + 1]);
        }
    }
    vector<LL> a(n);
    a.front() = l.front();
    for (int i = 1; i < n; i++) {
        a[i] = std::clamp(a[i - 1], L[i], r[i]);
    }
    for (int i = 0; i < n; i++) {
        cout << a[i] << (i == n - 1 ? '\n' : ' ');
    }
    return 0;
}

D.LIS on Tree 2（LIS）

题意：

问题陈述

有一棵树，树上有$N$个顶点，编号为$1$至$N$。树的第$i$条边双向连接顶点$u_i$和$v_i$。

对于$(1,\dots ,N)$的排列$P=(P_1,\dots ,P_N)$，我们定义$f(P)$如下：

• 对于每个顶点$i(1\le i\le N)$，假设$(v_1=1,v_2,\dots ,v_k=i)$是顶点$1$到顶点$i$的简单路径，假设$L_i$是$(P_{v_1},P_{v_2},\dots ,P_{v_k})$的最长递增子序列的长度。我们定义$f(P)=\sum _{i=1}^N{L}_i$。

给你一个整数$K$。请判断是否存在$(1,\dots ,N)$的排列$P$使得$f(P)=K$。如果存在，请给出一个这样的排列。

分析：

首先，判断什么情况无解。记$s_i$为以$i$为根的子树大小，$p_i$为$i$的深度（$d_1=1$），显然有$k<n$或$k\le \sum p_i$时无解（因为有$1\le L_i\le d_i$）。以下将通过构造说明其他情况（$k\in [n,\sum p_i]$）都有解。

更改点$i$的$p_i$会造成很多点的$L_j$发生变化，所以这不太好考虑。

我们直接假设最终构造中每个点路径上的$LIS$一定是它父节点的$LIS$拼上（或不拼上）自己。这样如果$i$在$1$到$i$的路径的$LIS$上，$i$一定也在子树中所有点的$LIS$上，这个点就会对答案$f(p)$造成$s_i$的贡献；否则就造成$0$的贡献。

发现这变成了一个背包问题：我们需要选择若干个节点（$1$是必选）使得它们的贡献$s_i$加起来恰好为$k$。

注意到如果我们把$s_i$按从大到小排序，就有$s_i\le \sum s_j+1(j>i)$（因为一个点的子树大小就是它所有的儿子的子树大小和$+1$，那这个点最大也不过是比它小的所有点都是它的儿子），因此我们从大到小贪心，每次遇到$k\ge s_i$就可以从$k$中减掉$s_i$，剩下的部分一定可以在后面拼出。

好了，我们已经决定哪些点要造成贡献了，答案该怎么构造呢？

为了保证所有没取到的点一定不造成贡献，我们把所有没取到的点的权值设为比取到的点的权值小，这样就不会拼在已经形成的$LIS$的后面；为了保证没取到的点不会自己形成一段$LIS$，我们只要让所有没取到的点的权值都从根往下降序排列就行。同理，既然取到的点要形成$LIS$，那么这些点的权值就应该从根往下升序排列。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL N = 2e5 + 5;
LL k;
int sz[N];
vector<int> T[N];
pair<int, int> p[N];
int n;

void dfs(int x, int fa) {
    sz[x] = 1;
    for (int v: T[x]) {
        if (v != fa) {
            dfs(v, x);
            sz[x] += sz[v];
        }
    }
    p[x] = {-sz[x], x};
}

int vis[N], ans[N];
int tot = 0;

void dfs0(int x, int fa) {
    for (int v: T[x])
        if (v != fa)
            dfs0(v, x);
    if (!vis[x])
        ans[x] = ++tot;
}

void dfs1(int x, int fa) {
    if (vis[x])
        ans[x] = ++tot;
    for (int v: T[x])
        if (v != fa)
            dfs1(v, x);
}

int main() {
    cin >> n >> k;
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        T[u].push_back(v);
        T[v].push_back(u);
    }
    dfs(1, 0);
    LL sum = 0;
    for (int i = 1; i <= n; i++)
        sum += sz[i];
    if (k < n || k > sum) {
        cout << "No";
        return 0;
    }
    cout << "Yes" << endl;
    sort(p + 1, p + n + 1);
    for (int i = 1; i <= n; i++) {
        if (k + p[i].first >= 0) {
            vis[p[i].second] = 1;
            k += p[i].first;
        }
    }
    dfs0(1, 0);
    dfs1(1, 0);
    for (int i = 1; i <= n; i++)
        cout << ans[i] << " ";
    return 0;
}

赛后交流

在比赛结束后，会在交流群中给出比赛题解，同学们可以在赛后查看题解进行补题。

群号： 704572101，赛后大家可以一起交流做题思路，分享做题技巧，欢迎大家的加入。