Codeforces Pinely Round 3 (Div. 1 + Div. 2) A~F

原创已于 2023-12-27 10:30:45 修改 · 940 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #codeforces #OI

于 2023-12-27 10:08:05 首次发布

codeforces题解专栏收录该内容

101 篇文章

订阅专栏

A.Distinct Buttons(思维)

题意：

你在开始时站在点 $(0, 0)$ ，同时，手上有一个遥控器，上面有四个按钮：

U:移动到 $(x, y + 1)$ 的位置
R:移动到 $(x + 1, y)$ 的位置
D:移动到 $(x, y - 1)$ 的位置
L:移动到 $(x - 1, y)$ 的位置

如果四个按钮都被按下过，那么遥控器将会被损坏，问能否到达给出的所有 $n$ 个点。

分析：

如果只能使用三个按键，那么只有在需要到达的所有点均在以下四个面中的一个时才能完成：

所有点都在 $x$ 轴上方
所有点都在 $x$ 轴下方
所有点都在 $y$ 轴左侧
所有点都在 $y$ 轴右侧

输入时使用数组记录出现的位置，最后判断输出即可。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

void solve() {
    int n;
    cin >> n;
    int a[5] = {0, 0, 0, 0};
    for (int i = 0; i < n; i++) {
        int x, y;
        cin >> x >> y;
        if (x > 0) {
            a[0] = 1;
        } else if (x < 0) {
            a[1] = 1;
        }
        if (y > 0) {
            a[2] = 1;
        } else if (y < 0) {
            a[3] = 1;
        }
    }
    if (a[0] + a[1] + a[2] + a[3] > 3) cout << "No" << endl;
    else cout << "Yes" << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

B.Make Almost Equal With Mod(思维)

题意：

给出一个数组 $a_1, a_2, ..., a_n$ ，你可以选择一个数字 $k$ ，使数组中所有数字对 $k$ 取模，问 $k$ 等于多少时，可以使得数组中的数字再操作后恰好包含两种不同的数字。

分析：

依次枚举 $2$ 的次方数即可。

说明：

选择 $2$ 作为 $k$ 时，剩下的结果仅包含 $0, 1$
如果剩下的数字全部为 $0$ 或 $1$ ，继续选择 $2^2 = 4$ 作为 $k$ ，若选择 $2$ 时剩下的数字为 $0$ ，那么选择 $k = 4$ 时剩下的就是 $0, 2$ ，同理，剩下数字均为 $1$ ，则选择 $k = 4$ 时剩下的数字就是 $1, 3$ 。
依此类推，由于每次取模的结果只会有两种可能性，那么当结果中两种情况均出现就找到了合法的 $k$ 。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

LL a[MAXN];

void solve() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (LL i = 2; ; i <<= 1) {
        set<LL> S;
        for (int j = 1; j <= n; j++) {
            S.insert(a[j] % i);
            if (S.size() > 2) break;
        }
        if (S.size() == 2) {
            cout << i << endl;
            return;
        }
    }
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

C.Heavy Intervals(思维)

题意：

给出 $n$ 个区间 $l_i, r_i]$ ，每个区间包含一个权值 $c_i$ ，且区间的价值为: $ci×(ri−li)c_i \times (r_i - l_i)$ ，你可以在保证区间合法 $l_i < r_i)$ 的情况下，对所有区间的 $l_i, r_i, c_i$ 进行任意重排，问所有区间的价值之和最小是多少？

分析：

既然要让价值之和最小，那么大的权值 $c_i$ 就要与长度更小的区间匹配，那要怎么在保证区间合法的情况下，让构造的区间尽可能长呢？

可以使用类似括号匹配的思想，先对 $l_i$ 和 $r_i$ 进行排序，把 $l_i$ 和 $r_i$ 视为左右括号进行括号匹配，并将构造成的区间长度记录下来。

完成匹配后，对权值 $c_i$ 和构造的区间长度 $l e n$ 进行排序，并按最大的权值和最小的区间长度进行匹配，次大的权值和次小的区间长度进行匹配，依次类推，就能得到最小的价值之和。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

LL l[MAXN], r[MAXN], c[MAXN], len[MAXN];

stack<int> st;

void solve() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> l[i];
    }
    for (int i = 0; i < n; i++) {
        cin >> r[i];
    }
    for (int i = 0; i < n; i++) {
        cin >> c[i];
    }
    sort(l, l + n);
    sort(r, r + n);
    sort(c, c + n);
    int pos_l = 0, pos_r = 0, cnt = 0;
    for (int i = 0; i < n * 2; i++) {
        if (pos_l < n && pos_r < n) {
            if (l[pos_l] < r[pos_r]) {
                st.push(l[pos_l++]);
            } else {
                len[cnt++] = r[pos_r++] - st.top();
                st.pop();
            }
        } else {
            len[cnt++] = r[pos_r++] - st.top();
            st.pop();
        }
    }
    LL ans = 0;
    sort(len, len + n);
    for (int i = 0, j = n - 1; i < n; i++, j--) {
        ans += len[i] * c[j];
    }
    cout << ans << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

