2014蓝桥杯 小朋友排队(归并排序 和 数状数组 求逆序对)

最新推荐文章于 2022-04-04 17:40:20 发布
最新推荐文章于 2022-04-04 17:40:20 发布
阅读量556 收藏
点赞数 2
分类专栏： 蓝桥杯练习 文章标签： 归并求逆序对 小朋友排队 数状数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41709801/article/details/88633466
版权

标题：小朋友排队

n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，
但是每次只能交换位置相邻的两个小朋友。
每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。
如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3），依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加k。
请问，要让所有小朋友按从低到高排队，他们的不高兴程度之和最小是多少。
如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。

【数据格式】
输入的第一行包含一个整数n，表示小朋友的个数。
第二行包含 n 个整数 H1 H2 … Hn，分别表示每个小朋友的身高。
输出一行，包含一个整数，表示小朋友的不高兴程度和的最小值。
例如，输入：
3
3 2 1
程序应该输出：
9
【样例说明】
首先交换身高为3和2的小朋友，再交换身高为3和1的小朋友，再交换身高为2和1的小朋友，每个小朋友的不高兴程度都是3，总和为9。

【数据规模与约定】
对于10%的数据， 1<=n<=10；
对于30%的数据， 1<=n<=1000；
对于50%的数据， 1<=n<=10000；
对于100%的数据，1<=n<=100000，0<=Hi<=1000000。

资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms

归并排序可以求总的逆序对，这个大家应该是知道的 。
他人 归并排序参考
此题所求并非是总的逆序对， 而是相对的。

解题思想:

如果有如下序列：
3 6 4 7 5 2 0 1
那么对于1来说，要想回到前面， 必须要经过 2 5 7 4 6 3 次序并不重要， 重要的是个数。
那么对于2来说，要被0 1经过。

那么总结一下就是：
就是相对于 2 来说有几个逆序对 即： 小于2并且在2右边的，大于2并且在其左边的， 取之和即为所求。

接下来一张草图，来解释归并求逆序对的过程。
在这里插入图片描述
归并排序求逆序对代码如下:
去掉含有 下面两个变量的代码所在行， 就是归并排序 （ ni_num_sum，ni_num_sum_temp ）

#define MAX 1000005
// 原数组 
long num[MAX] = {0};
// 辅助排序 
long num_sort[MAX] = {0};

// 去掉含有 下面两个变量的代码所在行， 就是归并排序
// 记录左右两边的逆序 个数 
long ni_num_sum[MAX] = {0}; 
// 辅助记录 
long ni_num_sum_temp[MAX] = {0};
void pai_sort(int l, int mid, int r){
	int i = l;
	int j = mid + 1;
	int index = l;
	while(i <= mid && j <= r){
		if(num[i] < num[j]){	// 后面大于前面 
			num_sort[index] = num[i]; 
			ni_num_sum[index] = ni_num_sum_temp[i] + (j - mid - 1); // 逆序数 
			++i; 
		}else if(num[i] > num[j]){ // 前面 大于 后面  出现逆序 
			num_sort[index] = num[j]; 
			ni_num_sum[index] = ni_num_sum_temp[j] + (mid - i + 1);	// 逆序数 
			++j; 
		} else{// 等于， 不需要加逆序数 
			num_sort[index] = num[i]; 
			++i; 
			num_sort[index] = num[j]; 
			++j; 
		}
		++index;
	}
	while(i <= mid){
		if(num[i] != num_sort[index])	// 如果出现相等的情况， 就不要计算
			ni_num_sum[index] = ni_num_sum_temp[i] + (j - mid - 1);
		num_sort[index] = num[i];
		++index;
		++i;
	}
	while(j <= r){ 
		if(num[i] != num_sort[index])	// 如果出现相等的情况， 就不要计算
			ni_num_sum[index] = ni_num_sum_temp[j] + (mid - i + 1);
		num_sort[index] = num[j];
		++index;
		++j;
	}
	// 排序完成 放回原数组， 并且将逆序结果缓存等待取用。
	for(i = l; i <= r; ++i){
		num[i] = num_sort[i];
		ni_num_sum_temp[i] = ni_num_sum[i]; // 缓存上一次的逆序对数 
	}
}
void gui_pai(int l, int r){
	if(l < r){
		int mid = (l + r) >> 1;
		gui_pai(l, mid);
		gui_pai(mid + 1, r);
		pai_sort(l, mid, r);	
	}
}

那么求出逆序对之后列 ？

之后便是转换成不满意程度了。

