2021牛客寒假算法基础集训营4 ABEFGHJ题解

最新推荐文章于 2022-01-27 09:35:23 发布
最新推荐文章于 2022-01-27 09:35:23 发布
阅读量469 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kaka03200/article/details/113891964
版权

链接：https://ac.nowcoder.com/acm/contest/9984#question

目录


听完雨巨的分析后豁然开朗许多%%%， 感觉自己又行了 。

A 九峰与签到题（签到）

注意一下任意时间的意思，即每个时间都要满足才行

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define fi first
#define se second
#define il inline
#define re register
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
const int N = 5e5 + 10;
const int M = 5e5 + 10;
const ll INF = 1e18;
const double eps = 1e-5;
const int MOD = 1e9;
int vis[N];
void solve() {
    int n, m; cin >> n >> m;
    map<int, int> mp1; map<int, int> mp2;
    vector<int> ans;
    for (int i = 1; i <= n; i++) {
        int opt;
        string s;
        cin >> opt >> s;
        mp1[opt]++;
        if (s == "AC") mp2[opt]++;
        if (mp1[opt] > 2 * mp2[opt]) {
            vis[opt] = 1;
        }
    }
    int f = 0;
    for (int i = 1; i <= 20; i++) {
        if (!vis[i] && mp1[i]) {
            printf("%d ", i);
            f = 1;
        }
    }
    if (!f) printf("-1\n");
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

B 武辰延的字符串（二分+字符串哈希）

有两个串s和t，我们现在要两个s的前缀拼出t的前缀，最普通的方法就是O2 的暴力枚举，考虑怎么去减少枚举，那自然就是二分了。

先用字符串哈希O(N)处理好两个字符串，然后枚举第一个前缀，我们用二分找第二个前缀最多可以匹配到多少长度为止，因为确定第一个前缀后，方案数就是第二个前缀最长匹配长度。

然后不断枚举第一个前缀，直到失配退出，把结果相加就可以啦。

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define fi first
#define se second
#define il inline
#define re register
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
const int N = 2e5 + 10;
const int M = 5e5 + 10;
const ll INF = 1e18;
const double eps = 1e-5;
const int MOD = 1e9 + 7;
ull f1[N], f2[N], p[N];
char s1[N], s2[N];
int n, m;
ull Get(ull *f, int l, int r) {
    return f[r] - f[l-1] * p[r - l + 1];
}

unordered_map<ull, int> mp;
void solve() {
    scanf("%s", s1+1);
    scanf("%s", s2+1);
    n = strlen(s1+1); m = strlen(s2+1);
    p[0] = 1;
    for (int i = 1; i <= n; i++) {
        f1[i] = f1[i-1] * 1331 + (s1[i] - 'a' + 1);
        mp[f1[i]] = 1;
        p[i] = p[i-1] * 1331;
    }
    for (int i = 1; i <= m; i++) {
        f2[i] = f2[i-1] * 1331 + (s2[i] - 'a' + 1);
    }
    ll ans = 0;
    for (int i = 1; i <= m; i++) {
        if (s1[i] != s2[i]) break;
        int l = i+1, r = m;
        while (l <= r) {
            int mid = (l + r) >> 1;
            if (mp[Get(f2, i+1, mid)]) l = mid + 1;
            else r = mid - 1;
        }
        ans += (r - i);
    }
    cout << ans << endl;
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

E 九峰与子序列（DP+字符串哈希 | 暴力）

有点像背包的题目，但多了一个判断能不能取的条件
写出状态：f[i][j]代表前i个字符串匹配到前j个位置有多少方案
列出转移方程：f[i][j] = f[i-1][j] + f[i-1][j-len] * (hash[j-len+1, j] == 串i)
但这样会mle，所以用滚动数组优化一下就好了

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define fi first
#define se second
#define il inline
#define re register
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
const int N = 5e6 + 10;
const int M = 5e5 + 10;
const ll INF = 1e18;
const double eps = 1e-5;
const int MOD = 1e9 + 7;
char s1[N], s2[N];
ull f[N], p[N];
ll dp[N];
ull Get(int l, int r) {
    return f[r] - f[l-1] * p[r - l + 1];
}
void solve() {
    int n, len; cin >> n >> s1+1;
    len = strlen(s1+1);
    p[0] = 1;
    for (int i = 1; i <= len; i++) {
        f[i] = f[i-1] * 1331 + (s1[i] - 'a' + 1);
        p[i] = p[i-1] * 1331;
    }
    dp[0] = 1;
    for (int i = 1; i <= n; i++) {
        cin >> s2 + 1;
        int l = strlen(s2+1);
        ull tmp = 0;
        for (int j = 1; j <= l; j++) tmp = tmp * 1331 + (s2[j] - 'a' + 1);
        for (int j = len; j >= l; j--) {
            dp[j] += dp[j-l] * (Get(j-l+1, j) == tmp);
        }
    }
    cout << dp[len] << endl;
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

F 魏迟燕的自走棋（贪心+并查集）

和之前牛客多校的一道签到题很像，当时是用HK冲过去的，std应该是并查集。

这题也是用并查集维护，思维非常巧妙。

我们将每个人看成一个点，武器的能力值抽象成边，这样就转化成图论的模型了。

我们从联通块角度去看，如果一个联通块还没有形成环，那么他们之间的武器是可以互相换的，即他们当中的任意点都可以拥有新武器，我们称这个联通块没有饱和。反之，如果联通块内有环，那么这个块中的点都不能再拥有别的武器了我们称这个联通块饱和。

接下来我们分类讨论一下所有询问的情况：

  1. 两个点属于同一个联通块，如果这个联通块是饱和的，就略过；如果这个联通块不饱和，就加上当前武器的能力值并把联通块设置成饱和。
  2. 两个点属于不同的联通块，如果其中一个点是饱和的，那就将合并后的联通块设成饱和；如果都不是饱和，合并后也是不饱和；如果两个都是饱和的，就略过。
#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define fi first
#define se second
#define il inline
#define re register
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
const int N = 2e5 + 10;
const int M = 5e5 + 10;
const ll INF = 1e18;
const double eps = 1e-5;
const int MOD = 1e9 + 7;
struct Query {
    int x, y, w;
    int id;
    bool operator < (const Query& rhs) const {
        return w > rhs.w;
    }
}q[N];
int fa[N], flag[N];
int find(int x) {return x == fa[x] ? x : fa[x] = find(fa[x]);}
void solve() {
    int n, m; cin >> n >> m;
    for (int i = 1; i <= n; i++) fa[i] = i, flag[i] = 0;
    for (int i = 1; i <= m; i++) {
        int k; cin >> k;
        if (k == 1) {
            cin >> q[i].x >> q[i].w;
            q[i].y = q[i].x;
        } else {
            cin >> q[i].x >> q[i].y >> q[i].w;
        }
    }
    sort(q+1, q+m+1);
    ll ans = 0;
    for (int i = 1; i <= m; i++) {
        int fx = find(q[i].x), fy = find(q[i].y);
        if (fx == fy) {
            if (!flag[fx]) {
                ans += q[i].w;
                flag[fx] = 1;
            }
        } else {
            if (flag[fx] && flag[fy]) continue;
            else if (!flag[fx] && !flag[fy]) {
                ans += q[i].w;
                fa[fx] = fy;
            } else {
                ans += q[i].w;
                fa[fx] = fy;
                flag[fy] = 1;
            }
        }
    }
    cout << ans << endl;
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

G 九峰与蛇形填数（线段树）

听说很多人都是暴力+剪枝过的，而且std还卡常 。

因为我们只要知道最后覆盖的是什么就可以，所以用二维的线段树去区间覆盖，N*Nlog(N)的复杂度。

最后我们可以通过起始位置和k， O（1）推出当前位置的值（分奇偶考虑一下，简单推一下式子），也不多说，具体看代码。

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define fi first
#define se second
#define il inline
#define re register
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
const int N = 2000 + 10;
const int M = 3000 + 10;
const ll INF = 1e18;
const double eps = 1e-5;
const int MOD = 1e9 + 7;
struct node {
    struct tree {
        int l, r;
        int lazt, sum;
    }t[N<<2];
    void push_down(int u) {
        if (t[u].lazt) {
            t[u<<1].lazt = t[u<<1|1].lazt = t[u].lazt;
            t[u<<1].sum = t[u<<1|1].sum = t[u].lazt;
            t[u].lazt = 0;
        }
    }
    void build(int u, int l, int r) {
        t[u].l = l, t[u].r = r;
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(u<<1, l, mid);
        build(u<<1|1, mid+1, r);
    }
    void modify(int u, int ql, int qr, int val) {
        if (ql <= t[u].l && qr >= t[u].r) {
            t[u].lazt = val;
            t[u].sum = val;
            return;
        }
        push_down(u);
        int mid = (t[u].l + t[u].r) >> 1;
        if (ql <= mid) modify(u<<1, ql, qr, val);
        if (qr > mid) modify(u<<1|1, ql, qr, val);
    }
    int query(int u, int pos) {
        if (t[u].l == t[u].r) return t[u].sum;
        int mid = (t[u].l + t[u].r) >> 1;
        push_down(u);
        if (pos <= mid) return query(u<<1, pos);
        else return query(u<<1|1, pos);
    }
}tree[2005];
int a[M], b[M], k[M];
inline int bf(int x, int y, int ai, int bi, int ki) {
    int tmp = x - ai + 1;
    if (tmp % 2 == 1) return tmp * ki - (bi+ki-1-y);
    else return (tmp-1)*ki+1 + (bi+ki-1-y);
}
void solve() {
    int n, m; cin >> n >> m;
    for (int i = 1; i <= n; ++i) tree[i].build(1, 1, n);
    for (int i = 1; i <= m; ++i) {
        cin >> a[i] >> b[i] >> k[i];
        for (int j = a[i]; j <= a[i]+k[i]-1; ++j) {
            tree[j].modify(1, b[i], b[i]+k[i]-1, i);
        }
    }
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            int cnt = tree[i].query(1, j);
            if (cnt == 0) printf("0 ");
            else printf("%d ", bf(i, j, a[cnt], b[cnt], k[cnt]));
        }
        printf("\n");
    }
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

H 吴楚月的表达式（模拟）

因为只有+ - * / 四种运算，所以这里可以用到一个小的trick。

我们把当前节点的值看成是 a + b

假设当前运算符为x，下一个节点值为a[v]

  1. x为 ‘+’ : a的值变成a+b，b的值变为a[v]
  2. x为 ‘-’ : a的值变成a+b，b的值变为-a[v]
  3. x为 '’ : a的值仍为a，b的值变为ba[v]
  4. x为 ‘/’ : a的值仍为a，b的值变为b/a[v]
#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define fi first
#define se second
#define il inline
#define re register
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
const int N = 2e5 + 10;
const int M = 5e5 + 10;
const ll INF = 1e18;
const double eps = 1e-5;
const int MOD = 1e9 + 7;
int n, cnt, h[N], a[N], fa[N];
ll ans[N];
struct Edge {
    int to, next;
    char w;
}e[M];
void add(int u, int v, char w) {
    e[cnt].to = v;
    e[cnt].w = w;
    e[cnt].next = h[u];
    h[u] = cnt++;
}
ll ksm(ll a, ll b) {
    ll res = 1, base = a;
    while (b) {
        if (b & 1) res = res * base % MOD;
        base = base * base % MOD;
        b >>= 1;
    }
    return res;
}
void dfs(int u, int far, ll pre, ll now) {
    for (int i = h[u]; ~i; i = e[i].next) {
        int v = e[i].to;
        if (v == far) continue;
        if (e[i].w == '+') dfs(v, u, (now+pre+MOD)%MOD, a[v]);
        else if (e[i].w == '-') dfs(v, u, (now+pre+MOD)%MOD, -a[v]);
        else if (e[i].w == '*') dfs(v, u, pre, now*a[v]%MOD);
        else dfs(v, u, pre, now*ksm(a[v], MOD-2)%MOD);
    }
    ans[u] = (pre+now+MOD)%MOD;
}
void solve() {
    cin >> n; memset(h, -1, sizeof h);
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 2; i <= n; i++) cin >> fa[i];
    for (int i = 2; i <= n; i++) {
        char c; cin >> c;
        add(i, fa[i], c);
        add(fa[i], i, c);
    }
    dfs(1, 0, 0, a[1]);
    for (int i = 1; i <= n; i++) printf("%lld%c", ans[i], i == n ? '\n' : ' ');
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}

J 邬澄瑶的公约数（质因数分解）

我们知道求最大公因数可以转化为公共质因子之积

把所有数质因数分解一下，然后求出最小的公共质因子之积

#include <bits/stdc++.h>
using namespace std;
//#define ACM_LOCAL
#define fi first
#define se second
#define il inline
#define re register
typedef long long ll;
typedef pair<int, int> PII;
typedef unsigned long long ull;
const int N = 1e4 + 10;
const int M = 5e5 + 10;
const ll INF = 1e18;
const double eps = 1e-5;
const int MOD = 1e9+7;
ll ksm(ll a, ll b) {
    ll res = 1, base = a % MOD;
    while (b) {
        if (b & 1) res = res * base % MOD;
        base = base * base % MOD;
        b >>= 1;
    }
    return res % MOD;
}
int prime[N], k = 0;
bool is_prime[N];
void get_prime(){
    memset(is_prime, true, sizeof is_prime);
    is_prime[0] = is_prime[1] = false;
    for(int i = 2 ; i < N;i++){
        if (is_prime[i]) prime[++k] = i;
        for(int j = 1; j <= k && i * prime[j] < N;j++){
            is_prime[i * prime[j]] = false;      //得到合数的最小质因子
            if(i % prime[j] == 0) break;
        }
    }
}
ll a[N], b[N], Min[N];
void get_fac(int x, int j) {
    for (int i = 1; i <= k; i++) {
        //if (prime[i] * prime[i] > x) break;
        int cnt = 0;
        while (x % prime[i] == 0) x /= prime[i], cnt++;
        Min[i] = min(Min[i], cnt * b[j]);
    }
}
void solve() {
    get_prime();
    int n; cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 1; i <= n; i++) cin >> b[i];
    for (int i = 1; i <= k; i ++) Min[i] = INF;
    for (int i = 1; i <= n; i++) {
        get_fac(a[i], i);
    }
    ll ans = 1;
    for (int i = 1; i <= k; i++) {
        if (Min[i] != INF)
            ans = ans * ksm(prime[i], Min[i]) % MOD;
    }
    cout << ans << endl;
}

signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("input", "r", stdin);
    freopen("output", "w", stdout);
#endif
    solve();
}
kaka0010
关注
2021牛客寒假算法基础集训营5 - D石子游戏
weixin_45509601的博客
02-22 1410
前言：哎，这场打的就很nanshou，开局a出俩题，剩下的数学题兴趣就直接无了，结果俩小时直接结束战斗。 结束之后看了一下题解，感觉D题讲的有点麻烦，这边讲一下一种更低效率不过更加直观的做法。如果有看不懂题解的朋友可以尝试一下我的理解。 正文开始# 没看过题目的可以去牛客先看一下。我这里自己出一组数据。 1 5 2 3 3 2 0 2 这里介绍一个算法，差分算法，至于为什么想到的，只能说看到这题就本能的就想到这个算法。 我们对数据进行差分（就是前一个数减后一个数）。得到差分数组cut。 0 1 2 -2 然
2020牛客寒假算法基础集训营4.D——子段异或【前缀】
NIRVANA REBIRTH
02-11 331
题目传送门 题目描述 输入一个数列a，你需要输出其中异或值为0的不同子段的数量。一个子段 [l,r](1≤l≤r≤n)[l,r] (1 \le l \le r \le n)[l,r](1≤l≤r≤n) 的异或值为al⊕al+1⊕al+2⊕…⊕ara_l \oplus a_{l+1} \oplus a_{l+2} \oplus \ldots\oplus a_ral​⊕al+1​⊕al+2​⊕…⊕a...
2021牛客寒假算法基础集训营4部分题解（A,B,D,E,F,G,H,I,J）
画船听雨眠
02-20 515
oj: 牛客 A 九峰与签到题 oj: 牛客 题解 签到题 代码 #pragma GCC optimize(2) #include <bits/stdc++.h> #define _for(i, a) for(int i = 0, lennn = (a); i < lennn; ++i) #define _rep(i, a, b) for(int i = (a), lennn = (b); i <= lennn; ++i) #define nl(i, n) (i == n - 1 ?
2021年牛客寒假集训营第四场题解
weixin_45761011的博客
02-25 170
A、九峰与签到题 B、武辰延的字符串 思路： 代码： #include <bits/stdc++.h> using namespace std; typedef unsigned long long ULL; const int N = 1e5 + 5, B = 131; char s[N], t[N]; ULL h1[N], h2[N], p[N]; ULL get1(int l, int r) { return h1[r] - h1[l-1] * p[r-l+1]; } ULL
2021牛客寒假算法基础集训营4-J-邬澄瑶的公约数(质因数分解)
Cosmic_Tree的博客
03-06 136
题目链接：点击进入 题目 思路 求 n 个数的最大公约数，可以把 n 个数都质因数分解，然后取所有的公共部分，再乘起来就是答案 代码 #include<iostream> #include<string> #include<map> #include<set> //#include<unordered_map> #include<queue> #include<cstdio> #include<vector>
2021牛客寒假算法基础集训营4（A B D E F G H J）
Tan_Yuu的博客
02-21 359
比赛链接：这里 OP 个人能力有限，有的题目实在知识点欠缺太多，这里是大佬的题解 A 九峰与签到题 签到题 思路 持续模拟打标记即可，注意题目描述：他认为任意时间内通过率大于等于50%的题为签到题 代码 #include <bits/stdc++.h> using namespace std; typedef long long ll; int main() { int m,n,i,j; int ac[25]={0},sb[25]={0}; bool pro[25];
F 魏迟燕的自走棋(思维+贪心+并查集维护联通块/左部点配对边＜=2的匈牙利）
代码笔记本
02-21 224
https://ac.nowcoder.com/acm/contest/9984/F 参考:F 魏迟燕的自走棋（贪心+并查集） 将每个人看成一个点，武器的能力值抽象成边，这样就转化成图论的模型了。 然后可以转化成联通块去看 这种点之间连边的最值维护似乎跟并查集维护联通块容易联系到一起(应该是个trickC. Bertown Subway(思维+贪心+并查集维护联通块) 从联通块角度去看，如果一个联通块还没有形成环，那么他们之间的武器是可以互相换的，即他们当中的任意点都可以拥有新武器，我们称这个
2020牛客寒假算法基础集训营5.E——Enjoy the game【博弈】
NIRVANA REBIRTH
02-13 656
题目传送门 题目描述 牛牛战队的三个队员在训练之余会自己口胡了一些题当做平时的益智游戏。有一天牛可乐想出了一个小游戏给另外两名队员玩，游戏规则如下： 初始一共有nn张卡牌 先手第一步最少要拿1张牌，最多要拿n-1张牌。 接下来每一步，双方最少要拿1张牌，最多拿等同于上一步对方拿的牌数的牌。 拿走最后一张牌的人将取得游戏的胜利。 你作为旁观者，看着他们玩的很开心，想参与到这场游戏中来，赌一赌谁...
2020牛客寒假算法基础集训营1 题解
LiuKairui的博客
03-02 767
A:honoka和格点三角形 题目描述 honoka最近在研究三角形计数问题。 她认为，满足以下三个条件的三角形是“好三角形”。 1.三角形的三个顶点均为格点，即横坐标和纵坐标均为整数。 2.三角形的面积为 。 3.三角形至少有一条边和 轴或 轴平行。 honoka想知道，在平面中选取一个大小为 109+710^9+7109+7 的矩形格点阵，可以找到多少个不同的“好三角形”？由于答案可能过大，请...
2022牛客寒假算法基础集训营2
m0_58178876的博客
01-27 1174
2022牛客寒假算法基础集训营2题解
魏迟燕的自走棋
m0_53807008的博客
06-03 100
题目链接：https://ac.nowcoder.com/acm/contest/9984/F 题目大意：给你n个人与m件装备，其中每个人都只能对应配一件装备，每件装备也只能配对应一个人。 每件装备可能对应的人有一个或者两个 同时每件装备具有wi点战斗力 问你最大能获得多少战斗力 思路： 感觉有点类似最大生成树 把每件装备的战斗力都当作边值，人的编号当作点 因为是要最大战斗力那么肯定要排序先最大的边进行合并 利用并查集来合并点，再利用辅助数组v[]判断点是否用过 同时要考虑一下自环的情况（就是每件装备只能对
武辰延的字符串(思维+二分字符串前缀)
代码笔记本
02-20 194
众所周知，武辰延很喜欢字符串。 这天，他对着两个字符串 s 和 t 发呆，他发现这两个串的前缀有很多相似的地方，s 的两个前缀连接起来竟也是 t 的前缀。 武辰延想知道有多少对 s 的非空前缀连接起来是 t 的前缀。 形式化地讲，我们把si​看作字符串 s 长度为 i 的前缀。 对于一对前缀 (si​,sj​)(允许 i=j)而言，当满足si+sj​=ti+j​时，我们认为这两个 s 的前缀拼接后等于 t 的一个前缀。 两对 s 的前缀 (si​,sj​)与 (si′​,sj′​)不同当且仅当 i...
牛客寒假训练 魏迟燕的自走棋 贪心+并查集
aaaaa124421421的博客
02-22 159
题目在这 贪心方案：对于装备的价值从大到小进行选择。 如果每件装备只对应一个人的话，只需要设置一个st数组记录每个人知否已经选了装备，从大到小枚举每件装备能否选择即可。 现在问题是k=1或k=2，我们可以考虑将士兵看成点，用并查集来维护士兵的信息，使用st数组来维护连通块能否还能选择装备。 连通块的意义：对于一个连通块，它可能不能再匹配装备了，或者还能匹配一件装备。如果还能匹配一件装备的话，任意选择其中一个点，则之前匹配该连通块的装备能匹配剩下的全部点。因此只要有装备能匹配连通块中的任意点，都可以将该装备选
2021牛客训练营 F.魏迟燕的自走棋(贪心并查集)
jziwjxjd的博客
02-21 261
传送门 费用流会TTT,但是没试过HKHKHK之类的 STD 设武器作用于x,yx,yx,y两个人(如果k=1k=1k=1那么令x=yx=yx=y),收益为www 我们在x,yx,yx,y之间连一条边权为www的边 那么显然,对于一个nnn个点的连通块,如果选了nnn条边 刚好就是一棵树加上一条边刚好成环(基环树) 刚好这个连通块内每个点都可以占据一条边(每个人都有武器) 那么每次都贪心的选择最大边加进连通块 除非这条边连接起来连通块会大于nnn条边。 证明 设方案eee某一次抉择中没有选择最大边kkk
【2021牛客寒假第四场】B题 武辰延的字符串 二分+哈希
狙击美佐的博客
02-19 134
【2021牛客寒假第四场】B题 武辰延的字符串 二分+哈希题意思路Code 传送门：https://ac.nowcoder.com/acm/contest/9984/B 题意 给字符串s和t，问有多少种s的两个前缀相连是t的前缀的个数。给字符串s和t，问有多少种s的两个前缀相连是t的前缀的个数。给字符串s和t，问有多少种s的两个前缀相连是t的前缀的个数。 思路 首先这题暴力n2肯定会T的。首先这题暴力n^2肯定会T的。首先这题暴力n2肯定会T的。 正确解法是先找s的前缀s1和t的前半部分配对，再找s的最长前
tinyarray-1.2.3-cp36-cp36m-win_amd64.whl
10-14
tinyarray-1.2.3-cp36-cp36m-win_amd64.whl
minepy-1.2.6-pp38-pypy38_pp73-win_amd64.whl
10-14
minepy-1.2.6-pp38-pypy38_pp73-win_amd64.whl
RJFireWall.zip
最新发布
10-14
r (230).zip
课程作业管理&基于java的课程作业管理系统设计与实现（毕业论文+ppt+开题报告）
10-14
通过标签分类管理等方式，实现管理员：首页、个人中心、公告信息管理、班级管理、学生管理、教师管理、课程类型管理、课程信息管理、学生选课管理、作业布置管理、作业提交管理、作业评分管理、课程评价管理、课程资源管理，教师；首页、个人中心、课程信息管理、学生选课管理、作业布置管理、作业提交管理、作业评分管理、课程评价管理、课程资源管理，学生；首页、个人中心、公告信息管理、课程信息管理、学生选课管理、作业布置管理、作业提交管理、作业评分管理、课程评价管理、课程资源管理等功能
牛客暑期集训营第八场：算法题解概览与策略分析
在2020牛客多校暑期集训营第八场的题解文档中，涉及了多个编程题目，主要集中在C++语言的应用上。以下是各题目的简要概述和解题思路： 1. A-All-StarGame: 题目要求在给定数组中选择数字，目标是使得最后选出的数字...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值