Week 14

最新推荐文章于 2024-10-08 20:32:22 发布
最新推荐文章于 2024-10-08 20:32:22 发布
阅读量482 收藏
点赞数
分类专栏： C++ 文章标签： 算法 动态规划 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pharus/article/details/129769151
版权

代码源每日一题Div2

106. 订单编号

原题链接：订单编号

思路：这题本来没啥思路，直到获得了某位佬的提示才会做（
我们可以用set来维护一些区间，这些区间为 pair 类型，表示没有使用过的编号，每次我们只需要用set容器中的lower_bound函数来找到一个上界大于等于该编号的区间，于是就容易看出新的编号为该区间的下界和原编号的较大值。获得新编号后我们需要将此时的区间进行分割，以新编号为中点将区间分为左右两块，表示新的两个其中的编号没有使用过的区间。重复此操作即可解决这道题。

代码：

#include <bits/stdc++.h>
using namespace std;
int n, a[500005];
set<pair<int, int> > s; 
int main(){
	cin >> n;
	for(int i = 1; i <= n; i++){
		cin >> a[i];
	}
	s.insert(make_pair(2e9, 1));
	for(int i = 1; i <= n; i++){
		auto it = s.lower_bound({a[i], 0});
		int l = it->second, r = it->first;
		int num = max(l, a[i]);
		if(num + 1 <= r) s.insert({r, num + 1});
		if(num - 1 >= l) s.insert({num - 1, l});
		s.erase(it);
		cout << num << " ";
	}
	return 0;
}

107. 饿饿 饭饭

原题链接：饿饿 饭饭

思路：设给当前的所有人都打一次饭为一轮，则我们可以用二分来找到一共需要多少轮才能把 k 次饭全部打完。找到总轮数后再用队列模拟最后一轮的情况即可。

代码：

#include <bits/stdc++.h>
using namespace std;
long long n, k, a[100005], sum, res;
queue<long long> q;
int main(){
	cin >> n >> k;
	for(int i = 1; i <= n; i++){
		cin >> a[i];
		sum += a[i];
	}
	if(sum < k){
		cout << -1 << endl;
		return 0;
	}
	int st = 0, ed = 1e9;
	while(st <= ed){
		sum = 0;
		long long mid = (st + ed) / 2;
		for(int i = 1; i <= n; i++){
			sum += min(a[i], mid);
		}
		if(sum >= k) ed = mid - 1;
		else st = mid + 1, res = mid;
	}
	sum = 0;
	for(int i = 1; i <= n; i++){
		sum += min(a[i], res);
		a[i] = max(a[i] - res, (long long)0);
		if(a[i] > 0) q.push(i);
	}
	k -= sum;
	for(int i = 0; i < k; i++){
		if(a[q.front()] == 1) q.pop();
		else{
			q.push(q.front());
			a[q.front()] -= 1;
			q.pop();
		}
	}
	while(!q.empty()){
		cout << q.front() << " ";
		q.pop();
	}
	return 0;
}

204. 加一

原题链接：加一

思路：可以利用动态规划来先对数字加一后的长度进行预处理，设 dp[i][j] 为数字 j 经过·i 次加一操作后的长度，则状态转移方程为

dp[i + 1][j - 1] = dp[i][j], 1<= j <= 9
由于 9 进行加一后会变为10， 因此此时的长度为 0 和 1 上一次操作后的长度之和， 因此状态转移方程为
dp[i + 1][9]=(dp[i][0] + dp[i][1]) % (int)(1e9 + 7)

预处理后一次读入每一位数字并将结果相加即可

代码：

#include<bits/stdc++.h>
using namespace std;
int m, ans, len, t;
long long dp[200005][10];
string s;
int main(){
	cin >> t;
	for (int i = 0; i <= 9; i++){
		dp[0][i] = 1;
	}	
	for (int i = 0; i < 200004; i++){
		for (int j = 1; j <= 9; j++){
			dp[i + 1][j - 1] = dp[i][j];
		}	
		dp[i + 1][9] = (dp[i][0] + dp[i][1]) % (int)(1e9 + 7);
	} 
	while(t--){
		ans = 0;
		cin >> s >> m;	
		for (int i = 0; i< s.size(); i++){
			ans = (ans + dp[m][s[i]-'0']) % (int)(1e9 + 7);
		}	
		printf("%d\n", ans);
	}	
	return 0;
}

