2020牛客暑期多校训练营（第四场）

最新推荐文章于 2020-08-25 14:46:39 发布
最新推荐文章于 2020-08-25 14:46:39 发布
阅读量139 收藏
点赞数
分类专栏： 多校
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yubing792289314/article/details/107646987
版权

目录

A. Ancient Distance
https://ac.nowcoder.com/acm/contest/5669/A

B. Basic Gcd Problem

https://ac.nowcoder.com/acm/contest/5669/B

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
int n, c, m;

int primes[N], cnt;     // 存储所有质数
bool st[N];     // 存储每个数是否已被筛掉
void get_primes(int n){      // 线性筛法求素数
    st[1] = 1;
    for (int i = 2; i <= n; i++) {
        if (!st[i]) primes[cnt++] = i;
        for (int j = 0; primes[j] <= n / i; j++) {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

ll qpow(ll a, ll b) {
    a %= mod;
    ll res = 1;
    while (b) {
        if (b & 1)res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}


int main() {
    ios::sync_with_stdio(false);

    get_primes(1000000);
    int T;
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &c);
        // 如果是素数 直接输出1
        if (!st[n]) {
            m = 1;
        } else {
            // 如果不是 则统计质因子的个数
            m = 0;
            for (int i = 0; i < cnt && primes[i] <= n; i++) {
                if (n % primes[i] == 0) {
                    while (n % primes[i] == 0) {
                        m++;
                        n /= primes[i];
                    }
                }
                if (!st[n])break;
            }
            if (n > 1) {
                m++;
            }
        }
        printf("%lld\n", qpow(c, m));
    }
    return 0;
}

C. Count New String · 后缀自动机

https://ac.nowcoder.com/acm/contest/5669/C
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int N = 1e6 + 10;
int pos[N];

namespace Sam { // 后缀自动机

    const int M = 2e6 + 10;
    const int CHAR_NUM = 10;
    
    // 后缀自动机
    struct SAM {
        struct state {
            int len, link;
            vector<int> nxt;

            state() { nxt.resize(CHAR_NUM); }
        } st[M * 2];

        int sz;//自动机的大小
        int last;// 未加入下一个字符前最长的前缀（整个串）所属的节点的编号

        void init() {
            // 创建只有一个初始状态的sam
            st[0].len = 0;
            st[0].link = -1;
            sz = 0;
            last = 0;
        }

        void insert(int c) {
            int cur = ++sz;
            st[cur].len = st[last].len + 1;
            int p = last;
            while (p != -1 && !st[p].nxt[c]) {
                st[p].nxt[c] = cur;
                p = st[p].link;
            }

            if (p == -1) {
                st[cur].link = 0;
            } else {
                int q = st[p].nxt[c];
                if (st[p].len + 1 == st[q].len) {
                    st[cur].link = q;

                } else {
                    int clone = ++sz;//复制
                    st[clone].len = st[p].len + 1;
                    st[clone].nxt = st[q].nxt;
                    st[clone].link = st[q].link;
                    while (p != -1 && st[p].nxt[c] == q) {
                        st[p].nxt[c] = clone;
                        p = st[p].link;
                    }

                    st[q].link = st[cur].link = clone;
                }
            }
            last = cur;
        }
    } sam;
}
using namespace Sam;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    string s;
    cin >> s;
    s = " " + s;
    sam.init();
    int n = s.length() - 1;
    pos[n + 1] = 0;
    stack<int> st;// 单调栈 字符从大到小排列
    for (int i = n; i >= 1; i--) {//从后往前遍历
        while (!st.empty() && s[st.top()] < s[i]) st.pop();
        int k = st.empty() ? n + 1 : st.top();//记下 最大字母的下标 根据坐标寻找插入时对应的后缀自动机的状态
        sam.last = pos[k];
        for (int j = i; j < k; j++) {
            sam.insert(s[i] - 'a');
        }

        pos[i] = sam.last;
        st.push(i);
    }

    ll ans = 0;
    // 根据后缀自动机的性质 以点i为节点的子串的个数 = len[i]-len[link[i]]
    for (int i = 1; i <= sam.sz; i++) {
        ans += sam.st[i].len - sam.st[sam.st[i].link].len;
    }
    cout << ans << endl;

    return 0;
}

D Dividing Strings
E Eliminate++

F. Finding the Order

https://ac.nowcoder.com/acm/contest/5669/F

#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
char s[310][310];

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        int ac, ad, bc, bd;
        scanf("%d%d%d%d", &ac, &ad, &bc, &bd);
        if (ac > ad)puts("AB//DC");
        else if (ac == ad) {
            if (bc > bd)puts("AB//CD");
            else puts("AB//DC");
        } else puts("AB//CD");
    }
    return 0;
}

