Hello 2024（A~D,F1）

新年坐大牢

A - Wallet Exchange 

        题意：共有俩钱包，每回合从其中一个钱包中拿走一块钱，谁拿走最后一块钱谁赢。

        思路：奇偶讨论即可。

// Problem: A. Wallet Exchange
// Contest: Codeforces - Hello 2024
// URL: https://codeforces.com/contest/1919/problem/0
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	LL a , b;
	cin >> a >> b;
	LL t = a + b;
	if(t & 1){
		cout <<"Alice\n";
	}	
	else{
		cout<<"Bob\n";
	}
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

B - Plus-Minus Split 

        题意：给定一个"+-"串,其中"+"代表了‘’+1“,"-”代表了“-1”.你需要将整个串分成若干份，每一份的价值为子串所代表的数的绝对值,求整个串的最小价值.

        思路：贪心,其实整个串的价值就是最小价值.

        

// Problem: B. Plus-Minus Split
// Contest: Codeforces - Hello 2024
// URL: https://codeforces.com/contest/1919/problem/B
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n;
	int ans = 0;
	string s;
	cin >> s;
	for(int i = 0 ; i < n ; i ++){
		if(s[i] == '+'){
			ans++;
		}
		else{
			ans--;
		}
	}	
	cout << abs(ans) << endl;
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

C - Grouping Increases 

        题意：给定一个数组,要求将其分成两部分,要求每部分中元素在原数组中的相对位置不能改变,每一部分的价值为：这一部分中,前一个数小于后一个数的个数.求两部分价值之和的最小值。

        思路:可以想到,由于无法改变相对顺序,我们需要从前往后的插入元素.而每一部分的最后一个元素值应当越大越好。因此我们每次插入元素只需要插入到两个部分中尾数小的那部分即可,然后再算出总共价值就是最小价值.

        

    // Problem: C. Grouping Increases
    // Contest: Codeforces - Hello 2024
    // URL: https://codeforces.com/contest/1919/problem/C
    // Memory Limit: 256 MB
    // Time Limit: 1000 ms
    // 
    // Powered by CP Editor (https://cpeditor.org)
     
    #include <bits/stdc++.h>
    using namespace std;
    #define LL long long
    #define pb push_back
    #define x first
    #define y second 
    #define endl '\n'
    const LL maxn = 4e05+7;
    const LL N = 5e05+10;
    const LL mod = 1e09+7;
    const int inf = 0x3f3f3f3f;
    const LL llinf = 5e18;
    typedef pair<int,int>pl;
    priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
    priority_queue<LL> ma;//大根堆
    LL gcd(LL a, LL b){
    	return b > 0 ? gcd(b , a % b) : a;
    }
     
    LL lcm(LL a , LL b){
    	return a / gcd(a , b) * b;
    }
    int n , m;
    vector<int>a(N , 0);
    void init(int n){
    	for(int i = 0 ; i <= n ; i ++){
    		a[i] = 0;
    	}
    }
    void solve() 
    {
    	int rear[2] = {inf , inf};
    	int n;
    	cin >> n;
    	for(int i = 0 ; i < n ; i ++){
    		cin >> a[i];
    	}	
    	int ans = 0;
    	for(int i = 0 ; i < n ; i ++){
    		int cnt = 0;
    		for(int j = 0 ; j < 2 ; j ++){
    			cnt += (rear[j] < a[i]);
    		}
    		if(cnt == 0){
    			if(rear[0] < rear[1]){
    				rear[0] = a[i];
    			}
    			else{
    				rear[1] = a[i];
    			}
    		}
    		else if(cnt == 1){
    			if(rear[0] < a[i]){
    				rear[1] = a[i];
    			}
    			else{
    				rear[0] = a[i];
    			}
    		}
    		else{
    			if(rear[0] < rear[1]){
    				rear[0] = a[i];
    			}
    			else{
    				rear[1] = a[i];
    			}
    			ans++;
    		}
    	}
    	cout << ans << endl;
    }            
    int main() 
    {
        ios::sync_with_stdio(false);
        cin.tie(0);
        cout.tie(0);
        cout.precision(10);
        int t=1;
    	cin>>t;
        while(t--)
        {
        	solve();
        }
        return 0;
    }

F1 - Wine Factory (Easy Version)

        题意：89dae49892db42f5983ab048729a5083.png