D.Split Plus K(思维)

题意：

给出 $n$ 个正整数 $a_1, a_2, ..., a_n$ ，你可以进行若干次以下操作：

选择一个数字 $x$ ，并将这个数字删除。
选择两个正整数 $y, z$ 满足 $y + z = x + k$ ，并将这两个数字放回。

问：能否在经过若干次操作后，使数组中所有数字相同，如果可以，输出最少操作次数，否则，输出-1.

分析：

由于每次产生的两个数字 $y, z$ 的总和会比原本的数字 $x$ 大 $k$ ，因此，如果一个数字被分解了 $m$ 次，那么得到的 $m + 1$ 个数字的总和就是 $\times k$ 。

令 $b_0, b_1, ..., b_m$ 为最后生成的 $m + 1$ 个数字，由于分解时会增加 $k$ ，且会增加 $m$ 次，那么可以将 $m$ 个 $k$ 分配给 $b1∼bmb_1 \sim b_m$ ，即最后生成的数字为 $b_0, b_1 + k, b_2 + k, ..., b_m + k$ 。

由题目可得以下两个式子：

$b_0 = b_1 + k = ... = b_m + k$
$b0+(b1+k)+...+(bm+k)=ai+m×kb_0 + (b_1 + k) + ... + (b_m + k) = a_i + m \times k$

由于无法知道最后分解出的数字数量 $m$ 到底是多少，因此需要对式子进行化简，让第二个式子两边同时减去 $m + 1$ 个 $k$ ，可得：

$b_0 - k = b_1 = ... = b_m$
$b_0 - k) + b_1 + ... + b_m = a_i - k$

而此时所有的 $b1∼bmb_1 \sim b_m$ 以及 $b_0 - k$ 均为 $a_i - k$ 的因子，因此，可以在输入后，将所有 $a_i$ 均减去 $k$ 。

然后，需要考虑，如果减去 $k$ 后的 $a$ 数组中出现了同时包含正负数或同时出现 $0$ 和其他数字，此时是无法完成构造的，直接输出 $- 1$ 。

最后考虑最后生成的数字，既然要让操作次数尽可能少，那么拆出的数字就要尽可能大，怎么选择最大的结果呢？只有选择减去 $k$ 之后的所有 $a_i - k$ 的最大公约数 $G$ 。

由于每次操作会增加一个数字，因此，将 $a_i - k$ 分解为若干个 $G$ 所需的操作次数为 $ai−kG−1\frac{a_i - k}{G} - 1$ 。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

LL n, k, a[MAXN];

void solve() {
    cin >> n >> k;
    LL maxn = -1e18, minn = 1e18;
    for (int i = 1; i <= n; i++) cin >> a[i], a[i] -= k, maxn = max(maxn, a[i]), minn = min(minn, a[i]);
    if (maxn == minn) {
        cout << 0 << endl;
        return;
    }
    if (minn < 0 && maxn >= 0 || minn == 0 && maxn > 0) {
        cout << "-1" << endl;
        return;
    }
    LL g = a[1];
    for (int i = 2; i <= n; i++) g = __gcd(g, a[i]);
    LL ans = 0;
    for (int i = 1; i <= n; i++) {
        ans += a[i] / g - 1;
    }
    cout << ans << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

E.Multiple Lamps(二进制)

题意：

现有 $n$ 盏灯，编号为 $1$ 到 $n$ 。一开始，所有的灯都是关闭的。

有 $n$ 个按钮。第 $i$ 个按钮控制所有编号为 $i$ 的倍数的灯。当一个灯其对应的按钮被使用时，如果它是关闭的，它将打开；如果它是打开的，它将关闭。

必须按照以下规则按一些按钮：

至少要按一个按钮。
不能多次按同一按钮。
有 $m$ 个数对 $u_i,v_i)$ ，如果按下按钮 $u_i$ ，必须同时按下按钮 $v_i$ （不一定是在按下按钮 $u_i$ 之后）。如果按下按钮 $v_i$ ，则不需要按按钮 $u_i$ 。

为了环保，请按下一些按钮，使其最后最多点亮 $⌊n5⌋⌊\frac{n}{5}⌋$ 盏灯，否则输出 $- 1$ 。

分析：

