2023牛客暑假多校5 题解CDGH | JorbanS

$ref$

牛客暑假多校5出题人题解

繁凡【算法笔记】竞赛图（有向完全图）（相关题型总结）

C-Cheeeeen the Cute Cat

题意 给定一个 $2n$ 个节点、$\frac{n(n-1)}{2}$ 条边的二分图，保证：

1. $i$ 和 $i+n$ 之间没有边 $(1\le i\le n)$
2. 如果 $i$ 和 $j+n$ 之间有边那么 $i+n$ 和 $j$ 之间没有边 $(1\le i,j\le n)$

显然上述保证条件是为了满足竞赛图，将 $1,2,...,n$ 与 $n+1,n+2,...,2n$ 两两合并，会发现此时的条件 1 保证了没有自环，条件 2 保证了不存在重边。然后将无向边化成两条有向边，现在即有 $n$ 个节点、$n(n+1)$ 条边，即竞赛图。

哈密顿回路：从图中的一个顶点出发，每个顶点有且仅访问一次，再回到起点的一条回路

哈密顿路径：从图中的一个顶点出发，每个顶点有且仅访问一次，不要求起点和终点有一条路径

竞赛图：有向完全图，即每对顶点之间都有一条边相连的有向图

竞赛图的性质：

• 没有自环，没有二元环；若竞赛图存在环，则一定存在三元环（如果存在一个环大于三元，那么一定存在另一个三元的小环）
• 任意竞赛图都有哈密顿路径（经过每个点一次的路径，不要求回到出发点）
• 图存在哈密顿回路的充要条件是强联通
• 哈密顿问题中，对于 n 阶竞赛图，当 n 大于等于 2 时一定存在哈密顿通路
• 设 D 为 n 阶有向简单图，若 D 的基图为 n 阶无向完全图，则 D 为 n 阶竞赛图

简单来说，竞赛图就是将完全无向图的无向边给定了方向

兰道定理：用来判定竞赛图，竞赛图的每个点的出度从小到大排序后得到的序列称为竞赛图的比分序列

官方题解没看懂，后来牛客增强了数据，好多方法都被卡了，code 没写

官方题解：

D-Cirno’s Perfect Equation Class

题意 给定 $k,c,n$ 求满足 $ka+b=c$ 且 $gcd(a,b)\ge n$ 正整数的 $a,b$ 的有多少组

题解 暴力枚举 $b$ 计算 $a$，得出 $gcd(a,b)$ 判断

特别的，要注意 $gcd(0,x)=0,x\ne 0$，所以当 $a=0$ 或 $b=0$ 时，需要特判

#include <iostream>

using namespace std;
int k, c, n;

int gcd(int a, int b) {
    return b ? gcd(b, a % b) : a;
}

inline bool check(int b) {
    int a = (c - b) / k;
    if (a * k != c - b) return false;
    if (b && gcd(a, b) >= n) return true;
    return false;
}

int solve() {
    cin >> k >> c >> n;
    int res = 0;
    for (int b = 1; b <= c / b; b ++)
        if (c % b == 0) {
            if (check(b)) res ++;
            if (b * b != c && check(c / b)) res ++;
        }
    return res;
}

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

G-Go to Play Maimai DX

题意 给定一个序列，求最短区间使得 1, 2, 3, 4 都存在，且至少有 k 个 4

题解 滑动窗口维护

#include <iostream>
#include <deque>

using namespace std;
int n, k, cnt[5];

int solve() {
    cin >> n >> k;
    int res = n;
    deque<int> dq;
    while (n --) {
        int x; cin >> x;
        dq.push_back(x);
        cnt[x] ++;
        if (!cnt[1] || !cnt[2] || !cnt[3] || cnt[4] < k) continue;
        while (cnt[4] > k && dq.front() == 4 || cnt[dq.front()] > 1 && dq.front() < 4) {
            cnt[dq.front()] --;
            dq.pop_front();
        }
        res = min(res, (int)dq.size());
    }
    return res;
}

int main() {
    cout << solve() << endl;
    return 0;
}

H-Nazrin the Greeeeeedy Mouse

题意 $n$ 个奶酪（每个体积为 $v[i]$，价值为 $w[i]$），$m$ 个背包（体积分别为 $sz[i]$，且非严格递增），按顺序用背包拿奶酪，每次只能拿上次拿过的奶酪的右侧的奶酪，求最大价值

Tag 背包 dp

状态表示

$f[i][j][k]$ 表示区间 $[i,j]$ 上背包大小为 $k$ 时能获得的最大奶酪价值

$g[k][i]$ 表示使用前 $k$ 个背包取前 $i$ 个奶酪能获得的最大奶酪价值

#include <iostream>

using namespace std;
const int N = 202;
int n, m, v[N], w[N], sz[N];
int f[N][N][N], g[N][N];

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i ++) cin >> v[i] >> w[i];
    // 只读入最后 min(m, n) 个背包，因为背包 size 大小递增，最多只能用 min(m, n) 次，贪心取最后的
    for (int i = 1; i <= m - n; i ++) scanf("%*d");
    for (int i = 1; i <= min(m, n); i ++) cin >> sz[i];
    // 预处理 f[i][j][k]，01 背包
    for (int i = 1; i <= n; i ++) {
        for (int j = i; j <= n; j ++) {
            for (int k = 0; k <= 200; k ++) {
                f[i][j][k] = f[i][j - 1][k];
                if (k >= v[j])
                    f[i][j][k] = max(f[i][j][k], f[i][j - 1][k - v[j]] + w[j]);
            }
        }
    }
    int res = 0;
    // k 表示第几个背包
    for (int k = 1; k <= min(m, n); k ++) {
        for (int i = 1; i <= n; i ++)
            for (int j = 0; j < i; j ++)
                // 从 k - 1 转移到 k，枚举 j 从 0 ~ i - 1，加上 j + 1 ~ i 区间 sz[k] 大小的背包能容纳的最大价值
                g[k][i] = max(g[k][i], g[k - 1][j] + f[j + 1][i][sz[k]]);
        res = max(res, g[k][n]);
    }
    cout << res << endl;
    return 0;
}