23.10.29周报

最新推荐文章于 2024-10-02 23:57:25 发布
最新推荐文章于 2024-10-02 23:57:25 发布
阅读量51 收藏
点赞数
文章标签： 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/breath_of_yuan/article/details/134023708
版权

23日第一题:

题意：给一串由0，1，2组成的字符串，0，1和1，2可换位，2和0不可换位，输出其最小字典序排列。

思路：2和0的位置不变，可发现1是换到哪都可以的，于是在第一个2之前的0后输出。这里我用的vector来存0和2，因为没有考虑到无0，2的情况，访问ve数组re了两发。

第二题：一道臭不可闻的模拟。

第三题：

题意：给一字符串，每次可交换任意相邻字母，问将其reverse所需最小操作数。

不会，上网看了下，题解说是和逆序对有关，遂看了下逆序对，有三种算法，暴力，归并排序，树状数组，所以顺便把归并排序和树状数组看了下。

归并排序求逆序对，时间复杂度为O(nlogn)，在求逆序对的同时将数组排序（倒过来说也可以），代码如下：

#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using PII=pair<int,int>;

const int N=2e5+10;
int n;
int a[101],tmp[101];
int ans;
void pai(int l,int mid,int r){
	int idx=l;
	int i=l,j=mid+1;
	while(i<=mid && j<=r){
		if(a[i]<=a[j]) tmp[idx++]=a[i++];
		else{
			ans+=mid-i+1;//逆序对
			tmp[idx++]=a[j++];
		}
	}
	while(i<=mid) tmp[idx++]=a[i++];
	while(j<=r) tmp[idx++]=a[j++];
	for(int i=l;i<=r;i++) a[i]=tmp[i];
}
void gb(int l,int r){
	if(l>=r) return ;
	int mid=l+(r-l)/2;
	gb(l,mid);
	gb(mid+1,r);
	pai(l,mid,r);
}
void solve(){
	cin >> n;
	for(int i=1;i<=n;i++) cin >> a[i];
	gb(1,n);
	for(int i=1;i<=n;i++) cout << a[i] << " ";
	cout << endl << ans;//逆序对
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int t=1;
	//cin >> t;
	while(t--) solve();
	return 0;
}
//make it count

树状数组求逆序对的思路也很巧妙，且让我对树状数组的理解更深刻。时间复杂度为O(nlogn)，如没有排序的需求，可用此方法。代码如下:

#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using PII=pair<int,int>;

const int N=2e5+10;
int n;
int a[101],t[101];
int ans;
int lowbit(int x){
	return x&-x;
}
void add(int x,int v){
	for(int i=x;i<=n;i+=lowbit(i)) t[i]+=v;
}
int ask(int x){
	int sum=0;
	for(int i=x;i;i-=lowbit(i)) sum+=t[i];
	return sum;
}
void solve(){
	cin >> n;
	for(int i=1;i<=n;i++){
		int tmp;
		cin >> tmp;
		add(tmp,1);
		ans+=i-ask(tmp);//i代表输入了多少数，ask代表输入的数中比tmp小的有多少
	}
	cout << ans;
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int t=1;
	//cin >> t;
	while(t--) solve();
	return 0;
}
//make it count

说回正题，思路：啃了会题解，发现做法其实相当于给降序序列求逆序对，如abcde，可生成54321求逆序对，当遇到相同字母，其值逆序排放，如abade，生成34521求逆序对，abada，生成14325求逆序对。虽然还是不懂怎么推导的，但起码翻译成这样就可以写代码了。

代码如下：

#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using PII=pair<int,int>;