G Geometry Challenge

H. Harder Gcd Problem

https://ac.nowcoder.com/acm/contest/5669/H

优先处理质因子较大的数，因为质因子越大，含有该质因子的数越少
当包含同一个质因子的数的个数有偶数个时，显然可以将这些数俩俩匹配
如果是奇数的话，就是一群配对里出了个单身狗的故事了，
选一个包含了更小的质因子的数，将其与其他同样包含了更小的质因子的数进行匹配

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
typedef pair<int, int> pii;
int n;

vector<int> v[N];// v[i]存放 包含第i个质因子的数

int primes[N], cnt = 0;     // 存储所有质数
int st[N], vis[N];     // 存储每个数是否已被筛掉

int Mx[N], Mi[N]; // 质因子最大值 质因子最小值
int id[N];

void get_primes(int n){      // 线性筛法求素数
    for (int i = 2; i <= n; i++) {
        if (!st[i]) {
            primes[cnt] = i;
            id[i] = cnt;
            cnt++;
        }
        for (int j = 0; primes[j] <= n / i; j++) {
            st[primes[j] * i] = 1;
            if (i % primes[j] == 0) break;
        }
    }
	// 求出所有质因子后 再筛选 将每个数放到自己最大质因子的位置
	// 用埃筛直接找也是可以的
    for (int i = cnt - 1; i >= 0; i--) {
        for (int j = primes[i]; j <= n; j += primes[i]) {
            if (!vis[j]) {
                vis[j] = 1; 
                Mx[j] = Mi[j] = primes[i];

            } else {
                Mi[j] = min(Mi[j], primes[i]);
            }
        }
    }
}

vector<pii> ans;
int sz;

int main() {
    ios::sync_with_stdio(false);

    get_primes(200000);
    
    int T;
    scanf("%d", &T);
    while (T--) {
        scanf("%d", &n);
        for (int i = 0; i < cnt; i++) {
            v[i].clear();
        }
        ans.clear();

        int lim = 0;
        for (int i = 2; i <= n; i++) {
            v[id[Mx[i]]].push_back(i);
            lim = max(lim, Mx[i]);
        }

        lim = id[lim];

        for (int i = lim; i >= 0; i--) {
            sz = v[i].size();
            if (sz == 1) {
                // 抛弃
            } else if (sz & 1) {//奇数
                sort(v[i].begin(), v[i].end(), [](int a, int b) { // c++14写法
                    return Mi[a] < Mi[b];
                });
                int x = v[i][0];
                if (Mi[x] != primes[i]) {//下放
                    v[id[Mi[x]]].push_back(x);
                } else {
                    //抛弃
                }
                for (int j = 1; j < sz; j += 2) { // 相邻两个进行匹配
                    ans.push_back({v[i][j], v[i][j + 1]});
                }
            } else {//偶数
                for (int j = 0; j < sz; j += 2) {
                    ans.push_back({v[i][j], v[i][j + 1]});
                }
            }
        }

        sz = ans.size();
        printf("%d\n", sz);
        for (int i = 0; i < sz; i++) {
            printf("%d %d\n", ans[i].first, ans[i].second);
        }
    }
    return 0;
}

