Codeforces Round #697 (Div. 3)A~G解题报告

最新推荐文章于 2022-12-22 14:57:57 发布
最新推荐文章于 2022-12-22 14:57:57 发布
阅读量125 收藏
点赞数
分类专栏： CodeForces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45573921/article/details/113653851
版权

Codeforces Round #697 (Div. 3)A~G解题报告

题 A Odd Divisor

题目介绍

在这里插入图片描述

解题思路

乍一想本题，感觉有点迷迷糊糊，但是证难则反，直接考虑没有奇数因子的情况，即 N = 2 i 2^{i} 2i,那么当N != 2 i 2^i 2i时，就有 奇数因子
注意使用 LL

AC代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

typedef long long LL;

bool Check(LL x)
{
    while (x != 1)
    {
        if (x & 1)
        {
            return true;
        }
        x >>= 1;
    }
    return false;
}

int main()
{
    LL n;
    int t;
    cin >> t;
    while (t -- )
    {
        scanf("%lld", &n);
        if (Check(n))
        {
            cout << "YES" << endl;
        }
        else
        {
            cout << "NO" << endl;
        }
    }
    return 0;
}

题 B New Year’s Number

题目介绍

在这里插入图片描述

解题思路

直接就是一个 dp裸题，倘若 x 是2021 与 2020 的若干和，那么 x == 2020 或 x ==2021或者x - 2020 满足要求 或者 x - 2021满足要求
有了上述的递推公式，直接开bool数组进行动态规划即可

AC代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

typedef long long LL;
const int N = 1000010;
bool st[N];

int main()
{
    int n;
    int t;
    cin >> t;
    st[2020] = st[2021] = true;
    for (int i = 2023; i < N; i ++ )
    {
        st[i] = st[i - 2021] | st[i - 2020];
    }
    while (t -- )
    {
        scanf("%d", &n);
        if (st[n])
        {
            cout << "YES\n";
        }
        else
        {
            cout << "NO\n";
        }
    }
    return 0;
}

题 C Ball in Berland

题目介绍

在这里插入图片描述

解题思路

同样是直接统计不太方便，我们直接反向思考，计算出总方案数量，减去不合法方案数量，得到结果
总方案数量 = k * (k - 1) / 2
不合法方案数量 = 同一个男生被选中两次 + 同一个女生被选中两次
记得开 LL

AC代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

typedef long long LL;
const int N = 200010;
int boy_cnt[N], girl_cnt[N];
int n, m, k;

int main()
{
    int t;
    cin >> t;
    LL res = 0;
    while (t -- )
    {
        scanf("%d%d%d", &n, &m, &k);
        res = LL(k) * (k - 1);
        memset(boy_cnt, 0, sizeof boy_cnt);
        memset(girl_cnt, 0, sizeof girl_cnt);
        for (int i = 1; i <= k; i ++ )
        {
            static int tmp;
            scanf("%d", &tmp);
            boy_cnt[tmp] ++;
        }
        for (int i = 1; i <= k; i ++ )
        {
            static int tmp;
            scanf("%d", &tmp);
            girl_cnt[tmp] ++;
        }

        for (int i = 1; i <= n; i ++ )
        {
            res -= LL(boy_cnt[i]) * (boy_cnt[i] - 1);
        }
        for (int i = 1; i <= m; i ++ )
        {
            res -= LL(girl_cnt[i]) * (girl_cnt[i] - 1);
        }
        /// cout << "#############\n";
        printf("%lld\n", res / 2);
        /// cout << res / 2 << endl;
    }
    return 0;
}

题 D Cleaning the Phone

题目介绍

在这里插入图片描述

解题思路

错误思路
本来将题目想成了 dp 进行求解，直接超时没商量，考虑一下复杂度，确实有问题
O(N*2N)太大
正解
这个题目应该进行贪心的，先处理出来 b i b_i bi​=1数组， b i b_i bi​=2数组，然后对数组可以清空的内存进行排序。
排序后进行求取数组的前缀和，方便我们下面两种做法降低复杂度。
下面有两种问题的求解办法，
方法一、二分
对于 对于 每个 b i b_i bi​=1的下标进行枚举，然后对 b i b_i bi​=2数组进行二分，查找到满足释放内存的最小前缀数组的下标。 O ( N l o g ( N ) ) O(Nlog(N)) O(Nlog(N))
方法二、双指针
先找到一个合法解，然后数组下标进行移动，另一个指针作相应的调整即可。 O ( N ) O(N) O(N)
但是算上排序，最终复杂度为 O ( N l o g ( N ) ) O(Nlog(N)) O(Nlog(N))