const int N=2e5+10;
int n,a[N],tmp[N];
ll ans;//第二次，wa
string s;
vector<int>ve[30];
void pai(int l,int mid,int r){
	int i=l,j=mid+1,idx=l;
	while(i<=mid && j<=r){
		if(a[i]<=a[j]) tmp[idx++]=a[i++];
		else ans+=mid-i+1,tmp[idx++]=a[j++];
	}
	while(i<=mid) tmp[idx++]=a[i++];
	while(j<=r) tmp[idx++]=a[j++];
	for(int k=l;k<=r;k++) a[k]=tmp[k];
}
void gb(int l,int r){
	if(l>=r) return ;//第一次，mle
	int mid=l+(r-l)/2;
	gb(l,mid);
	gb(mid+1,r);
	pai(l,mid,r);
}
void solve(){
	cin >> n >> s;
	s=" "+s;
	for(int i=1;i<=n;i++) ve[s[i]-'a'+1].push_back(i);
	for(int i=1;i<=26;i++)
		for(int j=0;j<ve[i].size();j++)
			a[ve[i][j]]=ve[i][ve[i].size()-j-1];
	for(int i=1;i<=n;i++) a[i]=n-a[i]+1;
	gb(1,n);
	cout << ans;
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int t=1;
	//cin >> t;
	while(t--) solve();
	return 0;
}
//make it count

然后这里代码写的很粗糙，第一次if(l>=r) return; 我没加等号，直接无限递归mle了，第二次我没给ans开long long导致wa了。已经因为没开llwa了好多次了，以后得记着记录ans的变量直接开long long别犹豫。

27日,周五:

补道周二比赛的题:

题意:给俩整数a和b,一次操作中,可让a/=c(a需能被c整除),或让b/=c(b需能被c整除),问能否通过刚好k次操作让a和b相等.

思路:先考虑最小操作次数minn,如a==b,minn为0,如a!=b但其一是另一因数,minn为1,如a!=b且互不能整除,minn为2(让a/=a,再让b/=b).再考虑最大操作次数maxx,即a能被多少质因数分解加上b能被多少质因数分解。那么理论上只要k在minn和maxx的闭区间范围内，就是YES，否则NO。那么如何计算a和b的质因数的数量呢？不会。去网上看了下，代码如下（函数，效果为输出所有质因数）：

void di(int x){
	for(int i=2;i<=x/i;i++){
		while(x%i==0){
			cout << i << endl;
			x/=i;
		}
	}
	if(x>1) cout << x;
}

最后代码写出来tle了，目前没想到什么办法。 

每日三题A题：

题意：只在序列中出现过一次的数是好数，把序列拆成A，B俩序列使A，B序列中好数的数量相等。

思路：记录下原序列中的好数num1，和出现次数大于等于3的数num2，当且仅当num1为奇数且num2为0时输出NO，否则YES。但代码思路出了点问题，写的很冗长复杂。

代码（奇丑无比）如下：

#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using PII=pair<int,int>;

const int N=2e5+10;
struct nod{
	int num,id;
}s[104];
int n;
int num1,num2;
vector<int>ve[3];
bool cmp1(nod a,nod b){
	return a.num!=b.num?a.num<b.num:a.id<b.id;
}
bool cmp2(nod a,nod b){
	return a.id<b.id;
}
void solve(){
	cin >> n;
	for(int i=1;i<=n;i++) cin >> s[i].num,s[i].id=i;
	sort(s+1,s+n+1,cmp1);
	for(int i=1,cnt=1;i<=n;i++){
		if(i==n){
			if(cnt==1) num1++,ve[1].push_back(s[i].id);
			else if(cnt>2) num2++,ve[2].push_back(s[i].id);
			break;
		}
		if(s[i+1].num!=s[i].num && cnt==1) cnt=1,num1++,ve[1].push_back(s[i].id);
		else if(s[i+1].num!=s[i].num && cnt>2) cnt=1,num2++,ve[2].push_back(s[i].id);
		else if(s[i+1].num!=s[i].num) cnt=1;
		else if(s[i+1].num==s[i].num) cnt++;
	}
	sort(s+1,s+n+1,cmp2);
	if(num1&1 && num2==0){cout << "NO"; return ;}
	cout << "YES" << endl;
	if(num1==0) for(int i=1;i<=n;i++) cout << 'A';
	else if(!(num1&1)){
		int idx=0;
		for(int i=1;i<=n;i++){
			if(find(ve[1].begin(),ve[1].end(),s[i].id)!=ve[1].end() && idx<num1/2) cout << 'A',idx++;
			else cout << 'B';
		}
	}else{
		int idx=0;bool iff=0;
		for(int i=1;i<=n;i++){
			if(find(ve[1].begin(),ve[1].end(),s[i].id)!=ve[1].end() && idx<num1/2) cout << 'A',idx++;
			else if(s[i].id==ve[2][0] && !iff) cout << 'A',iff=1;
			else cout << 'B';
		}
	}
	
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int t=1;
	//cin >> t;
	while(t--) solve();
	return 0;
}
//make it count

