首页 > 编程语言 >分治算法C++

分治算法C++

时间:2023-08-10 17:38:17浏览次数:39  
标签:cout int 分治 cin C++ while 算法 tie include

1、光荣的梦想

题目描述】 Prince对他在这片陆上维护的秩序感到满意,于是决定启程离开艾泽拉斯。在他动身之前,Prince决定赋予King_Bette最强大的能量以守护世界、保卫这里的平衡与和谐。在那个时代,平衡是个梦想。因为有很多奇异的物种拥有各种不稳定的能量,平衡瞬间即被打破。KB决定求助于你,帮助他完成这个梦想。

一串数列即表示一个世界的状态。

平衡是指这串数列以升序排列。而从一串无序数列到有序数列需要通过交换数列中的元素来实现。KB的能量只能交换相邻两个数字。他想知道他最少需要交换几次就能使数列有序。

【输入】 第一行为数列中数的个数n,第二行为n <= 10000个数。表示当前数列的状态。

【输出】 输出一个整数,表示最少需要交换几次能达到平衡状态。

【输入样例】 4 2 1 4 3 【输出样例】 2

冒泡排序

#include <iostream>
#include<cstring>
#include<bits/stdc++.h>
using namespace std;
const int N=10005;
int n,ans;
int a[N];
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>a[i];
	for(int i=n;i>1;i--){
		for(int j=1;j<i;j++){
			if(a[j]>a[j+1])
			{
				ans++;
				swap(a[j],a[j+1]);
			}
		}
	}                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
	cout<<ans;
  	return 0;
}

归并排序

#include <iostream>
#include<cstring>
#include<bits/stdc++.h>
using namespace std;
const int N=10005;
int n,ans;
int a[N],t[N];
void msort(int l,int r)
{
	if(l==r)return;//只有一个元素,直接返回,递归结束 
	int mid=(l+r)>>1;
	msort(l,mid);
	msort(mid+1,r);
	int i=l,j=mid+1,k=l;
	while(i<=mid && j<=r)
	{
		if(a[i]>a[j])
		{
			ans+=mid-i+1;
			t[k++]=a[j++];
		}else{
			t[k++]=a[i++];
		}
	}
	while(i<=mid)
		t[k++]=a[i++];
	while(j<=r)
		t[k++]=a[j++];
	for(int x=l;x<=r;x++)
		a[x]=t[x];
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++)
		cin>>a[i];
	
	msort(1,n);                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
	cout<<ans;
  	return 0;
}
2、取余运算(mod)快速幂

题目描述】 输入b,p,k 的值,求bpmodk 的值。其中b,p,k×k 为长整型数。

【输入】 输入b,p,k 的值。

【输出】 求bpmodk 的值。

【输入样例】 2 10 9 【输出样例】 2^10 mod 9=7

#include <iostream>
#include<cstring>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll b,p,k;

int fun(ll n)
{
	if(n==0)return 1;
	ll t= fun(n/2)%k;
	t = (t*t)%k;
	if(n%2==1)
		t= (t*b)%k;
	return t;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	cin>>b>>p>>k;
	cout<<b<<"^"<<p<<" mod "<<k<<"="<<fun(p);
  	return 0;
}
3、

一开始使用优先队列,结果超时了

#include <iostream>
#include<cstring>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int n,x,k;
struct cmp{
	bool operator()(int a,int b)
	{
		return a<b;
	}
};
priority_queue<int,vector<int>,cmp> pq;
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>x;
		pq.push(x);
	}
	cin>>k;
	int i=1;
	while(!pq.empty() && i<=k)
	{
		cout<<pq.top()<<endl;
		pq.pop();
		i++;
	}
  	return 0;
}

然后使用sort排序,也是有三个测试点超时

#include <iostream>
#include<cstring>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int n,x,k;
int a[100005];

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>a[i];
	}
	cin>>k;
	sort(a,a+n);
	int i=n-1;
	while(i>=n-k)
	{
		cout<<a[i--]<<endl;
	}
  	return 0;
}

如此一来,只能手写快速排序了。

#include <bits/stdc++.h>
using namespace std;
 
void quicksort(int a[], int left, int right, int k) {
	if (left >= right) return;
	int i = left;
	int j = right;
	int tmp = a[left];
	while (i!=j){
		while (i<j && a[j] >= tmp) 
			j--;
		swap(a[i], a[j]);
		while (i<j && a[i] <= tmp) 
			i++;
		swap(a[i], a[j]);
 
	}
	int m = right - i + 1;
	if (m == k) {	//已经有k个数在右边(右边为大数),则表示目标完成 
		return;
	} else if (m > k) {		//对右边进行分类 
		quicksort(a, i+1, right, k);
	} else {			//对左边进行分类 
		quicksort(a, left, i-1, k-m);
	}
}
 