但是本题有一个最狗的地方，cmp函数被卡了，可以直接写归并排序，或者cmp函数别写等号，否则会超时

AC代码

双指针
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

typedef long long LL;

const int N = 200010, INF = 0x3f3f3f3f;
LL a[N];
LL c[N], d[N];
LL n, m;
int idx1, idx2;

bool cmp(LL x, LL y){ return x > y; }
void show()
{
    for (int i = 1; i <= idx1; i ++ )   cout << c[i] << " ";    cout << endl;
    for (int i = 1; i <= idx2; i ++ )   cout << d[i] << " ";    cout << endl;
}

int main()
{
    int T;  cin >> T;
    while (T -- )
    {
        scanf("%lld %lld", &n, &m);
        for (LL i = 1; i <= n; i ++ )
            scanf("%lld", &a[i]);
        c[0] = d[0] = 0LL;
        idx1 = idx2 = 0;
        for (LL i = 1, b; i <= n; i ++ )
        {
            scanf("%lld", &b);
            if (b & 1)  c[++ idx1] = (a[i]);
            else    d[++ idx2] = (a[i]);
        }
        sort(c + 1, c + idx1 + 1, cmp);
        sort(d + 1, d + idx2 + 1, cmp);
        /// show();
        for (int i = 1; i <= idx1; i ++ )   c[i] += c[i - 1];
        for (int i = 1; i <= idx2; i ++ )   d[i] += d[i - 1];
        /// show();
        if (c[idx1] + d[idx2] < m)
        {
            printf("-1\n");
        }
        else
        {
            int i, j, res = INF;
            for (i = 0; i <= idx1; i ++ )   // 尺取法的起点
                if (c[i] + d[idx2] >= m)    // c[i] 的开头
                    break;
            j = idx2;

            res = min(res, i + j + j);

            // 此时i， j可以进行 尺取法 了
            while (i <= idx1 && j >= 0)
            {
                while (j >= 0 && i <= idx1 && c[i] + d[j] < m)
                {
                    i ++;
                }
                if (i <= idx1 && j >= 0)
                    res = min(res, i + j + j);
                while (i <= idx1 && j >= 0 && c[i] + d[j] >= m)
                {
                    if (i <= idx1 && j >= 0)
                        res = min(res, i + j + j);
                    j --;
                }

            }
            if (res == INF) res = -1;
            printf("%d\n", res);
        }
    }
    return 0;
}
二分
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

typedef long long LL;
const int N = 200010, INF = 0x3f3f3f3f;
int n, m;
int a[N];
LL c[N], d[N];
int szc, szd;


bool cmp(LL a, LL b)
{
    return a > b;
}
int main()
{
    int T;  cin >> T;
    while (T -- )
    {
        static int b;
        cin >> n >> m;
        for (int i = 1; i <= n; i ++ )  scanf("%d", &a[i]);
        c[0] = d[0] = szc = szd = 0;
        for (int i = 1; i <= n; i ++ )
        {
            scanf("%d", &b);
            if (b & 1)
                c[++ szc] = a[i];
            else
                d[++ szd] = a[i];
        }
        sort(c + 1, c + szc + 1, cmp);
        sort(d + 1, d + szd + 1, cmp);

        for (int i = 1; i <= szc; i ++ )    c[i] += c[i - 1];
        for (int i = 1; i <= szd; i ++ )    d[i] += d[i - 1];

        if (c[szc] + d[szd] < m)
        {
            puts("-1");
        }
        else
        {
            int res = INF;
            for (int i = 0; i <= szc; i ++ )
            {
                if (c[i] + d[szd] < m)
                    continue;
                else if (c[i] >= m)
                {
                    res = min(res, i);
                    break;
                }
                else
                {
                    static int tmp;
                    tmp = lower_bound(d + 1, d + 1 + szd, m - c[i]) - d;
                    res = min(res, tmp + tmp + i);
                }
            }
            cout << res << endl;
        }

    }

    return 0;
}

题 E Advertising Agency

题目介绍

在这里插入图片描述

解题思路

