8.25 Codeforces Round 827 (Div. 4)

已于 2024-01-09 18:06:49 修改
阅读量105 收藏
点赞数 1
分类专栏： c++刷题记录 文章标签： 算法 c++ 数据结构 程序人生 动态规划 贪心算法 散列表
于 2023-08-25 12:26:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69367351/article/details/132493070
版权

A Sum

分析： 判断三个数是否存在x+y=z的情况

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
#define int long long
int t, n, k;
const int N = 2e4 + 10;
​
void solve() {
    int a, b, c;
    cin >> a >> b >> c;
    if ((a + b) == c || (a + c) == b || (a == (b + c))) cout << "YES" << endl;
    else cout << "NO" << endl;
}
​
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
​
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

B Increasing

分析： 先将数都存入 sort 最后判断是否有等于的情况！

用vector为什么是错的？ 因为你申请空间过大，会存在值为0的情况 排序直接会将0放在前面，判断时为false

更正代码（vector）
void solve() {
    cin >> n;
    vector<int> v(n);
    for (int i = 0; i < n; i++) cin >> v[i];
    sort(v.begin(), v.end());
    bool flag = true;
    for (int i = 1; i < n; i++) {
        if (v[i] == v[i - 1]) {
            flag = false;
            break;
        }
    }
    if (flag) cout << "YES" << endl;
    else cout << "NO" << endl;
}
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
#define int long long
int t, n, k;
const int N = 2e4 + 10;
int a[105];
​
void solve() {
    cin >> n;
    for (int i = 0; i < n; i++) cin >> a[i];
    sort(a, a + n);
    bool flag = true;
    for (int i = 1; i < n; i++) {
        if (a[i] == a[i - 1]) {
            flag = false;
            //cout << "false" << i<< endl;
            break;
        }
    }
    if (flag) cout << "YES" << endl;
    else cout << "NO" << endl;
}
​
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
​
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

知识点：

c++之vector初始化指定大小容量

1.一维

vector<int> v(size);
vector<int> v;//这样size为0 不初始化容量会报错！
v.resize(size);//resize！！！

2.二维

//(外部size，内部size vector<int>(lsize,0))
vector<vector<int>> v(rsize,vector<int>(lsize,0));//内部要带类型！

C Stripes

分析：

看清题目意思 只有横排R 纵列B！直接判断横排R个数是否为8 不是输出B 是输出R

你可以每次只输入一个字符串来判断 不用一次性将一整个图输入！

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
#define int long long
int t, n;
//char g[10][10];
​
void solve() {
    string s;
    bool flag = false;
    for (int i = 0; i < 8; i++) {
        cin >> s;
        int cnt = 0;
        for (int j = 0; j < 8; j++) {
            if (s[j] == 'R') cnt++;
        }
        if (cnt == 8) flag = true;
    }
    if (flag) cout << "R" << endl;
    else cout << "B" << endl;
}
​
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
​
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

D Coprime

分析：如果直接暴力 时间复杂度是O(2^n) 爆，所以贪心，将注意力放大每个数的值上去1000很小 所以每次记录某个数出现的最大的坐标，枚举1000*1000次 看这两个数是否存在和是否互质

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
#define int long long
int t, n;
const int N = 2e5 + 10;
//char g[10][10];
int a[N];
​
void solve() {
    cin >> n;
    map<int, bool> mp;
    map<int, int> p;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        mp[a[i]] = 1;
        p[a[i]] = i;//因为坐标是不断变大的  所以直接等于
    }
    int ans = 0;
    for (int i = 1; i <= 1000; i++) {
        for (int j = 1; j <= 1000; j++) {
            if (mp[i] && mp[j] && __gcd(i, j)==1) {
                ans = max(ans, p[i] + p[j]);
            }
        }
    }
    cout << ans << endl;
}
​
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
​
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

知识点:

不要不舍得开 要存就开 能写就开 尽量往简单好写靠近！

两数互质：__gcd(x,y) ==1 即两数最大公约数为1

E Scuza

分析：二分+前缀和 暴力会超时，可以用二分，构建两个数组，一个是a[i],作为前缀和数组，一个是f[i]表示第i个台阶之前的高度最大的台阶，然后每次二分来查找k，因为尽可能走的更多，所以查找有边界，最后输出对应的前缀和。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
#define int long long
int t, n, q, k;
const int N = 2e5 + 10;
//char g[10][10];
int a[N];
​
void solve() {
    cin >> n >> q;
    vector<int> a(n + 5);//前缀和数组
    vector<int> v(n + 5);//这个阶梯之前高度最大的阶梯
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        v[i] = max(v[i - 1], a[i]);
        a[i] += a[i - 1];
    }
    while (q--) {
        cin >> k;
        int l = 1, r = n;
        while (l < r) {
            int mid = (l + r + 1) >> 1;
            if (v[mid] <= k) l = mid;
            else r = mid - 1;
        }
        if (v[l] <= k) cout << a[l] << " ";
        else cout << 0 << " ";
    }
    cout << endl;
}
​
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
​
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

F Smaller

分析： 每次对字符串s或t进行操作，判断是否按照题目要求字符串s小于t ，两种情况：

1.字符串t存在一个不为a的字符

2.t全为a s也全为a 但是s的长度小于t

完全不需要定义s和t！只用加上a的个数！

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
#define int long long
int t, n, q, k;
const int N = 2e5 + 10;
int a[N];

