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

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

目录

A African Sort

B. Binary Vector

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

#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 * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}

ll res[M + 5];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    ll x = 1, y, z = 1, tmp = 1;
    ll Inv2 = qpow(2, mod - 2);
    res[0] = 0;
    for (int i = 1; i <= M; i++) {
        x = (x * 2) % mod;
        y = x - 1;
        z = (z * Inv2) % mod;
        tmp = (tmp * (y * z % mod)) % mod;
        res[i] = res[i - 1] ^ tmp;
    }
    int T;
    cin >> T;
    while (T--) {
        cin >> n;
        cout << res[n] << endl;
    }
    return 0;
}

C. Combination of Physics and Maths

https://ac.nowcoder.com/acm/contest/5671/C

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e3 + 10;
ll a[N][N];
int n, m;
ll sum[N][N];

int main() {

    int T;
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &m);

        for (int i = 1; i <= n; i++) 
            for (int j = 1; j <= m; j++) 
                scanf("%lld", &a[i][j]);

        for (int i = 1; i <= n; i++) 
            for (int j = 1; j <= m; j++) 
                sum[i][j] = sum[i - 1][j] + a[i][j];
            
        double ans = 0.0;
        for (int i = 1; i <= n; i++) 
            for (int j = 1; j <= m; j++) 
                ans = max(ans, (1.0 * sum[i][j]) / (a[i][j] * 1.0));
            
        printf("%.8f\n", ans);
    }
    return 0;
}

D Data structure

E. Easy Construction

https://ac.nowcoder.com/acm/contest/5671/E

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int a[N];
int n, k;

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

    if (n & 1) {//奇数
        if (k != 0) {
            puts("-1");
            return 0;
        } else {
            a[1] = n;
            for (int i = 2, j = 1; i <= n; i += 2, j++) {
                a[i] = j;
                a[i + 1] = n - j;
            }
        }
    } else {//n 偶数
        int tmp = (1 + n) * n / 2;
        if ((tmp % n) != k) {
            puts("-1");
            return 0;
        } else {
            a[1] = n;
            a[2] = n / 2;
            for (int i = 3, j = 1; i <= n; i += 2, j++) {
                a[i] = j;
                a[i + 1] = n - j;
            }
        }
    }

    for (int i = 1; i <= n; i++) {
        cout << a[i] << ' ';
    }
    return 0;
}

F Fibonacci Partition

G. Grid Coloring

https://ac.nowcoder.com/acm/contest/5671/G

#include <bits/stdc++.h>
using namespace std;

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        int n, k;
        scanf("%d%d", &n, &k);
        if (n == 1 || k == 1 || (n + 1) * 2 * n % k != 0) {
            puts("-1");
            
        } else {
            int p = 0;
            for (int i = 1; i <= 2 * (n + 1); i++) {
                for (int j = 1; j <= n; j++) {
                    p = (p + 1) % k;
                    printf("%d ", p + 1);
                }
                if (n % k == 0)p = (p + 1) % k;
                printf("\n");
            }
        }
    }
    return 0;
}

H. Harmony Pairs · 数位dp

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

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9 + 7;
const int N = 1e3 + 10;
int sz;
int num[105];
ll dp[105][N * 2][2][2]; // dp[pos][sum][limB][limA]

// pos 当前位置
// sum B-A在前pos位上的差值总和
// limB limA B、A在当前位置枚举到的数位的限制 即 当前位是否可以枚举到数字9 0-不受限制 1-限制
ll dfs(int pos, int sum, int limB, int limA) {
    if (pos == sz) return sum > N ? 1 : 0;//为防止sum出现负数 在一开始时加上一个基础值
    if (~dp[pos][sum][limB][limA]) return dp[pos][sum][limB][limA];
    int upB = limB ? num[pos] : 9;
    ll res = 0;
    for (int i = 0; i <= upB; i++) {
        int upA = limA ? i : 9;// 题目要求 B>=A 且 S(A) > S(B)
        for (int j = 0; j <= upA; j++) {
            res = (res + dfs(pos + 1, sum + (j - i), limB && i == upB, limA && j == upA)) % mod;
        }
    }
    return dp[pos][sum][limB][limA] = res;
}

ll solve(string s) {
    sz = s.length();
    for (int i = 0; i < sz; i++) {
        num[i] = s[i] - '0';
    }
    // 从最高位开始
    return dfs(0, N, 1, 1);
}

