Codeforces_Round_970_(Div_3)（A - D + F）

最新推荐文章于 2024-11-10 21:54:30 发布
最新推荐文章于 2024-11-10 21:54:30 发布
阅读量633 收藏 28
点赞数 12
分类专栏： codeforces 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anran1110/article/details/141873439
版权

传送门

A. Sakurako’s Exam

分析

  • 由于出现的数中只有 1 1 1 和 2 2 2，所以 1 1 1 只能由 1 1 1 消除，因此如果有奇数个 1 1 1 的话，那么肯定无法 = 0 =0 =0，然后再对 2 2 2 的个数进行奇偶判断即可
/*******************************
| Author:  xiaojianhua1110
| Problem: A. Sakurako's Exam
| Contest: Codeforces Round 970 (Div. 3)
| URL:     https://codeforces.com/contest/2008/problem/A
| When:    2024-09-01 22:35:20
| 
| Memory:  256 MB
| Time:    1000 ms
*******************************/

#include<bits/stdc++.h>
#define all(a) a.begin(), a.end()
using i32 = int;
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
using vi32 = std::vector<int>;
using pii32 = std::pair<int, int>;
using vii32 = std::vector<pii32>;
using vi64 = std::vector<i64>;
using pii64 = std::pair<i64, i64>;
using vii64 = std::vector<pii64>;

void solve() {

    int a, b;
    std::cin >> a >> b;
    if(a == 0) {
        if(b % 2 == 0) {
            std::cout << "YES\n";
        } else {
            std::cout << "NO\n";
        }
    } else if(b == 0) {
        if(a % 2 == 0) {
            std::cout << "YES\n";
        } else {
            std::cout << "NO\n";
        }
    } else {
        if(a % 2 == 0 && b % 2 == 0) {
            std::cout << "YES\n";
        } else if(a % 2 == 1 && b % 2 == 1) {
            std::cout << "NO\n";
        } else if(a % 2 == 1 && b % 2 == 0) {
            std::cout << "NO\n";
        } else {
            std::cout << "YES\n";
        }
    }
}

int main() {
	
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    
    int t;
    std::cin >> t;
    while(t--) {
        solve();
    }

  	return 0;
}

B. Square or Not

分析

  • 要注意到题目说明的是 s q u a r e square square，也就是说最终得到的 m a t r i x matrix matrix一定是个正方形，那么我们可以先得到边长，然后再判断 0 0 0的个数是否满足要求即可（The string is always the result of writing out the strings of a beautiful matrix.）
/*******************************
| Author:  xiaojianhua1110
| Problem: B. Square or Not
| Contest: Codeforces Round 970 (Div. 3)
| URL:     https://codeforces.com/contest/2008/problem/B
| When:    2024-09-01 22:40:31
| 
| Memory:  256 MB
| Time:    2000 ms
*******************************/

#include<bits/stdc++.h>
#define all(a) a.begin(), a.end()
using i32 = int;
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
using vi32 = std::vector<int>;
using pii32 = std::pair<int, int>;
using vii32 = std::vector<pii32>;
using vi64 = std::vector<i64>;
using pii64 = std::pair<i64, i64>;
using vii64 = std::vector<pii64>;

void solve() {
    int n;
    std::cin >> n;
    std::string s;
    std::cin >> s;
    int cnt = std::count(all(s), '1');
    int ok = 0;
    int c = sqrt(n);
    int sum = c * 4 - 4;
    if(sum == cnt) {
        ok = 1;
    }
    if(ok) {
        std::cout << "Yes\n";
    } else {
        std::cout << "No\n";
    }


}

int main() {
	
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    
    int t;
    std::cin >> t;
    while(t--) {
        solve();
    }

  	return 0;
}

C. Longest Good Array

