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

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

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

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$，且区间的价值为:$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$和构造的区间长度$len$进行排序，并按最大的权值和最小的区间长度进行匹配，次大的权值和次小的区间长度进行匹配，依次类推，就能得到最小的价值之和。

代码：

#include

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$个数字的总和就是$x+m\times k$。

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

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

• $b_0=b_1+k=...=b_m+k$

• $b_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$

而此时所有的$b_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$所需的操作次数为$\frac{a_i-k}{G}-1$。

代码：

#include

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$。

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

分析：

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

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

代码：

#include

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,\dots ,a_n$，数据范围为$[0,n]$。

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

当$a_i\ne -1$时，在$[p_1,p2,\dots ,p_i]$中小于等于$i$的数的个数恰好为$a_i$。

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

分析：

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

• 若$a_i=a_{i+1}$，则$d{p}_i=d{p}_{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 

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)(数学)

分析：

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

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

因为有一些位置是$-1$，所以直接找到前一个限制的位置$las$。初始时，可以令$las=0$，$a_{las}=0$，上一个约束处是$las$，限制为$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}$。

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

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

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

代码：

#include 

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;
}

学习交流

​
以下为学习交流QQ群，群号： 546235402，每周题解完成后都会转发到群中，大家可以加群一起交流做题思路，分享做题技巧，欢迎大家的加入。
​