也好解决：
比如 2 有 7 个逆序对，那么就是 1 + 2 + 3 + 4 + 5 + 6 + 7 也就是n - 1求和：
对于 n 到 1的求和 求和公式为 **( ( (n + 1) * n) / 2 ) ** 。
代码如下：

// 1 - n  连续数  求和 
long sum_0_to_n(long n){
	return ((n + 1) * n )>> 1;
}

完整代码：

#include<stdio.h>
#define MAX 1000005
// 时间复杂度 O( N*log2(N) ) 
long N = 0;

// 原数组 
long num[MAX] = {0};
// 辅助排序 
long num_sort[MAX] = {0};

// 记录左右两边的逆序 个数 
long ni_num_sum[MAX] = {0}; 
// 辅助记录 
long ni_num_sum_temp[MAX] = {0};

unsigned long long ans = 0;
// 1 - n  连续数  求和 
long sum_0_to_n(long n){
	return ((n + 1) * n )>> 1;
} 
void pai_sort(int l, int mid, int r){
	int i = l;
	int j = mid + 1;
	int index = l;
	while(i <= mid && j <= r){
		if(num[i] < num[j]){	// 后面大于前面 
			num_sort[index] = num[i]; 
			
			ni_num_sum[index] = ni_num_sum_temp[i] + (j - mid - 1); // 逆序数 
			++i; 
		}else if(num[i] > num[j]){ // 前面 大于 后面  出现逆序 
			num_sort[index] = num[j]; 
			ni_num_sum[index] = ni_num_sum_temp[j] + (mid - i + 1);	// 逆序数 
			++j; 
		} else{// 等于， 不需要加逆序数 
			num_sort[index] = num[i]; 
			++i; 
			num_sort[index] = num[j]; 
			++j; 
		}
		index++;
	}
	while(i <= mid){
		if(num[i] != num_sort[index]) 
			ni_num_sum[index] = ni_num_sum_temp[i] + (j - mid - 1);
		num_sort[index] = num[i];
		++index;
		++i;
	}
	while(j <= r){ 
		if(num[i] != num_sort[index])
			ni_num_sum[index] = ni_num_sum_temp[j] + (mid - i + 1);
		num_sort[index] = num[j];
		++index;
		++j;
	}
	// 放回 
	for(i = l; i <= r; i++){
		num[i] = num_sort[i];
		ni_num_sum_temp[i] = ni_num_sum[i]; // 缓存上一次的逆序对数 
	}
}
void gui_pai(int l, int r){
	if(l < r){
		int mid = (l + r) >> 1;
		gui_pai(l, mid);
		gui_pai(mid + 1, r);
		pai_sort(l, mid, r);	
	}
} 
int main(){
	scanf("%d", &N);
	for(int i = 0; i < N; i++){
		scanf("%d", num + i);
	} 
	gui_pai(0, N - 1);
	// 使用逆序对 计算结果
	for(int i = 0; i < N; ++i){
		ans += sum_0_to_n(ni_num_sum[i]);
	} 
	printf("%lld\n", ans);
	for(int i = 0; i < N; i++){
		printf("%d ", ni_num_sum[i]);
	}
	return 0;	
}

解题思想二 数状数组：

同样是求逆序对， 但是求解方式不同。
同样一张草图， 表示解题过程。

在这里插入图片描述

#include<stdio.h>
#define N_MAX 100005
// 时间复杂度 O( N*log2(N) ) 

long N = 0;
// 原数组 
long num[N_MAX] = {0};
// 这里需要使用数字的最大值存放数据, 因为这相等于背包 
#define MAX 1000005 
// 树状数组解法
// 需要两个数组 
long tree_num_left[MAX];
long tree_num_right[MAX];
// 存放求和结果 
long ans_num_left[MAX];
long ans_num_right[MAX];
// 存放最大方便确定扫描区间 减少复杂度 
long max_num = -999999;
inline int low_bit(int t){
	return t&(-t);
} 
// 求和 
inline long tree_sum(long tree_num[], long index){
	long sum = 0;
	for(long i= index; i > 0; i -=low_bit(i)){
		sum +=  tree_num[i];
	}
	return sum;
} 
// 更新单节点
inline void update(long tree_num[], int index, long num){
	for(int i = index; i <= max_num; i += low_bit(i)){
		tree_num[i] += num;
	}
}
int main(){
	
	scanf("%d", &N);
	for(int i = 0; i < N; i++){
		scanf("%d", num + i);
		if(num[i] > max_num){
			max_num = num[i];
		} 
	} 
	max_num ++; // 因为会出现0的情况， 将最大值加1就可以， 相当于向右偏移1， 当然 多加也无所谓 
	
	// 树状数组解法 
	
	// 更新 由左向右扫描 
	for(int i = 0; i < N; ++i){
		update(tree_num_left, num[i] + 1, 1); 
		// 若是 替换成 ans_num_right[num[i]] 数据将变得有序 ， 但是后续合并和计算复杂度 最差 将会变高10倍 
		// 而且并不需要有序， 只需要结果就好 
		ans_num_left[i] = tree_sum(tree_num_left, max_num) - tree_sum(tree_num_left, num[i] + 1); 
	}
	// 更新 由右向左扫描 
	for(int i = N - 1; i >= 0; --i){
		update(tree_num_right, num[i] + 1, 1); 
		ans_num_right[i] = tree_sum(tree_num_right, num[i]); 
	}
	// 合并 
	unsigned long long ans_2 = 0;
	for(int i = 0; i < N; ++i){
		ans_num_right[i] += ans_num_left[i]; 
		// 求值
		ans_2 += sum_0_to_n(ans_num_right[i]);
		printf("%ld ", ans_num_right[i]);
	} 
	puts("");
	printf("树状数组求得：%lld\n", ans_2);
	
	return 0;	
}