分析

  • 这题可以用贪心的做法，对于 a 1 a_{1} a1​，为了满足要求，应该让 a 2 − a 1 a_{2} - a_{1} a2​−a1​尽量小，同时让 a 3 − a 2 a_{3} - a_{2} a3​−a2​也尽量小并且满足题给条件，结合测试样例来看，以 1 , 2 , 3... 1, 2, 3... 1,2,3...的幅度为增加最是最优的，因此只需要注意判断一下边界条件即可
/*******************************
| Author:  xiaojianhua1110
| Problem: C. Longest Good Array
| Contest: Codeforces Round 970 (Div. 3)
| URL:     https://codeforces.com/contest/2008/problem/C
| When:    2024-09-01 22:46:35
| 
| Memory:  256 MB
| Time:    2000 ms
*******************************/

#include<bits/stdc++.h>
#define all(a) a.begin(), a.end()
using i32 = int;
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
using vi32 = std::vector<int>;
using pii32 = std::pair<int, int>;
using vii32 = std::vector<pii32>;
using vi64 = std::vector<i64>;
using pii64 = std::pair<i64, i64>;
using vii64 = std::vector<pii64>;

void solve() {

    int l, r;
    std::cin >> l >> r;
    int gap = 1;
    int cur = l;
    int ans = 0;
    while(cur < r) {
        if(cur + gap <= r) {
            cur += gap;
            gap++;
            ans++;
        } else {
            break;
        }
    }
    std::cout << ans + 1 << "\n";

}

int main() {
	
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    
    int t;
    std::cin >> t;
    while(t--) {
        solve();
    }

  	return 0;
}

D. Sakurako’s Hobby

分析

  • 由于题给的是一个排列，每个数只会出现一次，因此任意数在有限次内都会回到自身，并且该过程所经过的数也同样会经过同样的数，只不过是顺序不一，因此可以用 D S U DSU DSU将属于同一组的数并起来，最后只需要查找 s i z siz siz即可
/*******************************
| Author:  xiaojianhua1110
| Problem: D. Sakurako's Hobby
| Contest: Codeforces Round 970 (Div. 3)
| URL:     https://codeforces.com/contest/2008/problem/D
| When:    2024-09-01 22:50:59
| 
| Memory:  256 MB
| Time:    2000 ms
*******************************/

#include<bits/stdc++.h>
#define all(a) a.begin(), a.end()
using i32 = int;
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
using vi32 = std::vector<int>;
using pii32 = std::pair<int, int>;
using vii32 = std::vector<pii32>;
using vi64 = std::vector<i64>;
using pii64 = std::pair<i64, i64>;
using vii64 = std::vector<pii64>;

struct DSU
{
    std::vector<int> f,siz;

    DSU() {}
    DSU(int n){
        init(n);
    }

    void init(int n){
        f.resize(n);
        std::iota(f.begin(), f.end(), 0);
        siz.assign(n, -1);
    }

    int find(int x){
        while(x!=f[x]){
            x = f[x] = f[f[x]];
        }
        return x;
    }

    bool same(int x,int y){
        return find(x) == find(y);
    }

    bool merge(int x,int y){
        x = find(x);
        y = find(y);
        if(x == y){
            return false;
        }
        siz[x] += siz[y];
        f[y] = x;
        return true;
    }

    int size(int x){
        return siz[find(x)];
    }
};

void solve() {

    int n;
    std::cin >> n;
    vi32 a(n);
    for(int i = 0; i < n; i++) {
        std::cin >> a[i];
    }
    std::string s;
    std::cin >> s;
    DSU dsu(n);
    for(int i = 0; i < n; i++) {
        if(s[i] == '0') {
            dsu.siz[i] = 1;
        } else {
            dsu.siz[i] = 0;
        }
    }
    for(int i = 0; i < n; i++) {
        dsu.merge(i, a[i] - 1);
    }
    for(int i = 0; i < n; i++) {
        std::cout << dsu.siz[dsu.find(i)] << " ";
    }
    std::cout << "\n";
}