I Investigating Legions
J Jumping on the Graph

Zaller
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2020牛客暑期多校训练营第五场Graph
s260127ljy的博客
07-26 247
GraphGraphGraph 原题请看这里 题目描述： WWW先生得到了一个具有NNN个顶点和N−1N-1N−1条边的新图。 这是一个没有周期的连通图。 每个边缘都具有丑陋值。 为了使图形更美观，WWW先生希望您可以帮助他进行修改。 您可以一次删除或添加一个具有丑陋值的边，并且可以根据需要进行多次。 但是任何时候都应满足以下条件： 1.1.1.图形已连接。 2.2.2.对于图中的每个循环，该循环中所有丑陋值的xorxorxor总和为000。 W先生想知道图中所有边的丑陋值的最小和。 输入描述： 第一行包含
2020牛客暑期多校训练营（第四场）D- Dividing Strings
ding_ning123的博客
07-21 300
传送门 Description With powerful decision-making skills, ZYB can solve complex problems ZYB has a decimal string {s}s of length {n}n. He wants to split the string into several (at least 2) non-empty continuous substrings and minimize the difference between th
2020牛客暑假多校训练第四场总结
weixin_45671402的博客
07-28 108
2020牛客暑假多校训练第四场总结 关于比赛： 这次的题感觉比第三场的题目整体难度要高（主要是做出来的就少）。签到题设置了一道找规律的题目，难度还可以。但是第二道题B的卡时卡的很迷惑，也不知道是后台出了什么bug还是我们头太铁… 整体分析这次比赛，队伍的状态一般。就签到题而言，原本就是一道很简单的思维题，但是团队一开始对这个题目的定位就出现了偏差，导致队伍一直在往复杂的方向走。而对于B题首先我们的思路一开始就没有统一，到底是质因子的个数还是质因子的种类数这一点上在最后一直没有达成共识。 对自己而言，这次比赛
2020牛客暑期多校训练营（第四场）A题解
KoToBa的博客
07-25 174
话说这题出题人给的题解看了半天看不大懂啊…… 还是抄 看了好多AC代码才搞明白 题目传送门 首先这道题的题面给出了一个easy版本的问题，我们先从这一问题开始。 读完题目后，我们略一思考就可发现，随着x的减少，k是会不断的增加的，这显然是一个单调的函数关系，因此很容易想到二分。在easy版本中k固定的情况下，二分的区间就是1~n，每次check时，我们先找出当前深度最深的点，向上跳x个距离到达某一结点u，将其设为关键点，然后将以u点为根的子树打上标记，表示这颗子树已经被“处理”了。这样每次重复上述过程，直到
2020牛客暑期多校训练营（第四场）题解
a_forever_dream的博客
08-25 800
A. Ancient Distance 给出一棵树，选定 kkk 个关键点，每个点往根方向走到的第一个关键点为最近关键点，令 f(k)=max⁡i=1n(if(k)=\max_{i=1}^n(if(k)=maxi=1n​(i 到最近关键点的距离)))，求 ∑k=1nf(k)\sum_{k=1}^n f(k)∑k=1n​f(k)。 他要的是枚举关键点数量，容易转化成枚举最大距离，然后求出需要的最少关键点数。 枚举出最大距离 xxx 后，就是个比较简单的贪心了，每次取深度最大的点，往上跳 xxx 步，将这个
2020牛客暑期多校训练营（第五场）
Irving0323的博客
08-05 186
多校
2020牛客暑期多校训练营（第五场） Graph
bbbll123的博客
07-26 337
原题 题目描述 W先生得到了一个具有N个顶点和N-1条边的新图。 这是一个没有环的连通图。 每个边缘应具有难看的值。 为了使图形更美观，W先生希望您可以帮助他进行修改。 您可以一次删除或添加一个具有丑陋值的边，并且可以根据需要进行多次。 但是任何时候都应满足以下条件： 1、1、1、 图形已连接。 2、2、2、 对于图中的每个环，该环中所有丑陋值的XOR总和为0。 W先生想知道图中所有边的丑陋值的最小和。 输入描述： 第一行包含一个整数N (2≤N≤100000)。 接下来的N-1行每行包含三个整数U,V,
2020牛客暑期多校训练营（第四场）B——Basic Gcd Problem
NGUP_LEE的博客
07-21 216
题目链接 题目分析： 主要就是这个公式，我们分析一下，这是一个迭代公式，直到x=1的时候才会结束。 每次迭代都会乘上c的值，所以迭代n次就有n个c相乘，也就是c的n次方，主要求解迭代次数 也就是寻找n质因子的个数cnt， for(int i=2;i*i<=n;i++) { while (n%i==0) { cnt++; n/=i; }
2020牛客暑期多校训练营（第四场） 个人做题记录
asdkjc的博客
07-20 219
F.Finding the Order 大意是说有两条平行线AB、CD，给出AC、AD、BC、BD的长度，要求判断是AB∣∣CDAB||CDAB∣∣CD还是AB∣∣DCAB||DCAB∣∣DC（就是判断CD两点的位置关系）。 读入之后分情况讨论即可（详见代码） #include<stdio.h> #include<map> #include<queue> #include<iostream> #include<algorithm> #includ
2020牛客暑期多校集训营第二场题解.pdf
01-20
2020牛客暑期多校集训营第二场题解.pdf
2020牛客暑期多校集训营第五场题解.pdf
01-20
2020牛客暑期多校集训营第五场题解.pdf
2020牛客暑期多校集训营第六场题解.pdf
01-20
2020牛客暑期多校集训营第六场题解.pdf
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
4. 二次型(Quadratic Form): 提供了求解二次型的方法，即利用拉格朗日对偶性，通过计算矩阵A的逆来得到最优解。 5. 无穷字符串比较: 通过周期性引理，比较两个无穷字符串a^∞和b^∞，如果前a+b-gcd(a,b)个字符没有...
2020牛客暑期多校训练营（第六场）
Yubing792289314的博客
08-02 1220
A African Sort B. Binary Vector #include <bits/stdc++.h> using namespace std; typedef long long ll; const ll mod = 1e9 + 7; const int M = 2e7; int n; ll qpow(ll a, ll b) { a %= mod; ll res = 1; while (b) { if (b & 1)res = res
2020牛客暑期多校训练营（第八场）
Yubing792289314的博客
08-03 395
A All-Star Game B Bon Voyage C Cinema D Disgusting Relationship E Enigmatic Partition F Factorio G. Game SET #include <bits/stdc++.h> using namespace std; const int N = 1e6 + 10; int n; string str[13] = { "one", "two", "three",
2020 Multi-University Training Contest 2
Yubing792289314的博客
08-15 343
1001 Total Eclipse 1002 Blood Pressure Game 1003 Count on a Tree II Striking Back 1004 Diamond Rush 1005 New Equipments 1006 The Oculus 1007 In Search of Gold 1008 Dynamic Convex Hull 1009 It’s All Squares 1010 Lead of Wisdom 1011 King of Hot Pot
2020 Multi-University Training Contest 1
Yubing792289314的博客
08-05 342
Fibonacci Sum 赛中交的代码赛后疯狂T，感谢测评姬放过……
2020牛客暑期多校2 C
最新发布
10-01
引用是一段C++代码，涉及到图的遍历和操作。代码的功能是根据给定的树，选择最少的点对，使得所有的边都被覆盖。具体思路是，首先确定点对的数量为叶子节点数除以2，然后通过DFS序找出叶子节点，每次选择编号为i和i+cnt/2的两个叶子节点作为点对。如果叶子节点数是奇数，则将最后一个叶子节点与根节点相连。最后输出点对的数量和每对点对的编号。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值