运行截图：

归并排序 和 数状数组全部代码

#include<stdio.h>
#define N_MAX 100005
// 时间复杂度 O( N*log2(N) ) 

long N = 0;
// 原数组 
long num[N_MAX] = {0};
// 辅助排序 
long num_sort[N_MAX] = {0};

// 记录左右两边的逆序 个数 
long ni_num_sum[N_MAX] = {0}; 
// 辅助记录 
long ni_num_sum_temp[N_MAX] = {0};



unsigned long long ans = 0;

// 1 - n  连续数  求和 
long sum_0_to_n(long n){
	return ((n + 1) * n )>> 1;
} 

void pai_sort(int l, int mid, int r){
	int i = l;
	int j = mid + 1;
	int index = l;

	while(i <= mid && j <= r){
		if(num[i] < num[j]){	// 后面大于前面 
			num_sort[index] = num[i]; 
			
			ni_num_sum[index] = ni_num_sum_temp[i] + (j - mid - 1); // 逆序数 
			++i; 
		}else if(num[i] > num[j]){ // 前面 大于 后面  出现逆序 
			num_sort[index] = num[j]; 
			
			ni_num_sum[index] = ni_num_sum_temp[j] + (mid - i + 1);	// 逆序数 
			++j; 
		} else{// 等于， 不需要加逆序数 
			num_sort[index] = num[i]; 
			++i; 
			num_sort[index] = num[j]; 
			++j; 
		}
		index++;
	}
	while(i <= mid){
		
		if(num[i] != num_sort[index]) 
			ni_num_sum[index] = ni_num_sum_temp[i] + (j - mid - 1);
		num_sort[index] = num[i];
		++index;
		++i;
	}
	while(j <= r){ 
		if(num[i] != num_sort[index])
			ni_num_sum[index] = ni_num_sum_temp[j] + (mid - i + 1);
		num_sort[index] = num[j];
		++index;
		++j;
	}
	// 放回 
	for(i = l; i <= r; i++){
		num[i] = num_sort[i];
		ni_num_sum_temp[i] = ni_num_sum[i]; // 缓存上一次的逆序对数 
	}
 
}
void gui_pai(int l, int r){
	
	if(l < r){
		int mid = (l + r) >> 1;
		gui_pai(l, mid);
		gui_pai(mid + 1, r);
		
		pai_sort(l, mid, r);	
	}
	
} 


// 这里需要使用数字的最大值存放数据, 因为这相等于背包 
#define MAX 1000005 
// 树状数组解法
// 需要两个数组 
long tree_num_left[MAX];
long tree_num_right[MAX];
// 存放求和结果 
long ans_num_left[MAX];
long ans_num_right[MAX];
// 存放最大方便确定扫描区间 减少复杂度 
long max_num = -999999;
inline int low_bit(int t){
	return t&(-t);
} 
// 求和 
inline long tree_sum(long tree_num[], long index){
	long sum = 0;
	for(long i= index; i > 0; i -=low_bit(i)){
		sum +=  tree_num[i];
	}
	return sum;
} 
// 更新单节点
inline void update(long tree_num[], int index, long num){
	for(int i = index; i <= max_num; i += low_bit(i)){
		tree_num[i] += num;
	}
}