肯定是先对 博主的 粉丝数量进行排序，贪心的请博主即可，这个题目主要是求解 排列组合问题。
C i j C_i^j Cij​= C i − 1 j C_{i-1}^j Ci−1j​+ C i − 1 j − 1 C_{i-1}^{j-1} Ci−1j−1​
利用dp直接进行求解，关键是初始化写好就可以了 C i i C_i^i Cii​= C i 0 C_i^0 Ci0​=1

AC代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

typedef long long LL;
const int N = 1010, INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int n, k;
int a[N];
int f[N][N];


bool cmp(LL a, LL b)
{
    return a > b;
}

int main()
{
    memset(f, 0, sizeof f);
    for (int i = 0; i < N; i ++ )
        f[i][i] = f[i][0] = 1;
    for (int i = 1; i < N; i ++ )
        for (int j = 1; j <= i; j ++ )
            f[i][j] = (f[i - 1][j] + f[i - 1][j - 1]) % MOD;

    int T;  cin >> T;
    while (T -- )
    {
        cin >> n >> k;
        for (int i = 1; i <= n; i ++ )
            scanf("%d", &a[i]);
        sort(a + 1, a + n + 1, cmp);

        static int x, sidx, eidx;
        x = a[k], sidx = -1, eidx = -1;
        for (int i = 1; i <= n; i ++ )
        {
            if (a[i] == x)
            {
                if (sidx == -1) sidx = i;
                eidx = i;
            }
        }
        cout << f[eidx - sidx + 1][k - sidx + 1] << endl;

    }

    return 0;
}

题 F Unusual Matrix

题目介绍

在这里插入图片描述

解题思路

题目问的是能否从 A n ∗ n A_{n*n} An∗n​矩阵转换到 B n ∗ n B_{n*n} Bn∗n​矩阵，由转换的性质，同一个行/列转换两次是没有任何作用的，因此我们枚举第一行需要操作/与不需要操作，那么第一行的元素能操作的对象只有列，因此列是否需要操作就得以确定，列确定，那么，反过来行也就得以确定，最终得到结果。

AC代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

typedef long long LL;
const int N = 1010, INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int n;
char a[N][N], b[N][N];
char c[N][N];

inline void Change(char c[][N], int x, bool row);
bool Same(char c[][N], char d[][N], int x)
{
    for (int i = 1; i <= n; i ++ )
        if (c[x][i] != d[x][i])
            return false;
    return true;
}

bool Check(char c[][N], char d[][N])
{
    // 第一行是不需要动的，我们看看 列 的影响
    for (int i = 1; i <= n; i ++ )
        if (c[1][i] != d[1][i])
            Change(c, i, false);
    for (int i = 2; i <= n; i ++ )
    {
        if (c[i][1] != d[i][1]) // 修改 行
            Change(c, i, true);
        if (!Same(c, d, i))
            return false;
    }
    return true;
}
inline void Change(char c[][N], int x, bool row)
{
    if (row)    // row
        for (int i = 1; i <= n; i ++ )
        {
            c[x][i] = 97 - c[x][i];   // 48 + 49 - c[i]
        }
    else        // col
        for (int i = 1; i <= n; i ++ )
        {
            c[i][x] = 97 - c[i][x];   // 48 + 49 - c[i]
        }
}

int main()
{
    int T;  cin >> T;
    while (T -- )
    {
        cin >> n;
        for (int i = 1; i <= n; i ++ )
            scanf("%s", a[i] + 1);
        for (int i = 1; i <= n; i ++ )
            scanf("%s", b[i] + 1);
        memcpy(c, a, sizeof c);

        if (Check(c, b) || (memcpy(c, a, sizeof c), Change(c, 1, true), Check(c, b)))
            puts("YES");
        else
            puts("NO");

    }
    return 0;
}

题 G Strange Beauty

题目介绍

在这里插入图片描述

解题思路

这个题目是一个比较巧妙地dp题目，对于一个 B e u t i f u l A r r a y Beutiful Array BeutifulArray我们将其非降序排序之后可以发现，后面的数字都是可以整除前面的，这是一个充分必要的条件
那么最长的数组对应着最长的整除序列
而且还有 一个坑点，鸡儿数字还可能相等，也就是我们需要先预处理出 X X X出现的次数
定义一个数组 f i f_i fi​表示，以数字 i 作为最大值，可以构成 B e a u t i f u l A r r a y BeautifulArray BeautifulArray的最大长度，
f i f_i fi​ = i i i出现次数+ m a x max max{因子的 j 的 f j f_j fj​}
下面是dp过程，而且为了方便书写，降低时间复杂度，直接将因子的相加写入了 因子的循环中