88a8e1ee29d34933b473aba12feafc53.png

思路：由于固定了eq?c_%7Bi%7D%20%3D%201e18,也就是前一个水塔的水必定能全部流入后一个水塔.

74de185b108a4143aeb3c0ffafe384e6.png

        这是一开始的eq?O%28N%5E2%29想法，然后发现整个过程其实是一个区间从前往后合并的过程，因此考虑用线段树去解决区间合并问题。

        接下来考虑如何合并：若前面区间还有剩余的水,那么可以由后面的魔法师去变为葡萄酒，因此我们需要知道的是，区间中还剩多少水和区间中的魔法师还剩多少能量。同时我们还可以统计转换了多少葡萄酒。

        每次只需要单点修改和整个区间查询就行了。

// Problem: F1. Wine Factory (Easy Version)
// Contest: Codeforces - Hello 2024
// URL: https://codeforces.com/contest/1919/problem/F1
// Memory Limit: 512 MB
// Time Limit: 5000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
#define int long long
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}
vector<int>a(N , 0);
vector<int>b(N, 0);
vector<int>c(N, 0);
struct info{
    LL Res;//剩余多少水
    LL Res_ma;//魔法师还剩余多少能量
    LL Value;//价值
    friend info operator + (info a ,info b){
    	info c;
		c.Value = a.Value + b.Value;
		c.Res_ma = b.Res_ma + a.Res_ma;
		if(a.Res > 0){
			int d = min(a.Res , b.Res_ma);
			c.Res_ma -= d;
			c.Value += d;
			a.Res -= d;
		}
		c.Res = a.Res + b.Res;
    	return c;
    }
};
struct node{
    info val;
} seg[N * 4];
struct SegTree{
	void update(int id)
	{
	    seg[id].val = seg[id * 2].val + seg[id * 2 + 1].val;
	}
	void build(int id, int l, int r)
	{
	    if (l == r) {
	    	seg[id].val = {max(0 * 1LL ,a[l] - b[l]) , max(0 * 1LL , b[l] - a[l]) , min(a[l] , b[l])};
	    }
	    else{
	        int mid = (l + r) / 2;
	        build(id * 2, l, mid);
	        build(id * 2 + 1, mid + 1, r);
	        update(id);
	    }
	}
	void modify(int id, int l, int r, int ql, int qr)
	{
	    if (l == ql && r == qr){
	    	seg[id].val = {max(0 * 1LL ,a[l] - b[l]) , max(0 * 1LL , b[l] - a[l]) , min(a[l] , b[l])};
	        return;
	    }
	    if (ql > r || qr < l) // 区间无交集
	        return; // 剪枝
	    int mid = (l + r) / 2;
	    if (qr <= mid) modify(id * 2, l, mid, ql, qr);
	    else if (ql > mid) modify(id * 2 + 1, mid + 1, r, ql, qr);
	    else
	    {
	        modify(id * 2, l, mid, ql, mid);
	        modify(id * 2 + 1, mid + 1, r, mid + 1, qr);
	    }
	    update(id);
	}
	info query(int id, int l, int r, int ql, int qr)
	{
	    if (ql == l && qr == r) return seg[id].val;
	    int mid = (l + r) / 2;
	    if (qr <= mid) return query(id * 2, l, mid, ql, qr);
	    else if (ql > mid) return query(id * 2 + 1, mid + 1, r, ql, qr);
	    else
	    {
	        return query(id * 2, l, mid, ql, mid) + query(id * 2 + 1, mid + 1, r, mid + 1, qr);
	    }
	}
};
LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
void solve() 
{
	cin >> n >> m;
	for(int i = 1 ; i <= n ; i ++){
		cin >> a[i];
	}
	for(int i = 1 ; i <= n ; i ++){
		cin >> b[i];
	}
	for(int i = 1 ; i < n ; i ++){
		cin >> c[i];
	}
	SegTree segTree;
	segTree.build(1 , 1 , n);
	for(int i = 0 ; i < m ; i ++){
		int q , x , y , z;
		cin >> q >> x >> y >> z;
		a[q] = x;
		b[q] = y;
		segTree.modify(1 , 1 , n , q , q);
		cout << segTree.query(1 , 1 , n , 1 , n).Value << endl;
	}
}            
signed main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
//	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