int main(){
	
	scanf("%d", &N);
	for(int i = 0; i < N; i++){
		scanf("%d", num + i);
		if(num[i] > max_num){
			max_num = num[i];
		} 
	} 
	max_num ++; // 因为会出现0的情况， 将最大值加1就可以， 相当于向右偏移1， 当然 多加也无所谓 
	
	// 树状数组解法 
	
	// 更新 由左向右扫描 
	for(int i = 0; i < N; ++i){
		update(tree_num_left, num[i] + 1, 1); 
		// 若是 替换成 ans_num_right[num[i]] 数据将变得有序 ， 但是后续合并和计算复杂度 最差 将会变高10倍 
		// 而且并不需要有序， 只需要结果就好 
		ans_num_left[i] = tree_sum(tree_num_left, max_num) - tree_sum(tree_num_left, num[i] + 1); 
	}
	// 更新 由右向左扫描 
	for(int i = N - 1; i >= 0; --i){
		update(tree_num_right, num[i] + 1, 1); 
		ans_num_right[i] = tree_sum(tree_num_right, num[i]); 
	}
	// 合并 
	unsigned long long ans_2 = 0;
	for(int i = 0; i < N; ++i){
		ans_num_right[i] += ans_num_left[i]; 
		// 求值
		ans_2 += sum_0_to_n(ans_num_right[i]);
		printf("%ld ", ans_num_right[i]);
	} 
	puts("");
	printf("树状数组求得：%lld\n", ans_2);
	 
	
	gui_pai(0, N - 1);
	// 使用逆序对 计算结果
	for(int i = 0; i < N; ++i){
		ans += sum_0_to_n(ni_num_sum[i]);
	} 
	for(int i = 0; i < N; ++i){
		printf("%ld ", ni_num_sum[i]);
	} 
	puts("");
	printf("归并排序求得: %lld\n", ans);
	
	
	
		
	
	return 0;	
}

运行截图:
在这里插入图片描述