AC代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

typedef long long LL;
const int N = 200010, INF = 0x3f3f3f3f;

int cnt[N];
int a[N];
bool st[N];
int f[N];
int n;

int main()
{
    int T;  cin >> T;
    while (T -- )
    {
        static int res;
        cin >> n;
        for (int i = 1; i <= n; i ++ )
            scanf("%d", &a[i]);

        res = INF;
        sort(a + 1, a + 1 + n);
        memset(cnt, 0, sizeof cnt);
        memset(st, false, sizeof st);
        memset(f, 0, sizeof f);
        for (int i = 1; i <= n; i ++ )  cnt[a[i]] ++;

        for (int i = 1, val; i <= n; i ++ )
        {
            val = a[i];
            if (st[val])    continue;
            st[val] = true;
            // cnt[val] = max(cnt[val], 1);
            f[val] = f[val] + cnt[val];    // 给自己加的
            for (int j = val + val; j < N; j += val)
            {
                f[j] = max(f[j], f[val]); // 给别的数字加的
            }
            res = min(res, n - f[val]);
        }

        cout << res << endl;

    }
    return 0;
}

本次CF小结

  • 小心快排可能被卡，导致超时，可以通过 修改cmp函数，或者是直接使用 归并排序来解决
  • 其次，考虑问题的时候，尤其是数量的问题，可以使用容斥定理，证难则反
  • 贪心、结合二分、或者是双指针来优化复杂度，有时候考虑dp背包复杂度太高
  • 求解组合数的常用方法要记住， dp，逆元，卢卡斯定理
