牛客小白月赛 90 （全）

菜比乌斯反演

已于 2024-04-06 15:27:37 修改

阅读量483

点赞数 5

分类专栏：牛客文章标签：算法 c++ 数据结构贪心算法动态规划排序算法

于 2024-04-05 23:19:59 首次发布

本文链接：https://blog.youkuaiyun.com/2301_80105412/article/details/137411328

版权

牛客专栏收录该内容

16 篇文章

订阅专栏

文章描述了几道编程竞赛题目，涉及贪心算法、数组操作、线段树、优先队列等技术，展示了在解决不同难度问题时所用的不同策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

评价：

好像比上次月赛简单100倍。

A题：小A的文化节

签到题

#include <bits/stdc++.h>
using namespace std;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int n, m; cin >> n >> m;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i ++ ) cin >> a[i];
    int ans = 0;
    while (m -- ) {
        int op; cin >> op;
        ans += a[op];
    }
    cout << ans << endl;
    return 0;
}

B题：小A的游戏

记平局数量为c，小A赢了a局，小B赢了b局

题目输入的是x和y

那么 x = c + 3 * a , y = c + 3 * b

暴力想法肯定是枚举a算出c带入y

但是肯定会超时

我们这样做的目的只是在探求a和b之间的关系而已

所以不妨相减可得 y - x = 3 * (b - a)

b和a都是整数，所以y - x是3的倍数即可。

#include <bits/stdc++.h>
using namespace std;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int t; cin >> t;
    while (t -- ) {
        int x, y;
        cin >> x >> y;
        if (abs(x - y) % 3 == 0) cout << "Yes\n";
        else cout << "No\n";
    }
    return 0;
}

C题：小A的数字

贪心。

单拎出个位数的情况，根据题意，我们只要输出1即可。

否则判断是否出现过0

如果出现过0，那么之后的每一位上都要有数字。

可证为0时输出1，不为0时输出0时最小。

没有出现过0，那么只要输出个位数当作最小，判断最末尾的那一个数即可。

#include <bits/stdc++.h>
using namespace std;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int t; cin >> t;
    while (t -- ) {
        string s; cin >> s;
        if (s.size() == 1) {
            cout << 1 << endl;
            continue;
        }
        bool ok = false;
        for (int i = 0; i < s.size(); i ++ ) {
            if (ok && s[i] != '0') cout << 0;
            if (s[i] == '0') {
                ok = true;
                cout << 1;
            }
        }
        if (!ok) {
            if (s[s.size() - 1] == '1') cout << 2;
            else cout << 1;
        }
        cout << endl;
    }
    return 0;
}

D题：小A的线段（easy version）

显然暴力dfs，可以加上差分优化

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 9;
const int mod = 998244353;
int l[11], r[11], d[N];
int n, m;
ll ans;
inline void dfs(int u) {
    if (u == m + 1) {
        int pre[N] = {};
        for (int i = 1; i <= n; i ++ ) {
            pre[i] = pre[i - 1] + d[i];
            if (pre[i] < 2) return;
        }
        ans = (ans + 1) % mod;
        return;
    }
    d[l[u]] ++, d[r[u] + 1] --;
    dfs(u + 1);
    d[l[u]] --, d[r[u] + 1] ++;
    dfs(u + 1);
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= m; i ++ ) {
        cin >> l[i] >> r[i];
    }
    dfs(1);
    cout << ans << endl;
    return 0;
}

E题：小A的任务

贪心。如果我们完成了a个A任务(a >= k)，那么我们需要的是a个B任务中耗时间最小的k个，这可以通过优先队列实现。每次往里面加入一个，然后弹出最大的那一个。

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int n, q; cin >> n >> q;
    vector<ll> a(n + 1), b(n + 1);
    for (int i = 1; i <= n; i ++ ) {
        cin >> a[i];
        a[i] += a[i - 1];
    }
    for (int i = 1; i <= n; i ++ ) cin >> b[i];
    while (q -- ) {
        int k; cin >> k;
        priority_queue<int> heap;
        ll sum = 0, ans = 1e18;
        for (int i = 1; i <= n; i ++ ) {
            heap.push(b[i]);
            sum += b[i];
            if (heap.size() > k) sum -= heap.top(), heap.pop();
            if (heap.size() == k) ans = min(ans, sum + a[i]);
        }
        cout << ans << endl;
    }
    return 0;
}

F题：小A的线段（hard version）

#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
const int mod = 998244353;
PII p[210];
int dp[210][410][410];
inline void add(int &t, int d) {
    t += d;
    if (t >= mod) t -= mod;
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int n, m;
    cin >> n >> m;
    vector<int> d;
    for (int i = 1; i <= m; i ++ ) {
        int l, r;
        cin >> l >> r;
        l --;
        p[i] = {l, r};
        d.push_back(l), d.push_back(r);
    }
    d.push_back(0), d.push_back(n);
    sort(d.begin(), d.end());
    d.erase(unique(d.begin(), d.end()), d.end());
    n = d.size();
    sort(p + 1, p + 1 + m);
    for (int i = 1; i <= m; i ++ ) {
        p[i].first = lower_bound(d.begin(), d.end(), p[i].first) - d.begin();
        p[i].second = lower_bound(d.begin(), d.end(), p[i].second) - d.begin();
    }
    dp[0][0][0] = 1;
    for (int k = 1; k <= m; k ++ ) {
        for (int i = 0; i < n; i ++ ) {
            for (int j = i; j < n; j ++ ) {
                if (dp[k - 1][i][j] == 0) continue;
                add(dp[k][i][j], dp[k - 1][i][j]);
                if (p[k].first <= i) {
                    add(dp[k][max(i, min(j, p[k].second))][max(j, p[k].second)], dp[k - 1][i][j]);
                }
            }
        }
    }
    cout << dp[m][n - 1][n - 1] << endl;
    return 0;
}