D - 01 Tree 

        题意：先有一颗未知的完整二叉树,非叶子结点的两条与子节点相连的边权一个为0，另一个为1.如今给出了根据dfs序的叶子结点的权值序列,求能否还原出一颗完整二叉树.定义结点的权值为该节点到根节点的边权之和.

        思路：可以发现：同一个父亲的两个叶子结点的权值只差了1，且两个叶子结点中小的那个就是父节点的权值.也就是说，dfs序中若相邻两个数差了1，那么这两个数就是同一个父亲结点的。由此我们可以将同一个父亲的两个叶子结点中大的删除，小的保留，这样就相当于将两个叶子结点给删除了.最后若只剩下一个点没有被删除，且这个点为0，那么就代表了能够通过删除操作只保留一个顶点，反过来也就是说通过这个序列能够形成一个完整二叉树.

      

// Problem: D. 01 Tree
// Contest: Codeforces - Hello 2024
// URL: https://codeforces.com/contest/1919/problem/D
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define x first
#define y second 
#define endl '\n'
const LL maxn = 4e05+7;
const LL N = 5e05+10;
const LL mod = 1e09+7;
const int inf = 0x3f3f3f3f;
const LL llinf = 5e18;
typedef pair<int,int>pl;
priority_queue<LL , vector<LL>, greater<LL> >mi;//小根堆
priority_queue<LL> ma;//大根堆
LL gcd(LL a, LL b){
	return b > 0 ? gcd(b , a % b) : a;
}

LL lcm(LL a , LL b){
	return a / gcd(a , b) * b;
}
int n , m;
vector<int>a(N , 0);
void init(int n){
	for(int i = 0 ; i <= n ; i ++){
		a[i] = 0;
	}
}
void solve() 
{
	cin >> n;
	for(int i = 1; i <= n ; i ++){
		cin >> a[i];
	}
	a[0] = a[n + 1] = -inf;
	vector<int>nex(n + 5 , 0) , pre(n + 5 , 0);
	for(int i = 1; i <= n ; i ++){
		nex[i] = i + 1;
		pre[i] = i - 1;
	}
	auto check = [&](int x){
		return (a[pre[x]] == a[x] - 1) || (a[nex[x]] == a[x] - 1);
	};
	vector<int>in(n + 5 , 0);
	priority_queue<pair<int,int>>ma;
	for(int i = 1 ; i <= n ; i ++){
		if(check(i)){
			in[i] = 1;
			ma.push({a[i] , i});
		}
	}
	while(!ma.empty()){
		auto tmp = ma.top();
		ma.pop();
		int pos = tmp.y;
		nex[pre[pos]] = nex[pos];
		pre[nex[pos]] = pre[pos];
		if(!in[nex[pos]] && check(nex[pos])){
			in[nex[pos]] = 1;
			ma.push({a[nex[pos]] , nex[pos]});
		}
		if(!in[pre[pos]] && check(pre[pos])){
			in[pre[pos]] = 1;
			ma.push({a[pre[pos]] , pre[pos]});
		}
	}
	int mi = n , bad = 0;
	for(int i = 1 ; i <= n ; i ++){
		bad += (!in[i]);
		mi = min(mi , a[i]);
	}
	if(bad == 1 && mi == 0){
		cout <<"YES\n";
	}
	else{
		cout <<"NO\n";
	}
}            
int main() 
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cout.precision(10);
    int t=1;
	cin>>t;
    while(t--)
    {
    	solve();
    }
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/302325.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

josef 约瑟 数字式时间继电器 JS14P 0~20S AC220V 通电延时

josef 约瑟 数字式时间继电器 JS14P 0~20S AC220V 通电延时

JS14P系列时间继电器 JS14P系列数字式时间继电器是JS14、JS20等的更新换代产品采用集成电路&#xff0c;数字按键开关预置&#xff0c;它具有体积小、重量轻、精度高、寿命长、通用性强等优点&#xff0c;适用于交流50Hz&#xff0c;电压380V及以下和直流220w以下的自动控制电…
阅读更多...
Pycharm安装numpy库失败解决办法

Pycharm安装numpy库失败解决办法