如果按下所有的按钮，灯 $i$ 就会被 $i$ 的所有因数各操作一次，所以如果 $i$ 有奇数个因数，灯 $i$ 最终就会是亮的。对于这种情况，当 $⌊n⌋≤⌊n/5⌋⌊\sqrt{n}⌋ \le ⌊n/5⌋$ ，即当 $\le n$ 时，按下所有按钮即可。

当 $\le 19$ 时，最多打开 $⌊195⌋=3⌊\frac{19}{5}⌋=3$ 盏灯。可以从 $1$ 到 $n$ 遍历按钮，当且仅当灯 $i$ 处于错误状态时按下按钮 $i$ 。最多会遍历 $3$ 个灯的所有子集，并检查相应的按钮选择是否有效(即 $m$ 约束成立)。可以通过打表预处理出来，然后进行 $c h ec k$ 。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 2e5 + 5;
vector<int> arr[20];
int st[20];
int n, m;
int a[MAXN], b[MAXN];

int lowbit(int x) {
    return x & (-x);
}

void init() {
    for (int i = 5; i <= 19; i++) {
        for (int j = 1; j < (1 << i); j++) {
            for (int k = j; k; k ^= lowbit(k)) {
                int x = __builtin_ctz(k) + 1;
                for (int y = x; y <= i; y += x)
                    st[y] ^= 1;
            }
            int sum = 0;
            for (int k = 1; k <= i; k++) {
                sum += st[k], st[k] = 0;
            }
            if (sum * 5 <= i)
                arr[i].push_back(j);
        }
    }
}

bool solve() {
    for (int i: arr[n]) {
        i <<= 1;
        bool f = 0;
        for (int j = 1; j <= m; j++) {
            f |= (i & (1 << a[j])) && !(i & (1 << b[j]));
        }
        if (f)
            continue;
        cout << __builtin_popcount(i) << endl;
        while (i) {
            cout << __builtin_ctz(i) << ' ';
            i ^= lowbit(i);
        }
        cout << endl;
        return 1;
    }
    return 0;
}

int main() {
    init();
    int T;
    cin >> T;
    while (T--) {
        cin >> n >> m;
        for (int i = 1; i <= m; i++) {
            cin >> a[i] >> b[i];
        }
        if (n >= 20) {
            cout << n << endl;
            for (int i = 1; i <= n; i++)
                cout << i << ' ';
            cout << endl;
            continue;
        }
        if (!solve())
            cout << "-1" << endl;
    }
}

F1.Small Permutation Problem(Easy Version)(DP)

题意：

给定一个整数 $n$ 和一个数组 $a_1,a_2,…,a_n$ ，数据范围为 $[0, n]$ 。

对于每个 $i$ ，若满足以下条件，则 $p_1,p_2,…,p_n([1,2,…,n])$ 是一个好的排列：

当 $a_i≠−1$ 时，在 $p_1,p2,…,p_i]$ 中小于等于 $i$ 的数的个数恰好为 $a_i$ 。

计算 $[1, 2, \dots, n]$ 中好的排列的个数，结果对 $998244353$ 取模。

分析：

本题为动态规划的思想，设 $dp_i$ 表示前 $i$ 个位置填充了 $a_i$ 个小于等于 $i$ 的元素的方案数量。因为 $a_i$ 和 $a_{i-1}$ 的关系只有可能为 $0, 1, 2$ 。故本题总共可分为三种情况讨论：

若 $a_i=a_{i+1}$ ，则 $dp_i=dp_{i+1}$
若 $a_i=a_{i+1}+1$ ，则需要填入一个小于等于 $i$ 的数字，有两种方案：方案1：在前 $i$ 个位置填入 $i$ 数字，可以填入的方法有 $i-1)-a_{i-1}+1$ ；方案2：在第 $i$ 个位置填写一个小于 $i$ 的数字，可以将 $i$ 或者之前未填写的小于等于 $i$ 的数字填入，可以填入的数字有 $i-1-a_{i-1}$ 个
若 $a_i=a_{i+1}+2$ ，则需要在前 $i - 1$ 个位置放数字 $i$ ，在第 $i$ 个位置放一个小于 $i$ 的数字

将上述三种情况分别考虑，遍历即可获得答案，注意需要特判 $a_n$ ，若不为 $n$ ，则直接输出 $0$ 。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const LL MOD = 998244353;

int n;
LL a[200010];