string s;

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

    memset(dp, -1, sizeof dp);
    
    cin >> s;
    cout << solve(s) << endl;
    return 0;
}

I Interesting Stiriling

J. Josephus Transform · 线段树 + 置换

https://ac.nowcoder.com/acm/contest/5671/J

官方题解
在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int a[N];
int n, m, k, x;
int p[N], nxt[N];

struct segTree {
#define ls (o<<1)
#define rs (o<<1|1)

    struct node {
        int l, r;
        int sum;
    } t[N << 2];

    void pushup(int o) {
        t[o].sum = t[ls].sum + t[rs].sum;
    }

    //不带数组 建树
    void build(int o, int l, int r) {
        t[o].l = l;
        t[o].r = r;
        if (l == r) {
            t[o].sum = 1;
            return;
        }
        int mid = l + r >> 1;
        build(ls, l, mid);
        build(rs, mid + 1, r);
        pushup(o);
    }

    //找当前线段树里存在的第k个数
    // 同时 删除这个数
    int query(int o, int L, int R, int k) {
        if (t[o].l == t[o].r) {
            t[o].sum = 0;
            return t[o].l;
        }
        int res;
        if (t[ls].sum >= k) res = query(ls, L, R, k);
        else res = query(rs, L, R, k - t[ls].sum);
        pushup(o);
        return res;
    }
} ST;

int vis[N];
vector<int> v;

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

    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        a[i] = i;
    }
    while (m--) {
        cin >> k >> x;
        for (int i = 1; i <= n; i++) {
            vis[i] = 0;
        }

        ST.build(1, 1, n);
        for (int i = 1, pos = k; i <= n; i++) {
            p[i] = ST.query(1, 1, n, pos);
            // 下一位数是剩下的数字里面的第pos位
            if (i < n) pos = ((pos - 1 + k - 1) % (ST.t[1].sum)) + 1;
        }

		// 根据置换p 求出环内的顺序
        for (int i = 1; i <= n; i++) {
            nxt[p[i]] = i;
        }

        for (int i = 1, now; i <= n; i++) {
            if (!vis[i]) {
                v.clear();
                now = i;
                while (!vis[now]) {
                    vis[now] = 1;
                    v.push_back(now);
                    now = nxt[now];
                }

                // 置换群快速幂
                for (int j = 0, sz = v.size(); j < sz; j++) {
                    p[v[j]] = v[(j + x) % sz];//新的位置关系
                }
            }
        }

        for (int i = 1; i <= n; i++) {
            nxt[p[i]] = a[i];
        }

        for (int i = 1; i <= n; i++) {
            a[i] = nxt[i];
        }
    }

    for (int i = 1; i <= n; i++) {
        cout << a[i] << (i == n ? "\n" : " ");
    }
    
    return 0;
}

K. K-Bag

https://ac.nowcoder.com/acm/contest/5671/K
参考博客 2020牛客多校第六场K.K-Bag （思维？）

#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
int a[N], b[N], vis[N], vis_pos[N];
int mp[N];
int n, k;

namespace Discretization { // 离散化板子
    vector<int> backUp;

    void discrete() {
        sort(backUp.begin(), backUp.end());
        backUp.erase(unique(backUp.begin(), backUp.end()), backUp.end());
    }

