AtCoder Regular Contest 116 补题(C、D、E)

C - Multiple Sequences

题意：

给定数字\(N\)和\(M\)，问有多少个长度为\(N\)的序列，满足\(1≤A_i≤M\)，且\(A_{i+1}\)是\(A_{i}\)的倍数

思路：

由于序列是成倍变大的，所以序列肯定是一个非严格单调递增的序列，那么可以枚举最后一个数\(A_n\)，通过递推可知，前面的数都是\(A_n\)的约数，所以就相当于将\(A_n\)的质因数拆解后，往前面\(n-1\)个空放，对于每个因子来说都是独立的，所以质因数分解后，当前这个因子就是\(p_i^{c_i}\)，当前因子为\(c_i\)，由于因子是可不选的，所以相当于有\(n\)个空(\(1\)个是用来代表空放的)，有\(c\)个球，所以放的方案数就是\({n+c-1\choose{n-1}}\),对于当前枚举的数，\(\prod \limits_{i=1}^{n}{n+c_i-1\choose{n-1}}\)，然后把所有枚举的情况累加即答案

View Code

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 4e5 + 10;
const int mod = 998244353;
int fact[N], infact[N];
int n, m;
int lowbit(int x) { return x & -x; }
int qmi(int a, int k) {
    int res = 1;
    while (k) {
        if (k & 1) res = res * a % mod;
        k >>= 1;
        a = a * a % mod;
    }
    return res;
}
void init() {
    fact[0] = infact[0] = 1;
    for (int i = 1; i < N; i++) {
        fact[i] = fact[i - 1] * i % mod;
    }
    infact[N - 1] = qmi(fact[N - 1], mod - 2) % mod;
    for (int i = N - 2; i >= 1; i--) {
        infact[i] = infact[i + 1] * (i + 1) % mod;
    }
}

int C(int n, int m) {
    if (m > n) return 0;
    return fact[n] * infact[m] % mod * infact[n - m] % mod;
}
signed main() {
    init();
    cin >> n >> m;
    int res = 0;
    for (int i = 1; i <= m; i++) {
        int now = i;
        int temp = 1;
        for (int j = 2; j <= now / j; j++) {
            if (now % j == 0) {
                int cnt = 0;
                while (now % j == 0) {
                    now /= j;
                    cnt++;
                }
                temp = temp * C(n + cnt - 1, n - 1) % mod;
                temp %= mod;
            }
        }
        if (now > 1) temp = temp * C(n, n - 1) % mod;
        temp %= mod;
        res = (res + temp) % mod;
    }
    cout << res << endl;
}

D - I Wanna Win The Game

题意：

给定\(N\)和\(M\)，现在问你有多少个序列满足下面的条件。\(A_i>=0\)，\(\sum \limits_{i=1} ^{n}A_i=M\),\(A_1 xor A_2 xor A_3.....A_n=0\)

思路：

有异或操作，考虑将\(M\)分解成二进制\(01\)数来考虑，由于所有数的异或和为\(0\)，则说明对于\(M\)的每一位，都必须要有偶数个\(1\)，保证异或为\(0\)，那么对于每一位就可以考虑有多少个\(1\)，每一位有\(2,2×2，2×3....2×k\)个1，也就是说每一位的大小都可以是\(2×2^i,4×2^i....2×k×2^i\),这就相当于是分组背包，每个组可以挑选体积为\(2×k×2^i\)的物品，此时定义\(f(i,j)\)定义为考虑\(M\)分解成二进制后的前\(i\)位，体积为\(j\)的方案数，那么最终答案就是\(f(log_{2}M,M)\)，转移方程为\(f(i,j)=f(i,j)+f(i-1,j-2×k×2^i)×{n\choose{2k}}\),相当于选出这些\(1\)后，分给\(n\)个空，方程可以优化前一维，最终输出\(f(M)\)就是答案

View Code

#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N = 5010;
const int mod = 998244353;

int fact[N], infact[N];
int n, m;
int f[N];
int qmi(int a, int k) {
    int res = 1;
    while (k) {
        if (k & 1) res = res * a % mod;
        k >>= 1;
        a = a * a % mod;
    }
    return res;
}
void init() {
    fact[0] = infact[0] = 1;
    for (int i = 1; i < N; i++) {
        fact[i] = fact[i - 1] * i % mod;
    }
    infact[N - 1] = qmi(fact[N - 1], mod - 2) % mod;
    for (int i = N - 2; i >= 1; i--) {
        infact[i] = infact[i + 1] * (i + 1) % mod;
    }
}
int C(int n, int m) {
    if (m > n) return 0;
    return fact[n] * infact[m] % mod * infact[n - m] % mod;
}
signed main() {
    init();
    cin >> n >> m;
    f[0] = 1;

    for (int i = 0; (1 << i) <= m; i++) {
        for (int j = m; j >= 0; j--) {
            for (int k = 1; 2 * k * (1 << i) <= j; k++) {
                if (j >= 2 * k * (1 << i)) {
                    f[j] += f[j - 2 * k * (1 << i)] * C(n, 2 * k) % mod;
                    f[j] %= mod;
                }
            }
        }
    }
    cout << f[m] << endl;
}

E - Spread of Information

题意：

给定\(N\)个点的的树，现在可以选\(K\)个点感染病毒，病毒以每秒一个点的速度向周边感染，问通过放置病毒，感染整棵树的最短时间为多少？

思路：

可以先把问题转换成给定时间\(X\)，来感染全图，最少需要多少病毒？可以发现时间是具有单调性的，所以是可以二分的，所以解决上面的问题，时间就可以用二分来枚举出来。给定时间来算感染全图需要的最少病毒数量，可以通过类树形\(dp\)搜索来解决
定义\(f(u)\)为在以\(u\)为子树的结点中，离它最近病毒的距离
\(g(u)\)在以\(u\)为子树的结点中，离它最远的未被感染的结点的距离
若\(f(u)+g(u)<=x\)，说明以\(u\)为子树的所有结点都被感染了，所以当前点也会被感染，所以\(g(u)=-inf\)
若\(g(u)=x\)，距离当前点最远的未被感染的点的距离已经到了\(x\)，此时不放病毒的话，就会导致那个最远的点在限定时间内被感染，所以当前点必须被感染，\(f(u)=0,g(u)=-inf,res++\)
最后回溯到根节点\(1\),若\(g(1)≥0\)的话，说明病毒还没在时间内感染根结点，必须在根节点放置一个病毒

View Code

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int inf = 0x3f3f3f3f;
#define int long long
vector<int> e[N];
int n, k;
int f[N], g[N];
int res;
void dfs(int u, int fa, int limit) {
    f[u] = inf, g[u] = 0;
    for (auto v : e[u]) {
        if (v == fa) continue;
        dfs(v, u, limit);
        f[u] = min(f[u], f[v] + 1);
        g[u] = max(g[u], g[v] + 1);
    }
    if (f[u] + g[u] <= limit) {
        g[u] = -inf;
    } else if (g[u] == limit) {
        f[u] = 0, g[u] = -inf;
        res++;
    }
}
bool check(int x) {
    res = 0;
    dfs(1, -1, x);
    if (g[1] >= 0) res++;
    return res <= k;
}
signed main() {
    cin >> n >> k;
    for (int i = 1, u, v; i < n; i++) {
        cin >> u >> v;
        e[u].push_back(v);
        e[v].push_back(u);
    }

    int l = 0, r = n;
    while (l < r) {
        int mid = (l + r) >> 1;
        if (check(mid)) {
            r = mid;
        } else {
            l = mid + 1;
        }
    }
    cout << l << endl;
}