梦鸢MoYuan
关注
专栏目录
蓝桥杯 历届试题 小朋友排队（数状数组+离散化||归并排序||线段树+离散化）...
Y先森0.0
11-30 247
Description n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。 每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。 如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3），依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加...
蓝桥杯--历届试题：小朋友排队（归并排序）
yf224的博客
05-24 1081
问题描述　　n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。　　每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。　　如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3），依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加k。　　请问，要让所有小朋友...
蓝桥杯 小朋友排队
Last Order
12-13 3013
历届试题 小朋友排队   时间限制：1.0s   内存限制：256.0MB     问题描述 　　n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。 　　每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。 　　如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的
蓝桥杯2014年省赛真题-小朋友排队【树状数组】
一个人的巴黎の博客
02-23 979
题目描述 n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。 每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。 如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3），依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加k。 请问，要让所有小朋友按从低到高排队，他们的不高兴程度之和最小是多少。 如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。 样例说明
2014蓝桥杯 小朋友排队
u014587147的专栏
03-17 682
/* *********************************************** Author :小蔡虎 Created Time :2016/ File Name :E:\2016 状态 ： ************************************************ */ #include #include #i
剑指Offer – 面试题51. 数组中的逆序对（归并排序，求逆序对）
01-20
输入一个数组，求出这个数组中的逆序对的总数。 示例 1: 输入: [7,5,6,4] 输出: 5 限制： 0 <= 数组长度 <= 50000 来源：力扣（LeetCode） 链接：...
算法设计之分治思想（求数组的逆序对）
01-21
输入一个数组，求出这个数组中的逆序对的总数。 示例 1: 输入: [7,5,6,4] 输出: 5 限制： 0 <= 数组长度 <= 50000 首先最容易想到的是暴力解法。 方法一：暴力解法（超时） 使用两层 for 循环枚举所有的数对，...
C++树状数组入门模板和简单应用+二分求逆序对
01-03
> #include using namespace std; const int MAX=50005; int a[MAX],tree[MAX],n; int lowbit(int x) //找最低位的1 { return x&-x; } void add(int i,int x)//修改数据在i加x { while(i0) ...树
求数组的逆序数
10-28
在计算机科学和编程领域，"数组的逆序数"是一个重要的概念，特别是在...例如，在快速排序和归并排序中，逆序数可以用来衡量算法的效率。在实际应用中，当处理大量数据时，有效的逆序数计算算法能够显著提高程序性能。
算法：求逆序对个数（暴力&&归并排序&&树状数组&&权值线段树）
Prime me的博客
12-08 2938
算法：求逆序对个数四种方法。 1，暴力 2，归并排序 3，树状数组 4，权值线段树
蓝桥杯历届试题 n个小朋友排队 Java组
这个人很懒什么都没有留下
04-12 692
问题描述 　　n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。 每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。 如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3），依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加k。 请问，要让所有小朋友按从低到高排队，他们的不高兴程度之和最小是多少。 如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。 输入格
蓝桥 小朋友排队 (归并排序求逆序数)
H4ppyD0g的博客
03-29 280
题目描述 n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。 每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。 如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3），依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加k 请问，要让所有小朋友按从低到...
蓝桥杯练习——逆序对
等等waiting
12-04 551
问题描述 Alice是一个让人非常愉跃的人!他总是去学习一些他不懂的问题，然后再想出许多稀奇古怪的题目。这几天，Alice又沉浸在逆序对的快乐当中，他已近学会了如何求逆序对对数，动态维护逆序对对数等等题目，他认为把这些题让你做简直是太没追求了，于是，经过一天的思考和完善，Alice终于拿出了一道他认为差不多的题目： 有一颗2n-1个节点的二叉树，它有恰好n个叶子节点，每个节点上写了一个整数。如果将...
蓝桥杯——2014省赛小朋友排队 逆序对求法（归并排序）C/C++
咕咕酱没有悲伤的博客
03-13 277
题目描述 小朋友排队 n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。 每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。 如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3） 依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加k。 请问，要让所有小朋友按从低到高排队，他们的不高兴程度之和最小是多少？ 如果有两个小朋友身高一样，则他们谁站在谁前面是没有关系的。
蓝桥杯第十二届校内模拟赛 逆序对
qq_43738331的博客
01-01 846
问题描述 　　在一个序列 a = (a[1], a[2], …, a[n]) 中，如果 (i, j) 　　满足 i < j 且 a[i] > a[j]，则称为一个逆序对。 　　例如：(3, 2, 2, 1) 中包含 6 个逆序对。 　　请问，(87, 39, 35, 1, 99, 10, 54, 1, 46, 24, 74, 62, 49, 13, 　　 2, 80, 24, 58, 8, 14, 83, 23, 97, 85, 3, 2, 86, 10, 71, 15) 　　 中包含多少个
蓝桥杯 算法训练 逆序对
old sweet的博客
03-28 1210
资源限制 时间限制：1.0s 内存限制：256.0MB 问题描述 Alice是一个让人非常愉跃的人!他总是去学习一些他不懂的问题，然后再想出许多稀奇古怪的题目。这几天，Alice又沉浸在逆序对的快乐当中，他已近学会了如何求逆序对对数，动态维护逆序对对数等等题目，他认为把这些题让你做简直是太没追求了，于是，经过一天的思考和完善，Alice终于拿出了一道他认为差不多的题目： 有一颗2n-1个节点的...
2022.04.04蓝桥杯第十一届 10.字串排序（逆序对）
qq_45799727的博客
04-04 2746
试题J 字串排序 【问题描述】 小蓝最近学习了一些排序算法，其中冒泡排序让他印象深刻。 在冒泡排序中，每次只能交换相邻的两个元素。小蓝发现，如果对一个字符串中的字符排序，只允许交换相邻的两个字符，则在所有可能的排序方案中，冒泡排序的总交换次数是最少的。 例如，对于字符串 lan 排序，只需要 1 次交换。对于字符串 qiao 排序，总共需要 4 次交换。 小蓝找到了很多字符串试图排序，他恰巧碰到一个字符串，需要 V 次交换，可是他忘了把这个字符串记下来，现在找不到了。 请帮助小蓝找一个只包含小写英文字母
【蓝桥杯官网试题 - 历届试题】小朋友排队（逆序数，树状数组）
xuanweiace的博客
04-08 445
题干： 问题描述 　　n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。 　　每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。 　　如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3），依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加k。 　　...
蓝桥杯小朋友排队JAVA
lirunhui6的博客
01-08 2100
问题描述　　n 个小朋友站成一排。现在要把他们按身高从低到高的顺序排列，但是每次只能交换位置相邻的两个小朋友。　　每个小朋友都有一个不高兴的程度。开始的时候，所有小朋友的不高兴程度都是0。　　如果某个小朋友第一次被要求交换，则他的不高兴程度增加1，如果第二次要求他交换，则他的不高兴程度增加2（即不高兴程度为3），依次类推。当要求某个小朋友第k次交换时，他的不高兴程度增加k。　　请问，要让所有小朋友...
树状数组求逆序对 时间复杂度
最新发布
09-11
树状数组求逆序对的时间复杂度为O(nlogn)，其中n为数组的大小。 树状数组（也称为BIT，Binary Indexed Tree）是一种高效的数据结构，可以用来求解一些区间操作的问题。对于求逆序对的问题，我们可以利用树状数组来...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梦鸢MoYuan

谢谢投喂！！！QWQ！！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值