    int id(int x) {
        return lower_bound(backUp.begin(), backUp.end(), x) - backUp.begin() + 1;
    }
}
using namespace Discretization;

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

    int T;
    cin >> T;
    while (T--) {
        cin >> n >> k;
        int flag = 1;//判断标志
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
            if (a[i] > k) {
                flag = 0;
            }
            backUp.push_back(a[i]);//离散化
        }

        if (!flag) {
            cout << "NO" << endl;
            backUp.clear();
            continue;
        }

        discrete();//离散化

        for (int i = 1; i <= n; i++) {
            a[i] = id(a[i]);// 离散化后的下标
        }

        if (n > k) {
            flag = 0;

            // 先判断 a[r-k+1...r]里 数值为a[r] 的个数是否多次出现
            for (int r = 1, l = 1; r <= n; r++) {
                vis[a[r]]++;
                if (vis[a[r]] > 1) {
                    b[r] = 0;// b[r]表示 以r为结尾 区间长度为k的 一个区间划分 是否合法 0非法 1合法
                } else {
                    b[r] = 1;
                }
                if (r >= k) {
                    vis[a[l++]]--;
                }
            }

            // 但是 还有 a[r-k+1...r]里  重复数字不是在a[r]上出现的 非法划分
            // 比如 k=6时 [x 3 2 3 x x] 显然 [x x x 3 2 3] [ x 3 2 3 x x] [ 3 2 3 x x x] 都是不合法的
            // 但是 前面统计的时候 只有第2个3的位置 即[x x x 3 2 3] 被设置为了非法 其后面的位置都被当成了合法
            
            // 所以 需要将 这些包含 重复数字的区间划分 设置为非法
            int cnt = 0;// cnt表示 还有cnt个位置需要设置为非法
            for (int i = 1; i <= n; i++) {
                if (mp[a[i]]) {
                    cnt = max(cnt, k - (i - mp[a[i]]));
                    // 同时包含位置i 和上一次出现的位置 mp[a[i]] 的长度为k的区间 都是非法的
                }
                if (cnt) {
                    b[i] = 0;
                    cnt--;
                }
                mp[a[i]] = i;
            }
            // 特殊情况 
            // 补齐最后非法的区间 即 最后一段区间是非法 但是只出现了非法区间的一部分
            // 不过 这一部分b[i]本来就是0 就不写了

            for (int i = 1, lim = n + cnt; i <= lim; i++) {
                if (b[i] == 0) {
                    vis_pos[(i % k) + 1] = 1;
                    // 那么从当前位置开始k个为一组往前分组 一直分到到第一个含有k个元素的组
                    // 都是不合法的分法 将第一个位置的下标 标记为1 - 不合法
                }
            }

            for (int i = 1; i <= k; i++) {
                if (vis_pos[i] == 0) {
                    //存在合法的起始位置
                    flag = 1;
                    break;
                }
            }

        } else {
            // 当n<=k 要么只有一组 要么是两组(即各取一部分拼接形成)
            // 找到第一个重复的位置
            int pos = 0;
            for (int i = 1; i <= n; i++) {
                vis[a[i]]++;
                if (vis[a[i]] > 1) {
                    pos = i;
                    break;
                }
            }
            // 都没有重复 显然合法
            if (pos == 0) {

            } else {
                // 以pos为分界线划分前后两部分
                // 将前面合法的统计过的部分清空
                for (int i = 1; i <= pos; i++) {
                    vis[a[i]]--;
                }
                // 判断后面的是否合法
                for (int i = pos; i <= n; i++) {
                    vis[a[i]]++;
                    if (vis[a[i]] > 1) {
                        flag = 0;
                        break;
                    }
                }
            }
        }
        
        if (flag) {
            cout << "YES" << endl;
        } else {
            cout << "NO" << endl;
        }

        // init
        memset(b, 0, sizeof b);
        memset(vis, 0, sizeof vis);
        memset(vis_pos, 0, sizeof vis_pos);
        memset(mp, 0, sizeof mp);

        backUp.clear();
    }
    return 0;
}
Zaller
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客网暑期ACM多校训练营（第六场）C Generation I
Hrbust_Final的博客
08-05 198
#include&lt;bits/stdc++.h&gt; using namespace std; typedef long long LL; const LL M = 998244353; const int N = 1e6 + 10; LL Pow(LL a, LL b) { LL ans = 1; while(b) { if(b&amp;1) an...
牛客网暑期ACM多校训练营(第六场) C （简单排列组合+逆元）
Jiandong
08-07 222
Generation I 链接：https://www.nowcoder.com/acm/contest/144/C 来源：牛客网   时间限制：C/C++ 3秒，其他语言6秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 Oak is given N empty and non-repeatable sets whic...
牛客网暑期ACM多校训练营（第六场） J. Heritage of skywalkert
常胜将军的博客
08-04 178
题目：点击打开链接 题意：按照题中给出的方式生成n个数，求这n个数任意两个数的最小公倍数的最大值。 分析：由于数据看上去像是随机生成的，所以只需要选出前 100 大的数平方暴力即可。随机两个正整数互质的概率为 6/π^2，取前k个数可以用STL的nth_element。 代码： #pragma comment(linker, "/STACK:102400000,102400000")///...
牛客网暑期ACM多校训练营（第六场）A Singing Contest 队列 +简单模拟
qq_41668093的博客
08-05 218
链接：https://www.nowcoder.com/acm/contest/144/A 来源：牛客网   Singing Contest 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 Jigglypuff is holding a singing contest. There...
2020牛客暑期多校集训营第六场题解.pdf
01-20
2020牛客暑期多校集训营第六场题解.pdf
2020牛客暑期多校集训营第二场题解.pdf
01-20
2020牛客暑期多校集训营第二场题解.pdf
2020牛客暑期多校集训营第五场题解.pdf
01-20
2020牛客暑期多校集训营第五场题解.pdf
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
6. 快速幂运算(Brute Force and Exponentiation): 题目中提到了用加法表示乘法，乘法表示指数运算，并预计算B_{i,j} = 2^{W*j} * v_i，然后利用快速幂优化计算，复杂度为O(nm/W + 2^W)，其中W通常取16，可以得到足够...
牛客网暑期ACM多校训练营（第六场）J Heritage of skywalkert（思维）
LSD20164388的博客
08-04 351
链接：https://www.nowcoder.com/acm/contest/144/J 来源：牛客网   时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 skywalkert, the new legend of Beihang University ACM-ICPC Team,...
牛客网暑期ACM多校训练营（第六场）C.Generation I 组合数+逆元+思维
xiuya19的博客
08-05 367
链接：https://www.nowcoder.com/acm/contest/144/C 来源：牛客网 Oak is given N empty and non-repeatable sets which are numbered from 1 to N. Now Oak is going to do N operations. In the i-th operation, he will insert an integer x between 1 and M to every set indexed
牛客网暑期ACM多校训练营（第六场）A Singing Contest(二分+队列)
辞树
08-04 307
链接：https://www.nowcoder.com/acm/contest/144/A 来源：牛客网   时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 Jigglypuff is holding a singing contest. There are 2n singers i...
2022牛客暑期多校训练营6（ABGIJM）
Tan_Yuu的博客
08-08 452
A Array B Eezie and Pie G Icon Design I Line J Number Game M Game on grid
算法竞赛入门 函数与递归
sky666tzz的博客
12-08 248
例题4-1 古老的密码 走这 问题分析： 看了半天没看懂题目，看评论才懂一一映射是什么意思，也就是每个字母以任意规则对应另一个字符串的字母，但每个字母的对应规则不同 所以题目就变成出现两个字符串出现相同次数的字母的种类是否相同 AC代码： #include <bits/stdc++.h> using namespace std; int a[101]; int b[101]; int main() { /*题目不一定是每个字母都必须向后移动n位，也就是说，字母的映射关系是任意的，但是一种1
2021.6.5蓝桥杯国赛C/C++B组真题题解
weixin_44160474的博客
06-07 802
真题完整题面链接 A：考察基础知识 Mb和MB之间的单位换算即Byte和bit之间的转换 1Byte=8bit 200/8=25 B：思路：首先使用欧拉筛得到所有的质数 然后再判断质数的各个数位是否在{2，3，5，7}中 代码： #include <bits/stdc++.h> using namespace std; #define ll long long const int maxn = 30000500; int prime[maxn]; int vis[maxn]; ll Prime
信息学奥赛一本通（C++版）第三章 程序的控制结构
harry04的博客
08-27 689
第一节 if选择结构: 1039：判断数正负 #include<bits/stdc++.h> using namespace std; int main() { int n,positive,zero,negative; cin>>n; if(n>0) { cout<<"positive"<<endl; } if(n==0) { cout<<"zero"<<endl; } if(n<0) {
Codeforces Round #764 (Div. 3)
m0_51508220的博客
01-11 685
题目链接 纪念第一次补全cf： 感动~~ A. Plus One on the Subset 题目大意：给出一个数组，每次我们可以选几个数+1，问至少多少次使得该数组中所有数大小相等。 签到 输出最大值 - 最小值即可， 因为对于每个数每次我们都只能使其增加1. #include <bits/stdc++.h> using namespace std; typedef long long LL; int main(void) { int T; scanf("%d", &a
2020牛客暑期多校2 C
最新发布
10-01
引用是一段C++代码，涉及到图的遍历和操作。代码的功能是根据给定的树，选择最少的点对，使得所有的边都被覆盖。具体思路是，首先确定点对的数量为叶子节点数除以2，然后通过DFS序找出叶子节点，每次选择编号为i和i+...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值