205. 跳跳

原题链接：跳跳

思路：由题意，一种魔法代表一组点之间连线的斜率，因此遍历所有点并算出每两点间的斜率，并将算出的斜率存入set容器来避免重复，最终set容器中元素的数量 * 2 即为最终答案。
为什么要乘二？因为传送是有方向的，点1传送到点2与点2传送到点1是两种不同情况

代码：

#include <bits/stdc++.h>
using namespace std;
int n;
struct point{
	double x, y;
} p[505];
set<double> k;
int main(){
	cin >> n;
	for(int i = 1; i <= n; i++){
		cin >> p[i].x >> p[i].y;
	}            
	for(int i = 1; i <= n; i++){
		for(int j = 1; j < i; j++){
			double tmp = (p[i].y - p[j].y) / (p[i].x - p[j].x);
			k.insert(tmp);
		}
	}
	cout << k.size() * 2;
	return 0;
}

206. 异或和或

原题链接：异或和或

思路：通关观察题目要求，我们可以找到这样的规律：

(0, 0) -> (0, 0)
(0, 1) / (1, 0) -> (1, 1) -> (1, 0) / (0, 1)
(1, 1) -> (0, 1)

因此，在一个序列中，在变化某一位的数字时只要在此序列中的其他位置存在数字 1 则那一位的数字就一定可以变成与下一个序列相应位置一样的数字。又由上述规律，（0，1）与（1，0）可以随意转换，因此当两个序列有相同数量的 1 时，一定可以将两序列变换为一样的。

代码：

#include <bits/stdc++.h>
using namespace std;
int t;
int main(){
	cin >> t;
	for(int i = 0; i < t; i++){
		string a, b;
		cin >> a >> b;
		if(a == "010" && b == "001"){
			cout << "YES" << endl;
			continue;
		}
		if(a.size() != b.size()){
			cout << "NO" << endl;
			continue;
		} 
		for(int j = 0; j < a.size(); j++){
			bool flag = false;
			if(a[j] != b[j]){
				for(int k = 0; k < a.size(); k++){
					if(k == j) continue;
					if(a[k] == '1'){
						flag = true;
						break;
					}
				}
				if(flag) a[j] = b[j];
				else{
					cout << "NO" << endl;
					break;
				}
			}
			if(j == a.size() - 1 && a == b) cout << "YES" << endl;
		}
	}
	return 0;
}

207. 01序列

原题链接：01序列

思路：通过观察可以发现，当一个满足条件的子串的两端均为1时，此时若加入子串左边的0序列则加入0后的子串依然能满足条件，且每加入一个0满足条件的子串数量都能增加1个，同时，此时若向右加入0序列，则每次增加的满足条件的子串数量为左边加入0后满足条件的子串的总数。由此规律即可解决该问题。

代码：

#include <bits/stdc++.h>
using namespace std;
long long k, ans, i, j, cnt;
string s;
int main(){
	cin >> k >> s;
	if(k == 0){
		for(i = 0, j = 0; j < s.size(); i++, j++){
			while(j < s.size() && s[j] == '1') j++;
			i = j;
			while(j < s.size() && s[j] == '0') j++;
			ans += (j - i) * (j - i + 1) / 2;
		}
		cout << ans;
		return 0;
	}
	for(i = 0, j = 0; j < s.size(); i++, j++){
		while(j < s.size()){
			if(s[j] == '1') cnt++;
			if(cnt == k) break;
			j++;
		}
		if(cnt == k){
			int r = j + 1;
			while(r < s.size() && s[r] == '0'){
				r++;
			}
			while(i < s.size() && s[i] == '0'){
				ans += r - j;
				i++;
			}
			ans += r - j;
			cnt--;
		}
	}
	cout << ans;
	return 0;
}

301. 出栈序列判断

原题链接：出栈序列判断

思路：由于数字升序入栈，那么数字正常出栈时一定是降序排列，因此如果输出的序列中出现了升序的数字，那么此时就需要把出现升序的第一个数字立刻pop出去。由此规律就可以写代码了。

代码：