B题和A题一模一样。

28号周六：

每日三题A题：

题意：朋友打怪，easy怪无伤通，hard怪掉一血，打怪和作弊轮着来，每次打怪可打1或2个怪，每次作弊也可跳过1或2个怪（必须打怪一次，作弊一次）。问通关最少掉多少血。

思路：刚开始想的有点复杂，想不通，后来试着简化思路，不去模拟打怪和作弊的过程，只看掉多少血，纯贪心，就a了。

代码如下：

#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using PII=pair<int,int>;

const int N=2e5+10;
int n;
int a[N];
int ans;
void solve(){
	ans=0;
	cin >> n;
	for(int i=1;i<=n;i++) cin >> a[i];
	for(int i=n-1;i;i--){
		if(a[i]) a[i]+=a[i+1];
		else a[i]=0;
	}
	for(int i=1;i<=n;i++){
		if(i==1 && a[i]){ans++; continue;}
		if(a[i]<=2) i+=a[i]?a[i]-1:0;
		else ans+=a[i]/3,i+=a[i]-1;
	}
	cout << ans << endl;
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int t=1;
	cin >> t;
	while(t--) solve();
	return 0;
}
//make it count

每日三题B题：

题意：一道很不错的离散化。给n条线段的左右端点，问被i条线段覆盖的点有多少（i从1到n）。

思路：先离散化排序，然后挨个处理每个点，如何处理是关键，开一ans数组存答案（开long long），cnt变量存当前线段数，对于新的点，先把到上个点的距离加进ans【cnt】，再处理端点，如有重合，先处理左再右。对于重复左端点或右端点，得一次把cnt加或减完，再进答案。

（这题好像用差分也可以）

代码如下：

#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using PII=pair<int,int>;

const int N=2e5+10;
int n,m;
vector<pair<ll,int>>ve;
ll ans[N];
void solve(){
	cin >> n;
	for(int i=1;i<=n;i++){
		ll l,r;
		cin >> l >> r;
		ve.push_back({l,0});
		ve.push_back({r,1});
	}
	sort(ve.begin(),ve.end());
	int cnt=0;
	for(int i=0,j=ve.size();i<j;i++){
		ans[cnt]+=i==0?0:ve[i].first-ve[i-1].first-1;
		if(!ve[i].second){
			cnt++;
			while(ve[i+1].first==ve[i].first && !ve[i+1].second) i++,cnt++;
		}
		ans[cnt]++;
		if(ve[i].second){
			cnt--;
			while(ve[i+1].first==ve[i].first && ve[i+1].second) i++,cnt--;
		}
	}
	for(int i=1;i<=n;i++) cout << ans[i] << " ";
}
int main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int t=1;
	//cin >> t;
	while(t--) solve();
	return 0;
}
//make it count

每日三题C题是道1900的树题，做不是很来。

看看昨天每日三题的C：

题意：一数组的美丽值为其最大子序列和，你可选一子段令其内所有值*=x，问操作一次后的最大美丽值。

思路：一眼dp，但我很不擅长dp，所以得看下题解，顺便练下dp。

看了下题解，看不懂，还是先练下基础dp吧。
看了些基础的dp。

星期天的比赛是华中科技大学新生赛，之前打过的.