一、出现错误&#xff08;以matplotlib为例&#xff09;&#xff1a; 二、解决办法&#xff1a; 方法一&#xff08;失败&#xff09;&#xff1a;PyCharm中有一个安装库的方法是&#xff1a;Settings>>Python Interpreter>>点击右侧的加号 第二个图 失败原因&am…
阅读更多...
C++每日一练（14）：对称矩阵的判定

C++每日一练（14）：对称矩阵的判定

题目描述 输入矩阵的行数&#xff0c;再依次输入矩阵的每行元素&#xff0c;判断该矩阵是否为对称矩阵&#xff0c;若矩阵对称输出“yes"&#xff0c;不对称输出”no“。 输入 第一行输入一个正整数N&#xff08;N<20&#xff09;&#xff0c;表示矩阵的行数&#xff0…
阅读更多...
深入了解pnpm：一种高效的包管理工具

深入了解pnpm：一种高效的包管理工具

✨专栏介绍 在当今数字化时代&#xff0c;Web应用程序已经成为了人们生活和工作中不可或缺的一部分。而要构建出令人印象深刻且功能强大的Web应用程序&#xff0c;就需要掌握一系列前端技术。前端技术涵盖了HTML、CSS和JavaScript等核心技术&#xff0c;以及各种框架、库和工具…
阅读更多...
Python笔记03-判断和循环

Python笔记03-判断和循环

文章目录 比较运算符if-else语句while语句for循环循环中断 比较运算符 字面量True表示真&#xff0c;字面量False表示假 if-else语句 if语句判断条件的结果一定要是布尔类型 不要忘记判断条件后的&#xff1a; 归属于if语句的代码块&#xff0c;需在前方填充4个空格缩进 age…
阅读更多...
批量整理记账，让你的财务生活更轻松

批量整理记账，让你的财务生活更轻松

每个月&#xff0c;每季度&#xff0c;每年&#xff0c;都需要花费大量的时间来整理、核对账单和记录每一笔支出。这种繁琐的工作真的太费时、费力了&#xff01;但今天&#xff0c;我要给你介绍一个神奇的工具——晨曦记账本。 所需工具&#xff1a; 一个【晨曦记账本】软件…
阅读更多...
常用类型_日期..

常用类型_日期..

1.Date java.util.Date是开发中常用的日期处理类(并非java.sql.Date类) 现在这么一个需求&#xff1a; 就是获取当前时区的时间 public class Main{public static void main(String[] args) {// d1和d2表示的时间都是一样的 所以推荐使用第一种写法 比较简洁Date d1 new Da…
阅读更多...
全新热门电商API接口，实现闲鱼商品详细搜索功能

全新热门电商API接口，实现闲鱼商品详细搜索功能

近年来&#xff0c;电商行业蓬勃发展&#xff0c;API&#xff08;Application Programming Interface&#xff09;接口已经成为电商平台的重要组成部分。API接口联讯数据不仅可以实现平台间的数据交互&#xff0c;还可以为开发者提供丰富的功能&#xff0c;满足用户多样化的需求…
阅读更多...
多模态推荐系统综述：五、挑战

多模态推荐系统综述：五、挑战

五、挑战 1、Multimodal Recommender Systems: A Survey 2023 •通用解决方案。 值得注意的是&#xff0c;尽管针对模型中的不同阶段提出了一些方法[24]&#xff0c;但没有提供这些技术组合的最新通用解决方案。 •模型可解释性。 多模态模型的复杂性会使系统生成的建议难以…
阅读更多...
【数据结构篇】数据结构中的 R 树和 B 树

【数据结构篇】数据结构中的 R 树和 B 树

数据结构中的 R 树和 B 树 ✔️关于R树&#xff08;RTree&#xff09;✔️什么是B树&#xff08;B-tree&#xff09;✔️B树和B树的区别✔️B树和B树在数据存储方面的具体差异 ✔️拓展知识仓✔️R树和B树的区别✔️ 那在内存消耗上有什么区别&#xff1f;✔️ R树有哪些优点和…
阅读更多...
【数据库】mysql事务

【数据库】mysql事务

一、事务的基本概念 1、事务的定义 事务可由一条非常简单的SQL语句组成&#xff0c;也可以由一组复杂的SQL语句组成。。 在 MySQL 中只有使用了 Innodb 数据库引擎的数据库或表才支持事务。事务处理可以用来维护数据库的完整性&#xff0c;保证成批的 SQL 语句要么全部执行&…
阅读更多...
海外代理IP在游戏中有什么作用？