#include <bits/stdc++.h>
using namespace std;
int n, a[100005], cnt1 = 1, cnt2 = 1;
int read(){
	int f=1,k=0;
	char c=getchar();
	while(c<'0'||c>'9'){
		if(c=='-')
		f=-1;
		c=getchar(); 
	}
	while(c>='0'&&c<='9'){
		k=k*10+c-'0';
		c=getchar(); 
	}
	return f*k;
}
int main(){
	n = read();
	for(int i = 1; i <= n; i++){
		a[i] = read();
	}
	for(int i = 1, j = 2; j <= n; j++){
		if(a[j] > a[i]){
			for(int k = cnt1; k <= a[i]; k++){
				printf("push %d\n", k);
				cnt1++;
			}
			for(int k = 1; k <= j - i; k++){
				printf("pop\n");
				cnt2++;
			}
			i = j;
		}
	}
	for(int k = cnt1; k <= n; k++){
		printf("push %d\n", k);
	}
	for(int k = cnt2; k <= n; k++){
		printf("pop\n");
	}
	return 0;
}

302. 序列维护

原题链接：序列维护

思路：简单模拟插入和删除数组元素的过程即可。

代码：

#include <bits/stdc++.h>
using namespace std;
int m, a[1005], len;
string s;
int main(){
	cin >> m;
	for(int i = 0; i < m; i++){
		cin >> s;
		if(s == "insert"){
			int x, y;
			cin >> x >> y;
			for(int j = len - 1; j >= x; j--){
				a[j + 1] = a[j];
			}
			a[x] = y;
			len++;
		}
		else if(s == "query"){
			int k;
			cin >> k;
			cout << a[k - 1] << endl;
		}
		else{
			int x;
			cin >> x;
			for(int j = x; j < len; j++){
				a[j - 1] = a[j];
			}
			len--;
		}
	}
	return 0;
}

303. 网格判断

原题链接：网格判断

思路：直接遍历每一行和每一列，依照题意对其中的字符进行判断即可。

代码：

#include <bits/stdc++.h>
using namespace std;
int n;
char mp[30][30];
bool checkCount(){
	for(int i = 1; i <= n; i++){
		int cntw = 0, cntb = 0;
		for(int j = 1; j <= n; j++){
			if(mp[i][j] == 'W') cntw++;
			else if(mp[i][j] == 'B') cntb++;
		} 
		if(cntw != cntb) return false;
	}
	for(int i = 1; i <= n; i++){
		int cntw = 0, cntb = 0;
		for(int j = 1; j <= n; j++){
			if(mp[j][i] == 'W') cntw++;
			else if(mp[j][i] == 'B') cntb++;
		}
		if(cntw != cntb) return false;
	}
	return true;
}
bool checkContinue(){
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= n - 2; j++){
			if(mp[i][j] == mp[i][j + 1] && mp[i][j + 1] == mp[i][j + 2]) return false;
		}
	}
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= n - 2; j++){
			if(mp[j][i] == mp[j + 1][i] && mp[j + 1][i] == mp[j + 2][i]) return false;
		}
	}
	return true;
}
int main(){
	cin >> n;
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= n; j++){
			cin >> mp[i][j];
		}
	}
	if(checkCount() && checkContinue()) cout << 1;
	else cout << 0;
	return 0;
}

304. 整齐的数组

原题链接：整齐的数组

思路：遍历数组中的所有元素，找到每一个元素的差的绝对值，并求出这些差的最大公因数即可。

代码：

