牛客小白月赛98

比赛链接：https://ac.nowcoder.com/acm/contest/85598#question

骰子魔术

思路

看有没有骰子掷出的点数 $a_i$ 与朋友说的点数 $x$ 相等即可。

复杂度

时间复杂度 $O(n)$，空间复杂度 $O(1)$

代码实现

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        int x;
        cin >> x;
        if (x == m) {
            cout << "YES\n";
            return 0;
        }
    }
    cout << "NO";
}

最少剩几个？

思路

对于操作 $1$，$a_i+a_j$ 是奇数，那么 $a_i,a_j$ 必然是一偶一奇，意味着要删去 $x$ 个偶数就需要有 $x$ 个奇数与之匹配。
对应操作 $2$，$a_i+a_j$ 是奇数，那么 $a_i,a_j$ 必然都是奇数，意味着奇数可以两两消去。

令偶数数量为 $c_0$，奇数数量为 $c_1$。
因为偶数只有一种删除方法，所以优先删去偶数，而删去的偶数需要和奇数一一匹配，所以两者的数量减少了 $min(c_0,c_1)$。

然后就只剩奇数，因为奇数可以两两消去，如果剩余数量为偶数则可以消完，否则会剩下一个，因此将 $c_1$ 对 $2$ 取模即可。

复杂度

时间复杂度 $O(n)$，空间复杂度 $O(1)$

代码实现

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int c[2] = { 0 };
    for (int i = 1; i <= n; i++) {
        int x;
        cin >> x;
        c[x % 2]++;
    }
    int v = min(c[0], c[1]);
    c[0] -= v, c[1] -= v;
    //     奇偶一一匹配
    c[1] %= 2;
    //     奇数间两两消去
    cout << c[0] + c[1];
}

两个函数

思路

1，当 $x=1$ 时，直接输出 $a$ 即可。

2，当 $x>1$ 时， $g(x)=f(f(1))+f(f(2))+f(f(3))+...+f(f(x-1))=f(a)+f(2a)+f(3a)+...+f((x-1)a)=a^2+2a^2+3a^2+...+(x-1)a^2$。
提出公因子可得，$g(x)=(1+2+3+...+(x-1))a^2=\frac{(x-1)(1+x-1)}{2}\ast a^2=\frac{x(x-1)}{2}\ast a^2$。

综上，$g(x)=\{\begin{array}{l}a,x=1\\ \frac{x(x-1)}{2}\ast a^2,x>1\end{array}$，因为题目需要对 $mod=998244353$ 取模，所以计算 $\frac{1}{2}$ 需要求 $2$ 的逆元，用快速幂求 $2^{mod-2}$ 即可。

细节

注意，模数为 $998244353$，相乘操作可能会超过 $longlong$ 的数据范围，所以数据类型至少要用 $unsignedlonglong$ 计算。

复杂度

时间复杂度 $O(1)$，空间复杂度 $O(1)$

代码实现

#include <bits/stdc++.h>
using namespace std;

#define int long long

const int mod = 998244353;

unsigned long long qmi(unsigned long long a, int b)
{
    int res = 1;
    while (b) {
        if (b & 1)
            res = res * a % mod;
        b >>= 1;
        a = a * a % mod;
    }
    return res;
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int v = qmi(2, mod - 2);
    // 2的逆元,即模意义下的 1/2

    int T;
    cin >> T;
    while (T--) {
        int a, x;
        cin >> a >> x;
        if (x == 1) {
            cout << a % mod << '\n';
        } else {
            int ans = (unsigned long long)qmi(a, 2) * (x - 1) % mod * x % mod * v % mod;
            cout << ans << '\n';
        }
    }
}

切割 01 串 2.0

思路

注意到字符串的长度不大，上界为 $500$，且切割操作相当于分割区间，联想到可以用区间 $dp$ 解决问题。

状态表示

$f[l][r]$ 表示对区间 $[l,r]$ 的连续子串做切割操作能进行的最多次操作

初始化

默认为 $0$ 即可，表示没法操作

状态转移

对于区间 $[l,r]$，可以通过切割操作得到区间 $[l,k],[k+1][r]$，因此 $f[l][r]=max(f[l][k]+f[k+1][r]+1)(l\le k<r)$。

可以发现，长度大的区间 $[l,r]$ 是从长度小的区间 $[l,k],[k+1,r]$ 转移来的，所以按长度从小到大计算区间的对应值。

根据题目要求，$[l,k]$ 中 $0$ 出现的次数 $c_0$ 和 $[k+1,r]$ 中 $1$ 出现的次数 $c_1$，需要满足 $L\le |c_0-c_1|\le R$。

因为状态 $f[l][r]$ 的数量级为 $n^2$，每次枚举 $k$ 计算对应的 $f[l][r]$，总体的复杂度为 $O(n^3)$，而 $n$ 最大为 $500$，如果每次再遍历计算 $c_0,c_1$，复杂度近似 $O(n^4)$，显然会超时，所以需要对 $0,1$ 的数量进行前缀和预处理，这样就可以直接查询对应区间中 $0,1$ 的数量。

最后的答案为整个字符串即区间 $[l,r]$ 的最大切割次数，对应 $f[1][n]$ 。

复杂度

时间复杂度 $O(n^3)$，空间复杂度 $O(n^2)$

代码实现

#include <bits/stdc++.h>
using namespace std;

#define int long long

const int N = 505;

int n, L, R;
int a[N], b[N], f[N][N];
string str;

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    cin >> n >> L >> R >> str;
    str = ' ' + str;
    for (int i = 1; i <= n; i++) {
        a[i] = a[i - 1] + (str[i] == '0');
        b[i] = b[i - 1] + (str[i] == '1');
    }
    for (int i = 1; i <= n; i++) {
        for (int l = 1; l + i - 1 <= n; l++) {
            int r = l + i - 1;
            for (int k = l; k < r; k++) {
                int c0 = a[k] - a[l - 1];
                int c1 = b[r] - b[k];
                // 判断左侧子串和右侧子串0,1的差值是否满足条件
                if (L <= abs(c0 - c1) && abs(c0 - c1) <= R) {
                    f[l][r] = max(f[l][r], f[l][k] + f[k + 1][r] + 1);
                }
            }
        }
    }
    cout << f[1][n];
}