void solve() {
	cin >> q;
	bool othera = false, otherb = false;
	int cnta = 0, cntb = 0;
	while (q--) {
		int d, k; string x; cin >> d >> k >> x;
		for (auto c : x) {//此形式！c就相当于x中的每个元素！
			if (d == 1) {
				if (c != 'a') othera = 1;
				else cnta += k;//每个字符a都要加这么多遍
			}
			else {
				if (c != 'a') otherb = 1;
				else cntb += k;
			}
		}
		if (otherb) cout << "YES" << endl;
		else if (!othera && cnta < cntb) cout << "YES" << endl;
		else cout << "NO" << endl;
	}
}

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

	cin >> t;
	while (t--) {
		solve();
	}
	return 0;
}

G Orray（没太搞明白）

只有前log2(maxval)个元素是重要的 因为在以最佳方式放置这些元素后，我们可以确定所有可以在前缀or中设置的位都已经设置好了。因此我们可以蛮力选择log2(maxval)次选择（如果一个元素在所有未使用的元素中提供了最大的新前缀or值，我们就选择添加该元素），然后只添加其余未使用的元素

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
//#define int long long 
int t, n, q;

void solve() {
	cin >> n;
	vector<int> a(n);
	for (int i = 0; i < n; i++) cin >> a[i];
	int cur = 0;
	vector<bool> vis(n, false);
	for (int i = 0; i < min(31, n); i++) {
		int mx = 0, idx = -1;
		for (int j = 0; j < n; j++) {
			if (vis[j]) continue;
			if ((cur | a[j]) > mx) {
				mx = (cur | a[j]);
				idx = j;
			}
		}
		vis[idx] = true;
		cout << a[idx] << " ";
		cur |= a[idx];
	}
	for (int i = 0; i < n; i++) if (!vis[i])cout << a[i] << " ";
	cout << endl;
}

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

	cin >> t;
	while (t--) {
		solve();
	}
	return 0;
}
要坚持自己思考，认真vp认真补题！及时回看！
Cythia-1
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
刷题计划(暑假)
weixin_34292959的博客
07-06 241
暂定每天更新。 tot : 137 + 6 7.7 1. P1378 油滴扩展 (done) 2. P1306 斐波那契公约数 (实力不足) 3. Bugs Integrated, Inc.(加深理解三进制dp) (未完成) 4. UVa12206 Stammering Aliens (复习字符串hash) (done) 5. P2863 [USACO06JAN]牛的舞会The C...
电子元器件技术培训(ppt 78)(8.25MB).part4.rar
08-16
电子元器件技术培训(ppt 78)(8.25MB).part4.rar
checkstyle-8.25-all.jar
10-26
1，一款Java代码格式自动调整插件，很好用，能够让你的代码整洁，进而锻炼出整洁的书写习惯。
Plex_v8.25.0.28473_MOD.apk
11-13
Plex_v8.25.0.28473_MOD.apk
customer8.25.crx
11-23
customer8.25.crx
电子元器件技术培训(ppt 78)(8.25MB).part2.rar
08-16
电子元器件技术培训(ppt 78)(8.25MB).part2.rar
【18】输出字符菱形
2301_78786609的博客
07-19 418
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 365
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
算法题目整合5
最新发布
qq_62571233的博客
07-23 667
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 597
AtCoder Beginner Contest 363 ABCDE
2024.7.19 刷题总结
TheJustice_的博客
07-19 276
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 486
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 287
完全二叉树的节点个数-递归
python实现图像缩放算法
qq_42568323的博客
07-20 365
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 202
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
算法第十一天：leetcode707.设计链表
m0_75068978的博客
07-19 1468
的链接如下表所示，您可直接复制下面网址进入力扣学习，在观看下面的内容之前一定要先做一遍哦，这样才能印象深刻！题目描述：你可以选择使用单链表或者双链表，设计并实现自己的链表。val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果是双向链表，则还需要属性prev以指示链表中的上一个节点。假设链表中的所有节点下标从开始。实现index-1valvalvalindexindexindexindex// 链表变为 1->2->3// 返回 2。
【刷题汇总 -- 压缩字符串(一)、chika和蜜柑、 01背包】
m0_69455439的博客
07-19 1150
今日刷题汇总day018 -- 压缩字符串(一)、chika和蜜柑、 01背包
算法——滑动窗口（day5）
fax_player的博客
07-20 835
（上一题是通过缩小窗口来求长度最小，所以每一次缩小都有可能得到最小长度）（而本题是求最大连续长度，只需要在去除所有重复项后计算就行了）
将-8.25放在寄存器中，求寄存器的内容
12-07
根据IEEE 754单精度浮点数格式，一个32位的float型数据可以分为三个部分：符号位、指数位和尾数位。其中符号位占1位，指数位占8位，尾数位占23位。对于一个负数，符号位为1，其余位为其绝对值的二进制表示。对于指数位和尾数位，需要将-8.25转化为二进制表示。 首先将8转化为二进制，得到1000，然后将小数部分0.25转化为二进制，得到0.01。将这两个二进制数拼接起来，得到1000.01。接下来需要将这个二进制数规格化，即将小数点左移3位，得到1.00001。因此指数位为3+127=130，转化为二进制为10000010。尾数位为00001000000000000000000。 最后将符号位、指数位和尾数位拼接起来，得到32位的二进制数为11000001000001000000000000000000。将其转化为十六进制，即可得到寄存器的内容为C1040000。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值