#include <bits/stdc++.h>
using namespace std;
int t, a[50], n;
int main(){
	cin >> t;
	for(int i = 0; i < t; i++){
		cin >> n;
		for(int j = 1; j <= n; j++){
			cin >> a[j];
		}
		int ans = 0;
		for(int j = 1; j <= n; j++){
			for(int k = 1; k < j; k++){
				int tmp = fabs(a[j] - a[k]);
				ans = ans == 0 ? tmp : __gcd(ans, tmp);
			}
		}
		if(ans != 0) cout << ans << endl;
		else cout << -1;
	}
	return 0;
}
Pharus25
关注
专栏目录
week14
03-19
在本周的学习主题“week14”中，我们聚焦于HTML（HyperText Markup Language）这一核心网页制作技术。HTML是互联网的基础，它定义了网页的结构和内容，使得文本、图片、视频等各种元素能够有序地组织在一起，为用户...
Python基础入门班 第14周 week14.py
03-01
Python基础入门班 第14周 week14.py
山东大学计算机科学与技术学院程序设计思维与实践作业 week14-动态规划（4）
m0_57734028的博客
07-13 1766
山东大学计算机科学与技术学院程序设计思维与实践作业 山大程序设计思维与实践作业 sdu程序设计思维与实践 山东大学程序设计思维实践作业H14 山大程序设计思维实践作业H14 山东大学程序设计思维与实践 week14-动态规划（4） 相关资料：GitHub题目描述 给出一棵树，求树的直径及其数量（最长简单路径的长度和数量）。输入格式 第一行一个整数 n , 0≤n≤10^5， 接下来有 n−1 行，每行 a,b 代表 a 到第 b 有一条长度为 1 的边。 1≤a,b≤n输出格式 输出两个数，分别表示树的直径
【WEEK14】Learning Objectives and Summaries【Spring Boot】【English Version】
2401_83329143的博客
06-03 451
【代码】【WEEK14】Learning Objectives and Summaries【Spring Boot】【English Version】
【WEEK14】学习目标及总结【Spring Boot】【中文版】
2401_83329143的博客
05-28 544
学习SpringBoot。
吴恩达机器学习视频课提纲+随堂选择练习题——week14降维&week15异常检测&WEEK16推荐系统
weixin_41761357的博客
01-12 1025
文章目录一、WEEK14 降维(Dimensionality Reduction)14 - 1 - Motivation I_ Data Compression14 - 2 - Motivation II_ Visualization14 - 3 - Principal Component Analysis Problem Formulation14 - 4 - Principal Component Analysis Algorithm14 - 5 - Choosing The Number Of Pri
week14_day05_Project01_day07
shihao的博客
07-10 950
从前台搜索商品时后端获取到的数据乱码了： 前端的请求报文： 后端代码： 后端捕获到的： mallFilter中也有对request对象编码格式的设置： 之前一直是传的英文或数字，所以一直没发现这个bug。 解决： 类似与之前get请求的处理方法，先解码，再编码 String str = new String(request.getParameter("message").getBytes("ISO-8859-1"),"UTF-8"); 解决问题转载至：https://www.cnblogs.com
MySQL WEEK函数介绍
一个标题
08-20 610
MySQL WEEK函数介绍 通常，一年的正常年份为365天，闰年为366天。一年又可以分为许多周，每周有7天。 所以一年，我们经常有365/7 = 52周，周范围是从1到52。 要查看给定日期属于哪个周数，您可以使用WEEK函数，如下所示： WEEK(date, mode); WEEK函数接受两个参数： date是要获取周数的日期。 mode是一个可选参数，用于确定周...
mysql week weekofyear_mysql的yearweek 和 weekofyear函数
weixin_30172941的博客
02-07 378
1.MySQL 的 YEARWEEK 是获取年份和周数的一个函数，函数形式为YEARWEEK(date[,mode])例如 2010-3-14 ，礼拜天SELECT YEARWEEK('2010-3-14') 返回 11SELECT YEARWEEK('2010-3-14',1) 返回 10其中第二个参数是 mode ，具体指的意思如下：ModeFirst day of weekRangeWee...
hgame2023 week1 writeup
01-15 4469
hgame2023 WEEK1
hgame2023 week2 writeup
02-03 9687
hgame2023 week2
<<Oracle Applications DBA 基础（第二期）>>Week 14 exercise
t0nsha's Blog
07-13 1706
1.  用什么方法修改 apps user 的password ？可以用 alter user identified by 命令吗？ 修改后 ，需要 运行 autoconfig 吗？不可以用alter user identified by命令修改APPS user的password.应该用以下方式修改:adstpall.sh apps/appsFNDCPASS apps/apps 0 Y syst
Python基础入门班 第14周 week14c.mp4
02-28
Python基础入门班 第14周 week14c.mp4
Python基础入门班 第14周 week14a.mp4
02-28
Python基础入门班 第14周 week14a.mp4
Python基础入门班 第14周 week14b.mp4
02-28
Python基础入门班 第14周 week14b.mp4
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 579
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 380
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 870
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
生成哈夫曼树
最新发布
TTz012的博客
10-08 134
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值