int main() {
	
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    
    int t;
    std::cin >> t;
    while(t--) {
        solve();
    }

  	return 0;
}

F. Sakurako’s Box

分析

  • 题目意思很明确，让我们求所有数两两相乘然后除以个数 % 1 0 9 + 7 10^9 + 7 109+7即可，对于求两两相乘，可以用前缀和进行优化，个数就是个等差数列的公式即可
/*******************************
| Author:  xiaojianhua1110
| Problem: F. Sakurako's Box
| Contest: Codeforces Round 970 (Div. 3)
| URL:     https://codeforces.com/contest/2008/problem/F
| When:    2024-09-01 22:51:01
| 
| Memory:  256 MB
| Time:    2000 ms
*******************************/

#include<bits/stdc++.h>
#define all(a) a.begin(), a.end()
using i32 = int;
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
using vi32 = std::vector<int>;
using pii32 = std::pair<int, int>;
using vii32 = std::vector<pii32>;
using vi64 = std::vector<i64>;
using pii64 = std::pair<i64, i64>;
using vii64 = std::vector<pii64>;

template<class T>
constexpr T power(T a, i64 b) {
    T res = 1;
    for (; b; b /= 2, a *= a) {
        if (b % 2) {
            res *= a;
        }
    }
    return res;
}

constexpr i64 mul(i64 a, i64 b, i64 p) {
    i64 res = a * b - i64(1.L * a * b / p) * p;
    res %= p;
    if (res < 0) {
        res += p;
    }
    return res;
}

template<int P>
struct MInt {
    int x;
    constexpr MInt() : x{} {}
    constexpr MInt(i64 x) : x{norm(x % getMod())} {}
    