海外代理IP在游戏中有什么作用？

随着科技的飞速发展&#xff0c;手机和电脑等电子产品已成为互联网连接万物的重要工具&#xff0c;深度融入我们的日常生活&#xff0c;我们借助互联网完成工作、休闲和购物等任务&#xff0c;以求提升生活质量。 不仅如此&#xff0c;网络游戏也是人们心中最爱&#xff0c;它…
阅读更多...
2024.1.8每日一题

2024.1.8每日一题

LeetCode 回旋镖的数量 447. 回旋镖的数量 - 力扣&#xff08;LeetCode&#xff09; 题目描述 给定平面上 n 对 互不相同 的点 points &#xff0c;其中 points[i] [xi, yi] 。回旋镖 是由点 (i, j, k) 表示的元组 &#xff0c;其中 i 和 j 之间的距离和 i 和 k 之间的欧式…
阅读更多...
Prometheus Blackbox_exporter笔记

Prometheus Blackbox_exporter笔记

一、安装Promtheus 在 Prometheus 官网 Download | Prometheus 获取适用于 Linux 的 Prometheus 安 装包&#xff0c;这里我选择最新的 2.46.0 版本&#xff0c;我是 Linux 系统&#xff0c;选择下载 prometheus-2.46.0.linux-amd64.tar.gz 下载安装包&#xff1a; wget htt…
阅读更多...
UI自动化测试神器：RunnerGo

UI自动化测试神器：RunnerGo

UI自动化测试已经成为现代软件开发过程中不可或缺的一部分。它能够提供诸多优势&#xff0c;包括提高测试效率、减少人力成本、提升软件质量等。同时&#xff0c;可视化工具为UI自动化测试带来了更多便利和灵活性。然而&#xff0c;可视化工具也存在一些潜在的劣势。本文将探讨…
阅读更多...
读元宇宙改变一切笔记01_起源

读元宇宙改变一切笔记01_起源

1. 元宇宙是我们下一个生存之地 1.1. 1968年&#xff0c;只有不到10%的美国家庭拥有彩色电视&#xff0c;但当年票房排名第二位的电影《2001&#xff1a;太空漫游》&#xff08;2001: A Space Odyssey&#xff09;设想了这样的未来 1.1.1. 斯坦利库布里克(Stanley Kubrick) …
阅读更多...
二 数据查询

二 数据查询

1、实验目的 理解SQL成熟设计基本规范&#xff0c;熟练运用SQL语言实现数据基本查询&#xff0c;包括但表查询、分组统计查询和连接查询。 2、实验内容及要求 针对数据库设计各种单表查询SQL语句、分组统计查询语句&#xff1b;设计单个表针对自身的连接查询&#xff0c;设计…
阅读更多...
lc 140. 单词拆分 II

lc 140. 单词拆分 II

回溯算法查询匹配单词 class Solution { public:unordered_map<string, int> word_map;void mapping(vector<string>& wordDict){for(auto &a : wordDict)word_map[a];}vector<string> ret;// s: 原始字符串// tmp: 已查询到的单词// …
阅读更多...
【Flutter 开发实战】Dart 基础篇：最基本的语法内容

【Flutter 开发实战】Dart 基础篇：最基本的语法内容

在深入了解 Dart 这门编程语言之前&#xff0c;我们需要了解一些关于 Dart 的最基本的知识&#xff0c;像是常量、变量、函数等等&#xff0c;这样才能够让我们的开发效率更上一层楼。在本节&#xff0c;我们将探讨一些基础语法&#xff0c;包括入口方法 main、变量、常量以及命…
阅读更多...
光伏组件QUV紫外加速老化试验箱

光伏组件QUV紫外加速老化试验箱

一、产品特点 QUV紫外加速老化试验箱能模拟阳光中 UV340波段光谱的荧光紫外灯&#xff0c;并结合控温、供湿等装置来模拟对材料造成变色、亮度、强度下降&#xff1b;开裂、剥落、粉化、氧化等损害的阳光&#xff0c;以及高温、高湿、凝露、黑暗周期等因素&#xff0c;同时通过…
阅读更多...
最新文章

Copyright @ 2022~2023