and xor or

思路

令 $f(l,r)=(a_l\&a_{l+1}\&...\&a_r)\oplus (a_l|a_{l+1}|...|a_r)$。

求满足 $2^{k_1}\le f(l,r)<2^{k_2}$ 的区间数量，相当于满足 $f(l,r)\ge 2^{k_1}$ 的区间数量减去满足 $f(l,r)\ge 2^{k_2}$ 的区间数量。

$2^k$ 转换为二进制为 $(\mathrm{1000....}{)}_2$，即除了从低到高第 $k$ 位为 $1$ 外，其他位都为 $0$，显然要不小于 $2^k$，需要在不小于 $k$ 位上的二进制位存在至少一个 $1$。

因为 $0\le a_i\le 10^{18}<2^{61}$，所以位数的上界为 $61$，因此 $f(l,r)$ 若满足上述条件，就需要在 $[k,61]$ 的二进制位上至少有一个 $1$。

考虑单独的一个二进制位，注意到 $f(l,r)$ 最后一步计算是异或 $\oplus$，如果计算结果为 $1$，由异或的性质可以得到 $(a_l\&a_{l+1}\&...\&a_r)$，$(a_l|a_{l+1}|...|a_r)$$ 这两个值其中一个为 $1$，另一个为 $0$。显然后者为 $0$，前者一定为 $0$，所以只需要考虑 $a_l\&a_{l+1}\&...\&a_r=0,a_l|a_{l+1}|...|a_r=1$ 的情况。

从小到大枚举区间右端点 $r$，当前在第 $j$ 位上，如果距离 $r$ 最近的 $1$ 下标为 $b_j$，最近的 $0$ 下标为 $c_j$，那么当 $l\in [1,c_j]$时， $a_l\&a_{l+1}\&...\&a_r=0$，当 $l\in [1,b_j]$ 时，$a_l|a_{l+1}|...|a_r=1$，因此，当 $l\in [1,b_j]\cup [1,c_j]=[1,min(b_j,c_j)]$ 时，$f(l,r)$ 在第 $j$ 位上存在 $1$。

因为在 $[k,61]$ 的二进制位上至少有一个 $1$ 即可满足条件，所以对于枚举的右端点 $r$，使得 $f(l,r)$ 满足条件的左端点的选择区间即为 $[1,max(min(b_j,c_j))](k\le j\le 61)$，满足 $f(l,r)\ge 2^k$ 的区间数量，即为所有的右端点 $r$ 所对应的左端点的选择区间的长度和。

通过上述做法即可求出满足 $f(l,r)\ge 2^{k_1}$ 的区间数量和满足 $f(l,r)\ge 2^{k_2}$ 的区间数量，两者相减即为答案。

复杂度

时间复杂度 $O(n\log n)$，空间复杂度 $O(\log n)$

代码实现

#include <bits/stdc++.h>
using namespace std;

#define int long long

const int N = 5e5 + 5, M = 62;

int n, k1, k2;
int a[N], b[M], c[M], f[N][M];

inline int ask(int bit)
{
    int res = 0;
    // 注意要把数组初始化
    for (int i = bit; i < M; i++) {
        b[i] = c[i] = 0;
    }
    for (int i = 1; i <= n; i++) {
        int r = 0;
        // 满足条件的左端点的可选最大区间[1,r]的右端点
        for (int j = bit; j < M; j++) {
            if ((a[i] >> j) & 1) {
                b[j] = i;
                // b[j] 为第j位上最接近的1的下标,如果当前下标为i时第j位为1则更新为i
            } else {
                c[j] = i;
                // 同理,如果当前下标为i时,第j位为0则最接近坐标更新为0
            }
            r = max(r, min(b[j], c[j]));
            // 在第j位上l的可选区间为[1,min(b[j],c[j])]
        }
        res += r;
    }
    return res;
}

signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    cin >> n >> k1 >> k2;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        for (int j = 0; j < M; j++) {
            f[i][j] = (a[i] >> j) & 1;
            f[i][j] += f[i - 1][j];
        }
    }
    int ans = ask(k1) - ask(k2);
    cout << ans << '\n';
}