void solve() {
    cin >> n;
    for (int i = 1; i < n + 1; i++) {
        cin >> a[i];
    }
    if (a[1] > 1) {
        printf("0\n");
        return;
    }
    vector<LL> dp(n + 1, 0);
    dp[1] = 1;

    for (int i = 2; i < n + 1; i++) {
        if (a[i] == a[i - 1]) {
            dp[i] = dp[i - 1];
        } else if (a[i] == a[i - 1] + 1 and a[i] <= i) {
            (dp[i] += dp[i - 1] * ((i - 1) - a[i - 1] + 1)) %= MOD;
            (dp[i] += dp[i - 1] * ((i - 1) - a[i - 1])) %= MOD;
        } else if (a[i] == a[i - 1] + 2 and a[i] <= i) {
            (dp[i] += dp[i - 1] * ((i - 1) - a[i - 1]) % MOD * ((i - 1) - a[i - 1]) % MOD) %= MOD;
        }
    }
    if (a[n] == n) {
        cout << dp[n] << endl;
    } else {
        cout << 0 << endl;
    }
}

int main() {
    int t;
    cin >> t;
    while (t--)
        solve();
    return 0;
}

F2.Small Permutation Problem(Hard Version)(数学)

分析：

对于 $F 2$ ：将题目的点想象成一个 $\times n$ 的图，排列中第 $i$ 个数为 $p_i$ 时，即可视为选中了 $i,p_i)$ 这个点。

题目条件对 $a_i$ 的限制，就可以看成是在左上角 $\times i$ 的矩阵中，选了 $a_i$ 个点

因为有一些位置是 $- 1$ ，所以直接找到前一个限制的位置 $l a s$ 。初始时，可以令 $l a s = 0$ ， $a_{las}=0$ ，上一个约束处是 $l a s$ ，限制为 $a_{las}$ 。当前约束处是 $i$ ，限制为 $a_i$ 。

这样处理后可以发现出现一个 $L$ 形区域可以选点，这部分需要选 $v=a_i-a_{las}$ 个点，

如图， $w_1=i-las$ ， $h_1=las-a_{las}$ ， $h_2=i-las$ ， $w_2=i-a_{las}$ 。

枚举 $w1×h1w_1 \times h_1$ 这个矩阵中，选了 $k$ 个点，这 $k$ 个点选了之后，同行同列不能再选点。

那么对于下面的部分就还剩 $h2×(w2−k)h_2 \times (w_2-k)$ 这个矩阵，需要选剩下的 $v - k$ 个点，可以从 $0$ 枚举到 $a_i-a_{las}$ 枚举这个 $k$ ，因为邻相差之和最终等于 $n$ ，所以复杂度是 $O (n)$

对于一个 $\times w$ 的矩阵，在其中选择 $k$ 个点的方案是： $\times C(w,k) \times k!$ ，即先选择 $k$ 个横坐标在哪，再选择 $k$ 个纵坐标在哪，再将纵坐标顺序打乱拼到横坐标上。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

const int MAXN = 2e5 + 5;
const LL MOD = 998244353;

inline LL qpow(LL b, LL p) {
    LL res = 1;
    while (p) {
        if (p & 1) {
            res = res * b % MOD;
        }
        b = b * b % MOD;
        p >>= 1;
    }
    return res;
}

LL n, fac[MAXN], a[MAXN], ifac[MAXN];

LL A(LL n, LL m) {
    if (n < m || n < 0 || m < 0) {
        return 0;
    } else {
        return fac[n] * ifac[n - m] % MOD;
    }
}

LL C(LL n, LL m) {
    if (n < m || n < 0 || m < 0) {
        return 0;
    } else {
        return fac[n] * ifac[m] % MOD * ifac[n - m] % MOD;
    }
}

LL sum1(LL n, LL m) {
    return C(n, m) * A(n, m) % MOD;
}

void solve() {
    cin >> n;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    fac[0] = 1;
    for (int i = 1; i <= n; ++i) {
        fac[i] = fac[i - 1] * i % MOD;
    }
    ifac[n] = qpow(fac[n], MOD - 2);
    for (int i = n - 1; ~i; --i) {
        ifac[i] = ifac[i + 1] * (i + 1) % MOD;
    }
    a[0] = 0;
    if (a[n] != -1 && a[n] != n) {
        cout << "0" << endl;
        return;
    }
    a[n] = n;
    int j = 0;
    LL ans = 1;
    for (int i = 1; i <= n; ++i) {
        if (a[i] != -1) {
            int t = a[i] - a[j], x = j - a[j], y = i - a[j];
            if (t < 0) {
                cout << "0" << endl;
                return;
            }
            LL res = 0;
            for (int i = 0; i <= x && i <= t; ++i) {
                res = (res + ((i & 1) ? MOD - 1 : 1) * sum1(x, i) % MOD * sum1(y - i, t - i)) % MOD;
            }
            ans = ans * res % MOD;
            j = i;
        }
    }
    cout << ans << endl;
}

int main() {
    int T;
    cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}