    static int Mod;
    constexpr static int getMod() {
        if (P > 0) {
            return P;
        } else {
            return Mod;
        }
    }
    constexpr static void setMod(int Mod_) {
        Mod = Mod_;
    }
    constexpr int norm(int x) const {
        if (x < 0) {
            x += getMod();
        }
        if (x >= getMod()) {
            x -= getMod();
        }
        return x;
    }
    constexpr int val() const {
        return x;
    }
    explicit constexpr operator int() const {
        return x;
    }
    constexpr MInt operator-() const {
        MInt res;
        res.x = norm(getMod() - x);
        return res;
    }
    constexpr MInt inv() const {
        assert(x != 0);
        return power(*this, getMod() - 2);
    }
    constexpr MInt &operator*=(MInt rhs) & {
        x = 1LL * x * rhs.x % getMod();
        return *this;
    }
    constexpr MInt &operator+=(MInt rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    constexpr MInt &operator-=(MInt rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    constexpr MInt &operator/=(MInt rhs) & {
        return *this *= rhs.inv();
    }
    friend constexpr MInt operator*(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res *= rhs;
        return res;
    }
    friend constexpr MInt operator+(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res += rhs;
        return res;
    }
    friend constexpr MInt operator-(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res -= rhs;
        return res;
    }
    friend constexpr MInt operator/(MInt lhs, MInt rhs) {
        MInt res = lhs;
        res /= rhs;
        return res;
    }
    friend constexpr std::istream &operator>>(std::istream &is, MInt &a) {
        i64 v;
        is >> v;
        a = MInt(v);
        return is;
    }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a) {
        return os << a.val();
    }
    friend constexpr bool operator==(MInt lhs, MInt rhs) {
        return lhs.val() == rhs.val();
    }
    friend constexpr bool operator!=(MInt lhs, MInt rhs) {
        return lhs.val() != rhs.val();
    }
};

template<>
int MInt<0>::Mod = 998244353;

template<int V, int P>
constexpr MInt<P> CInv = MInt<P>(V).inv();

constexpr int P = 1000000007;
using Z = MInt<P>;

void solve() {

    int n;
    std::cin >> n;
    std::vector<Z> a(n);
    for(int i = 0; i < n; i++) {
        std::cin >> a[i];
    }
    std::vector<Z> b(n);
    b[0] = a[0];
    for(int i = 1; i < n; i++) {
        b[i] = b[i - 1] + a[i];
    }
    Z ans = 0;
    for(int i = 1; i < n; i++) {
        ans += a[i] * b[i - 1];
    }
    Z cnt = Z(n) * Z(n - 1) / Z(2);
    std::cout << ans / cnt << "\n";
}

int main() {
	
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    
    int t;
    std::cin >> t;
    while(t--) {
        solve();
    }

  	return 0;
}
2004xjh
关注
专栏目录
Codeforces Round 974 (Div. 3) A-F
swan416的博客
09-22 2516
下午的ICPC网络赛的难受一晚上全都给我打没了 手速拉满再加上秒杀线段树 这场简直了啊 唯一可惜的是最后还是掉出了1000名 一把上蓝应该没啥希望了吧
Codeforces Round 962 (Div3) A-C题解
2301_79967286的博客
07-27 930
题目大意：给定你两个字符串 每次给定一个范围l
Codeforces Round 874 (Div. 3)A-F
LEVIATHANq的博客
05-20 778
思路:这个数组里面所有数值连在一起不是环就是链，如果找最大值就是判断环和链的个数，这个可以用并查集，如果是找最小值的话，就是找最大的环，但是数组中的这些小环是不可能拆开组成最大环的，而链可以一起组成最大环，所以找完最大环后，还有把这些小环的个数加上。再将每一个brr[i]的值填入对应的arr[i]的second中.因为idex组成的3 2 1 是fa的一个排列，所以这是一个环，代码中排断环，我是用异或，即将fa和idex一起异或，得出的数要是0，说明就是个环，否则是个链。思路:太麻烦了，不想说。
Codeforces Round 981 div3 个人题解(A~G)
Lazy_ChessPlayer的博客
10-25 1594
Codeforces Round 981 div3 个人题解(A~G)
Codeforces_Round_#622(Div. 2)_C.Skyscraper_非官方解法
01-03
题意： 给了一堆楼 要求 不能存在 i < j> aja_jaj​ < aka_kak​ 的情况 不一定非要挨着 楼高有限制 不得超过mim_imi​ 官方题解是 单调栈 正着一遍 反着一遍就可以了 正着：dp［i］前i个保持递增序列的最大前缀...
CodeForces_Div2_276_A +鸽巢原理
mbanyan的博客
10-03 264
一.鸽巢原理（抽屉原理） 1.基础点 把ｎ＋１个物体放入n个盒子里，则至少有一个盒子里含有两个或两个以上的物体 。 2.强化点 当n只鸽子飞进m个巢时，必定至少有一个巢中飞进了r只 3.运用 只用于证明是否存在的问题 二.Codeforces Round #276 (Div. 2) A.Factory 1.题目的意思是说：第一天有a个材料，每天多生成a%m个材料，当a%m=0时，停止生产计划。 2.暴力可以直接解，比如m是[1,1e5],那么循环1e6就可。 3.找规律，当a%m为前面出现过的余数时，必回
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
今天CF被D恶心到了，写个题解重新整理下思路，（20开始想，25写完暴力代码，1.30才过，优化后的。。 核心思路就是在暴力的基础上进行组合数等差加速。 C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m 我们发现内层...
codeforces round 962 (div. 3)tion-ma笔记
07-29
codeforces round 962 (div. 3)tion-ma笔记
Codeforces Round #756 (Div. 3)题解A-F
Arctic_Clam的博客
11-26 598
Codeforces Round #756 (Div. 3) A. Make Even 分析: 三种情况 本身是偶数, 答案为0 十进制最高位是偶数, 答案为1 十进制非最高位存在偶数, 答案为2 代码: #include <bits/stdc++.h> using namespace std; //#pragma GCC optimize(2) #define close(); ios::sync_with_stdio(false); #define endl '\n' #define
Codeforces Round-866-div.2 A + B
samewide的博客
04-21 325
但其实看一下样例就明白了，就是每次把最左边的数字放在最开头，总共可以操作n次，这样就可以形成一个由01组成的矩阵，然题目要求输出的即由1形成的最大矩形（矩形中每一个元素都是1）的面积（即矩形内所有数字1的数量）。首先要明确的是，三角形的边长必然是字符串中1的最长连续序列（循环中的最长，首尾都是1的时候是可以合并起来的），这样我们就可以把两个s首位相接，然后求s中1最长的连续子序列，即为三角形的边长。则上述两种情况可以归并成一种，如果三角形的边长是n（无论奇偶），则矩形中1的数量为。，则矩形中1的数量是。
Codeforces Round #555 (Div. 3), problem: (E) Minimum Array【贪心+二分 lower_bound+multiset初见】
超逸の学习技术博客
09-28 384
题目链接 题目大意 给你两个长度为n的数组，记为a和b，然后我们可以对b数组进行排序，来获得一个新的数组c，c数组通过(ai+bj)%n求得，最后我们要使得c数组的字典序最小 题解 暴力o(n ^ 2 )会超时。 由题意，要使得数组c的字典序最小，很明显是个贪心的题，即我们每次ab数组相加后取余得到的值每次要最小，即ai+bi大于n并且最接近n，如果相加不能大于或者等于n的话，那么我们就用最小的...
STL set
hls0611的博客
11-09 206
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
100种算法【Python版】第51篇——希尔排序
AnFany
11-06 313
100种算法【Python版】第51篇——希尔排序
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 363
Leetcode 160. 相交链表
洛谷 P2239 [NOIP2014 普及组] 螺旋矩阵
jzwalliser的博客
11-09 916
本文由Jzwalliser原创，发布在CSDN平台上，遵循CC 4.0 BY-SA协议。因此，若需转载/引用本文，请注明作者并附原文链接，且禁止删除/修改本段文字。
GJ Round (2024.10) Round 8~21
lunjiahao的博客
11-06 857
前言： 点此 返回 GJ Round 目录 Round 8 (10.5) A 给定 nnn 个区间，每个区间 [li,ri][l_i,r_i][li​,ri​]，最大化选取区间对数，使得每对区间 [li,ri],[lj,rj][l_i,r_i],[l_j,r_j][li​,ri​],[lj​,rj​] 满足 [li,ri]∩[lj,rj]=∅[l_i,r_i] \cap [l_j,r_j] =\varnothing[li​,ri​]∩[lj​,rj​]=∅ 先按 lil_ili​ 从小到大排序，再按
【刷题】优选算法
林宇恒的博客
11-06 481
如图，我们先算出最左边(1)和最右边(7)围起来的容量，然后，7不动，1继续和7的左边3，8，4...遍历算出容量，你会发现底是不断缩短的，同时高一直都是1，因为高只有两种情况，比它小或和它相等，所以1和7左边的值算出来的容量都是比1和7的容量小的，因为底在不断变小同时高可能不变也可能变小。根据两个实例和鸽巢原理可以发现不断的平方和最终都会形成环，所以我们可以联想到用快慢指针，慢指针走一步，快指针走两步，最终会在环相遇，判断相遇时是否为1。第一个实例是快乐数，因为会变为1且不断是1的循环。
力扣－每日温度
最新发布
m0_63056769的博客
11-10 71
这是我的第一个思路 虽然可以得到正确答案 但是过于暴力 已经超出了时间限制。
【LeetCode】【算法】416. 分割等和子集
passer__jw767的博客
11-06 304
LeetCode 416. 分割等和子集
69. x 的平方根
学习历程记录和分享
11-06 180
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5。由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去。给你一个非负整数 x ，计算并返回 x 的 算术平方根。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值