让我康米
关注
Cadence SPB OrCAD X - Allegro X 2023 v23.10.000
10-15
Cadence SPB OrCAD X - Allegro X 2023 v23.10.000，今年最新版本。
Altium Designer 23.10.1 Build 27 (x64)
11-08
Altium Designer 23.10.1 Build 27 (x64)，不知道更新了什么，不好下载就先下载到某雷，再下载。
Miniconda3-py39_23.10.0-1-MacOSX-x86_64.sh.zip
02-06
在给定的文件“Miniconda3-py39_23.10.0-1-MacOSX-x86_64.sh.zip”中，我们主要关注的是Miniconda3的Python 3.9版本，适用于64位的Mac操作系统。这个文件是一个名为“Miniconda3-py39_23.10.0-1-MacOSX-x86_64.sh”...
Miniconda3-py39_23.10.0-1-Linux-x86_64.zip
02-06
"Miniconda3-py39_23.10.0-1-Linux-x86_64.zip" 是一个针对Python 3.9版本的Miniconda3安装包，适用于64位Linux操作系统。这个压缩包内包含的"Miniconda3-py39_23.10.0-1-Linux-x86_64.sh" 是一个Shell脚本，用户...
425344155327405PS App v23.10.0安卓最新版.apk
11-03
425344155327405PS App v23.10.0安卓最新版.apk
计数排序(counting sort)
sinat_16493273的博客
09-29 395
计算排序是一种通过计算每个元素出现的次数来进行排序的算法。它不比较元素，而是利用数组来“计数”，所以在某些情况下，它能比传统的比较排序快。计数排序首先要找到要排序数组的最大值，然后创建一个统计数组存储每个排序元素的出现次数，然后累加计数数组，根据计数数组来确定每个元素的位置。以一个实际例子来看，假设待排序数组：{2,8,7,6,4,5,2,8,5}
八大排序详解
weixin_73077334的博客
09-29 1213
八大排序详解
C++番外篇-------排序算法总结
lys20221113242的博客
09-29 714
1.冒泡排序1.冒泡排序冒泡排序是一种简单的排序算法，它通过重复遍历要排序的列表，依次比较每对相邻项，并在必要时交换它们，从而使较大的元素逐渐“浮”到列表的顶部，而较小的元素则“沉”到底部。以下是冒泡排序的基本步骤：1. 从列表的第一个元素开始，依次比较相邻的两个元素。2. 如果顺序不正确（例如，前一个元素大于后一个元素），则交换它们。3. 继续进行这样的遍历和比较，直到到达列表的末尾。4. 重复以上步骤，直到整个列表都被排序。2.选择排序。
查找与排序-插入排序
wlq_567的博客
10-02 393
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。是一种简单直观的排序算法，其基本思想是将未排序的元素逐个插入到已排序的部分中，直到所有元素都被插入到合适的位置为止。假设我们有以下待排序的数组：[5, 3, 8, 6, 2]最终，数组变为有序状态：[2, 3, 5, 6, 8]
class 029 重要排序算法的总结
2301_80967814的博客
09-30 494
冒泡排序, 选择排序, 插入排序中, 最差的是选择排序, 因为付出了O(n^2)的时间复杂度, 也没有稳定性.归并排序, 随机快速排序, 堆排序中, 最需要注意的是随机快速排序, 因为随机快速排序的时间复杂度是根据期望确定的, 不能用最差和最好的情况进行确定, 这一点在以前随机快排的帖子中有详细的说明.
排序算法之快速排序
最新发布
qq_64039411的博客
10-02 126
【代码】排序算法之快速排序。
查找与排序-归并排序
wlq_567的博客
10-02 216
排序算法可以分为内部排序和外部排序，是数据记录在中进行排序，是因排序的，一次不能容纳全部的排序记录，在排序过程中需要。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。代价是需要额外的内存空间。若将两个有序表合并成一个有序表，称为2-路归并。该算法时间复杂度为O(n log n)。
C语言：排序（1）
2401_86551514的博客
09-29 1728
直接选择排序的特性总结：1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用2. 时间复杂度：O(N^2)3. 空间复杂度：O(1)4. 稳定性：不稳定。
排序算法（1）
qq_54065331的博客
09-29 384
排序算法最佳适用场景不适用场景冒泡排序学习排序概念，处理少量数据大数据量排序，性能要求高的场景选择排序数据量小且不要求稳定性时大数据量排序插入排序小规模或部分有序数据排序，实时数据处理大数据量，完全无序的数据。
二叉树最小深度
2301_80161204的博客
09-27 468
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1280
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1009
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 512
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1280
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
conda 23.10.0 'which' 不是内部或外部命令，也不是可运行的程序 或批处理文件。
11-30
根据提供的引用内容，这个问题可能是由于环境变量没有正确配置导致的。为了解决这个问题，你可以尝试以下两种方法： 1. 在命令行中手动添加路径： 在命令行中输入以下命令，将路径添加到环境变量中： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值