int main(){
	int n, k;
	int a[100010];
	memset(a, 0, sizeof(a));
	scanf ("%d", &n);
	for (int i=0; i<n; i++) {
		scanf ("%d", &a[i]);
	}
	scanf ("%d", &k);
	quicksort(a, 0, n-1, k);
	sort(a+n-k, a+n);
	for (int i=n-1; i>=n-k; i--) {
		printf ("%d\n", a[i]);
	}
	return 0;
}

标签:cout,int,分治,cin,C++,while,算法,tie,include
From: https://blog.51cto.com/u_16131726/7037761

相关文章

  • 广度优先搜索C++
    1、细胞(1)题目描述一矩形阵列由数字0到9组成,数字1到9代表细胞,细胞的定义为沿细胞数字上下左右还是细胞数字则为同一细胞,求给定矩形阵列的细胞个数。如:阵列4100234500067103456050020456006710000000089有4个细胞。【输入】第一行为矩阵的行n和列m;下面为一个n×m......
  • 递归算法练习C++
    1、逆波兰表达式(1)题目描述逆波兰表达式是一种把运算符前置的算术表达式,例如普通的表达式2+3的逆波兰表示法为+23。逆波兰表达式的优点是运算符之间不必有优先级关系,也不必用括号改变运算次序,例如(2+3)*4的逆波兰表示法为*+234。本题求解逆波兰表达式的值,其中运算符包括......
  • Google C++ 风格指南记录
    最近在看谷歌的C++风格指南发现了一些有意思的知识点,遂记录下1.第六章第二小节介绍了右值引用只在定义移动构造函数与移动赋值操作时使用右值引用.不要使用 std::forward.定义:右值引用是一种只能绑定到临时对象的引用的一种,其语法与传统的引用语法相似.例如, void......
  • Lnton羚通智能分析算法检测人群异常聚集检测告警算法的流程代码
    Lnton羚通视频智能分析算法中人群异常聚集检测报警系统是基于yolov8图像识别和数据分析技术,人群异常聚集检测告警算法通过在关键区域布设监控摄像头,实时监测人员的密集程度和行为动态,分析和判断人群密集程度是否超过预设阈值,一旦发现异常聚集,将自动发出信号,并提示相关人员采取相应......
  • AI绘画教程:为艺术而生的算法,你还在烦恼小红书与公众号的配图吗?(下)
    大家好,我是千寻哥,在上一篇给大家分享了我的第一篇AI绘画类教程的上集:AI绘画教程:为艺术而生的算法,你还在烦恼小红书与公众号的配图吗(上)?别着急,今天就来完成下半部分,在上一集中,我们介绍了三种用于生成AI绘画的网站。使用网站生成的AI绘画图片用于小红书的封面以及素材,从而助力你的新媒......
  • 有效的括号--LeetCode算法
    不用map的解法publicbooleanisValid(Strings){//输入的字符串为空,直接返回trueif(s.isEmpty())returntrue;//新建一个栈Stack<Character>stack=newStack<Character>();//遍历传入的字符串//如果时"(","{","["就......
  • 算法——初级排序算法之希尔排序
    介绍&特点对于大规模乱序数组插入排序很慢,因为它只会交换相邻的元素,元素只会一点一点地从数组一端移到另一端。例如,如果主键最小的元素正好在数组的尽头,要将它挪到正确的位置就需要N-1次移到。希尔排序为了加快速度简单地改进了插入排序,交换不相邻的元素以对数组的局部进行排序,并......
  • 代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素
    704二分查找题目给定一个n个元素有序的(升序)整型数组nums和一个目标值target,写一个函数搜索nums中的target,如果目标值存在返回下标,否则返回-1。第一想法判断条件是value=target因为数组是升序,其实每种查找方法应该相差不大?不过题目都标了二分查找了emmm思......
  • 【通知】有三AI更新420页14万字视觉算法工程师成长指导手册,可下载收藏打印...
    各位同学,可还记得我们发布的《深度学习视觉算法工程师成长指导手册》,现在更新了,超过14万字,420页文档,可下载收藏打印,目录如下,文末提供了下载方式。手册简介目前深度学习在图像,语音,NLP领域大展拳脚,不管是本专业还是非本专业的技术人员都有很多人投身这一行,但是学校的学科建设刚刚开始......
  • manacher(马拉车)算法C++详解
    马拉车的定义马拉车本质是对中心扩展法(暴力算法)的优化。马拉车是干什么的Manacher算法帮助我们在给定的字符串中找到最长的回文子串。为了简单起见,我们先只处理有奇数个字符的字符串,关于偶数个字符的字符串,在文章最后会给出解法。我们的处理思路和暴力算法基本一致,那就是从左......