_luckylight
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
一个长度为n的数组，为删除一些数后，剩下的数能否构成长度大于3的回文数组 思路： 只要能找到两个相等的数，且他们的间距大于2即可 o(n^2)的暴力就能过 比赛时写了一个o(n)的 就是把所有相等的数放到一个vector里，...
D. Cleaning the Phone(枚举+前缀和+二分)
代码笔记本
01-31 320
https://codeforces.com/contest/1475/problem/D 经典两个物品状态的总最优题: #include<iostream> #include<vector> #include<queue> #include<cstring> #include<cmath> #include<map> #include<set> #include<cstdio> #include<a
Codeforces Round #697 (Div. 3) 解题报告
weixin_43911947的博客
01-26 458
题目链接：https://codeforces.com/contest/1475 震惊！2021年1月25日晚上23点，3万余人聚集在codeforces集体上分！导致服务器卡顿，最终整场比赛不计分(⊙﹏⊙) A. Odd Divisor 题目大意 t组数据，每组给你一个整数n，问你n有没有非1的奇数因子，有输出YES，否则输出NO 范围：(1≤t≤1e4，2≤n≤10^14) 思路 位运算。因为他不看偶数因子，那么可以一直除2，然后看最后的n是不是1，如果是1，那么说明都是偶数因子，否则那么
Codeforces Round #805 (Div. 3) 题解（A~F）
Euphria的博客
07-11 352
cf div3
Codeforces Round #839 (Div. 3)
scanner
12-22 343
日常div3练习
Codeforces Round #693 (Div. 3)A~G解题报告
weixin_45573921的博客
02-07 178
Codeforces Round #693 (Div. 3)解题报告 A Cards for Friends 原题信息 解题思路 本题就是一个找 x/2i=old,y/2j=oldx/2^i=old,y/2^j=oldx/2i=old,y/2j=old, 返回 2i∗2j>=n2^i*2^j>=n2i∗2j>=n 一般这样的题目都需要注意使用 LL AC代码 #include <cstdio> #include <cstring> #include <alg
Codeforces Round #738 (Div. 2) A~D1题解
pursuit的博客
08-16 380
文章目录A. Mocha and MathB. Mocha and Red and BlueC. Mocha and HikingD1. Mocha and Diana (Easy Version) A. Mocha and Math 题意 给你一个nnn元素的数组。你可以进行任意次操作选定区间[l,r][l,r][l,r]，使得a[l]=a[l]&a[r],....a[r]=[r]&a[l]a[l] = a[l]\& a[r],....a[r] = [r] \&a[l]
Codeforces Round #629 (Div. 3)解题报告
zzugzx的博客
03-27 314
题目链接 A.Divisibility Problem 题意： 给定a和b，每次a可以加1，问加多少的时候a能整除b给定a和b，每次a可以加1，问加多少的时候a能整除b给定a和b，每次a可以加1，问加多少的时候a能整除b 题解： 直接(a − a%b)就可以了，特判一下原本就能取余的情况直接(a~-~a\%b)就可以了，特判一下原本就能取余的情况直接(a −&nbsp...
Codeforces Round #805 (Div. 3)(A~G2)
m0_56203653的博客
07-14 246
Codeforces Round #805 (Div. 3)(A~G2)
Codeforces Round #686 (Div. 3) 题解
lfy0的博客
08-26 194
文章目录前言总结 前言 总结
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 ...#define rep(i,a,b) for(int i=a;i=b;i--) typedef long long l
Codeforces Round #629 (Div. 3) B. K-th Beautiful String
01-03
解题思路 第一个bbb在倒数第二位有1个字符串，在倒数第三位有2个字符串…在倒数第nnn位时有n−1n-1n−1个字符串 可以根据第一个bbb的位置对字符串进行分组，然后找到第kkk个字符串在第几组里即可，然后再推出第二个...
Codeforces Round #628 (Div. 2) A~~D
01-03
A #include using namespace std; typedef long long ll; int main(){ int t; cin>>t; while(t--){ ll x; cin>>x; cout<<1>>t; while(t--){ st.clear(); ll n; cin >>n; ll re
chromedriver-win64_121.0.6123.0.zip
06-15
chromedriver-win64_121.0.6123.0.zip
Chekiang Shu Ke Sung-mianfeiziti字體下載
最新发布
06-15
Chekiang Shu Ke Sung-mianfeiziti字體下載
中国科学院大学22-23秋季学期 《程序设计基础与实验（C语言）》课程大作业——基于Min-Max搜索策略的五子棋对战程序
06-15
C语言是一种广泛使用的编程语言，它具有高效、灵活、可移植性强等特点，被广泛应用于操作系统、嵌入式系统、数据库、编译器等领域的开发。C语言的基本语法包括变量、数据类型、运算符、控制结构（如if语句、循环语句等）、函数、指针等。在编写C程序时，需要注意变量的声明和定义、指针的使用、内存的分配与释放等问题。C语言中常用的数据结构包括： 1. 数组：一种存储同类型数据的结构，可以进行索引访问和修改。 2. 链表：一种存储不同类型数据的结构，每个节点包含数据和指向下一个节点的指针。 3. 栈：一种后进先出（LIFO）的数据结构，可以通过压入（push）和弹出（pop）操作进行数据的存储和取出。 4. 队列：一种先进先出（FIFO）的数据结构，可以通过入队（enqueue）和出队（dequeue）操作进行数据的存储和取出。 5. 树：一种存储具有父子关系的数据结构，可以通过中序遍历、前序遍历和后序遍历等方式进行数据的访问和修改。 6. 图：一种存储具有节点和边关系的数据结构，可以通过广度优先搜索、深度优先搜索等方式进行数据的访问和修改。 这些数据结构在C语言中都有相应的实现方式，可以应用于各种不同的场景。C语言中的各种数据结构都有其优缺点，下面列举一些常见的数据结构的优缺点： 数组： 优点：访问和修改元素的速度非常快，适用于需要频繁读取和修改数据的场合。 缺点：数组的长度是固定的，不适合存储大小不固定的动态数据，另外数组在内存中是连续分配的，当数组较大时可能会导致内存碎片化。 链表： 优点：可以方便地插入和删除元素，适用于需要频繁插入和删除数据的场合。 缺点：访问和修改元素的速度相对较慢，因为需要遍历链表找到指定的节点。 栈： 优点：后进先出（LIFO）的特性使得栈在处理递归和括号匹配等问题时非常方便。 缺点：栈的空间有限，当数据量较大时可能会导致栈溢出。 队列： 优点：先进先出（FIFO）的特性使得
高级信息通信运行管理员第七套试卷
06-15
这是高级信息通信运行管理员考证试卷
codeforces round #828 (div. 3)
06-06
好的，以下是关于Codeforces Round #828 (Div. 3)的一些信息： Codeforces Round #828 (Div. 3)是Codeforces网站上的一场编程竞赛，属于Div. 3级别的比赛。该比赛于2022年3月1日 15:35 (UTC)开始，比赛时长为2个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值