详细题解|蓝桥杯第十一届软件类校内模拟赛

大纲:

1.GB*1024=MB 答案:15488
2.枚举约数,答案:96
3.完全二叉树最多,答案:1010(不知道有没有看错题,是不是二叉)
4.枚举,判是否包含9,544
5.50%数据:3层枚举判递增;100%数据:思路1,枚举中心点,查左边<i的,查右边>i的,总时间复杂度O(n^2);思路2:查询可以优化,用树状数组查,总时间复杂度O(longn)
6.100%数据:枚举,倒着判数字是否递减,O(10^7) 不会超时
7.100%数据:字符串模拟
8.70%数据:按题意模拟,更新原草地;100%数据:思路1,bfs搜索;思路2:二维差分
9.50%数据:dfs暴力搜索;80%数据:记忆化搜索;100%数据:记忆化搜索+打表。
10.60%数据:按题意模拟,每次查询前一个元素后面的元素的最大值;时间复杂度O(n^2);100%数据:思路1:按60%的思路中的查询可以用线段树优化,用线段树查询区间最大值,时间复杂度O(nlongn)

下面是详细代码和大题按数据点给分的各个思路:

1. 答案:15488

15.125GB*1024 = 15488MB,用计算器算一下,答案是15488


2. 答案:96

1200000有多少个约数(只计算正约数)。
枚举1200000的约数,set去重

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

const int maxn = 1e6+10;

set<int> se;
int main(){
	ll x = 1200000;
	for(ll i = 1; i <= sqrt(x); i++){
		if(x%i == 0) {
			se.insert(i);
			se.insert(x/i);
		}
	}
	cout<<se.size();
	return 0;
} 

3. 答案:未知

一棵包含有2019个结点的树,最多包含多少个叶结点?
不记得是不是二叉树了,如果是一颗普通的树,那么答案是2018;
如果是一个二叉树,那么在类满二叉树下,叶节点最多,答案可能是1010;(不确定)

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

const int maxn = 1e6+10;
int n = 2019;

int main(){
	ll sum = 0;
	int maxDeep = 0;
	for(int depth = 0;depth<=10000;depth++){ //枚举满二叉树的层数
		if(sum + pow(2,depth) > n) break;
		sum += pow(2,depth);
		maxDeep = depth;
	}
	cout<<(pow(2,maxDeep) - ((n-sum)/2)) + (n-sum); //最后一层有可能不满,那么倒数第二层有(pow(2,maxDeep) - ((n-sum)/2))个非叶子节点,再加上最后一层的叶子节点(n-sum)个
	return 0;
} 

4. 答案:544

在1至2019中,有多少个数的数位中包含数字9?
枚举1~2019,判断是否包含9

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

const int maxn = 1e6+10;

int cnt = 0;

bool contain(int x){
	if(x == 9) return true;
	if(x<9) return false;
	while(x){
		if(x%10 == 9) return true;
		x = x/10;
	}
	return false;
}

int main(){
	for(int i=1;i<=2019;i++){
		if(contain(i)) cnt++;
	}
	cout<<cnt;
	return 0;
} 

5.

问题描述
在数列 a[1],a[2],...,a[n] 中,如果对于下标 i,j,k 满足 0<i<j<k<n+1 且 a[i]<a[j]<a[k],则称 a[i],a[j],a[k] 为一组递增三元组,a[j] 为递增三元组的中心。

给定一个数列,请问数列中有多少个元素可能是递增三元组的中心。

输入格式
输入的第一行包含一个整数 n。

第二行包含 n 个整数 a[1],a[2],...,a[n] ,相邻的整数间用空格分隔,表示给定的数列。

输出格式
输出一行包含一个整数,表示答案。

评测用例规模与约定
对于 50 的评测用例,2<=n<=100,0<=Num<=1000 。
对于所有评测用例,2<=n<=1000,0<=Num<=10000 。

50% 3层枚举,判递增

3层枚举,只要a[i] < a[j] < a[k]说明满足条件了

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

//50%

const int maxn = 1e5+100;
int a[maxn];
int n;
set<int> se;
int main(){
	cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i];
	ll cnt = 0;
	for(int i=1;i<=n;i++){
		for(int j=i+1;j<=n;j++){
			if(a[j] > a[i]){
				for(int k=j+1;k<=n;k++){
					if(a[k] > a[j]) 
						se.insert(j);
				}
			}
		}
	}
	cout<<se.size();
	return 0;
} 

100% 枚举中心点,O(n^2)

枚举中心点,查左边<i的,查右边>i的,如果中心点左边有比它小的数,同时中心点右边有比它大的数,就满足条件,总数+1。总时间复杂度O(n^2)。

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

//100% 枚举O(n^2) 

const int maxn = 1e5+100;
int a[maxn];
int n;
int main(){
	cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i];
	ll cnt = 0;
	for(int center = 2;center<=n-1;center++){ //枚举中心点 
		int leftNum = 0,rightNum = 0;
		for(int left = 1;left<center;left++){ //统计左边比它小的 
			if(a[left] < a[center]) leftNum++;
		}
		for(int right = center+1;right<=n;right++){ //统计右边比它大的 
			if(a[right] > a[center]) rightNum++;
		}
		if(leftNum * rightNum != 0) cnt++;
	}
	cout<<cnt;
	return 0;
} 

100% 树状数组优化O(nlongn)

树状数组维护分别正序和倒序维护各个数出现的次数,动态查询
1.正序建树:查询中心点左边比它的值小的个数,就是查此时1~i-1的数的个数
2.逆序建树:查询中心点右边比它的值大的个数,就是查此时i+1~n的数的个数
3.枚举中心点: 如果中心点左边有比它小的数,同时中心点右边有比它大的数,就是一个合法的中心点

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

/*
100% nlogn
树状数组维护分别正序和倒序维护各个数出现的次数,动态查询 
1.正序建树:查询中心点左边比它的值小的个数,就是查此时1~i-1的数的个数
2.逆序建树:查询中心点右边比它的值大的个数,就是查此时i+1~n的数的个数
3.枚举中心点: 如果中心点左边有比它小的数,同时中心点右边有比它大的数,就是一个合法的中心点 
*/
const int maxn = 1e5+100;
int C[maxn];
int a[maxn];
int n;
int cnt1[maxn],cnt2[maxn];

int lowbit(int x){
	return x & -x; 
} 

int getsum(int x){ //查前缀和 
	int ans = 0;
	while(x >= 1){
		ans += C[x];
		x = x - lowbit(x);
	}
	return ans;
}

void add(int x,int k){
	while(x <= n){
		C[x] = C[x] + k;
		x = x + lowbit(x);
	}
}

int query(int l,int r){ //区间查询 
	return getsum(r) - getsum(l-1);
}


int main(){
	cin>>n;
	for(int i=1;i<=n;i++) {
		cin>>a[i];
		add(a[i],1); //正序建树查左侧比i个元素小的 
		cnt1[i] = query(1,i-1); 
	}
	memset(0,sizeof(C),0);
	for(int i=n;i>=1;i--){ //倒序建树 查右侧比第i个元素大的 
		add(a[i],1);
		cnt2[i] = query(i+1,n);
	}
	ll cnt = 0;
	for(int i=1;i<=n;i++){ //枚举中心点 
		if(cnt1[i] && cnt2[i]) cnt++;
	}
	cout<<cnt;
	return 0;
} 
/*
5
1 2 5 3 5
*/

6.

问题描述
一个正整数如果任何一个数位不大于右边相邻的数位,则称为一个数位递增的数,例如 1135 是一个数位递增的数,而 1024 不是一个数位递增的数。

给定正整数 n ,请问在整数 1 至 n 中有多少个数位递增的数?

输入格式
输入的第一行包含一个整数 n 。

输出格式
输出一行包含一个整数,表示答案。

评测用例规模与约定
对于 40% 的评测用例,1<=n<=1000。
对于 80% 的评测用例,1<=n<=100000。
对于所有评测用例,1<=n<=1000000。

100%数据:枚举,倒着数字判递减,O(10^7)

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

//100%

const int maxn = 1e6+10;

int n;

bool solve(int x){
	if(x < 10 ) return true;
	int last = x%10;
	x = x / 10;
	while(x){
		if(x%10 > last) return false;
		last = x%10;
		x = x / 10;
	}
	return true;
}

int main(){
	cin>>n;
	ll cnt = 0;
	for(int i=1;i<=n;i++){
		if(solve(i)) cnt++;
	}
	cout<<cnt;
	return 0;
} 

7.

问题描述
小明对类似于 hello 这种单词非常感兴趣,这种单词可以正好分为四段,第一段由一个或多个辅音字母组成,第二段由一个或多个元音字母组成,第三段由一个或多个辅音字母组成,第四段由一个或多个元音字母组成。
给定一个单词,请判断这个单词是否也是这种单词,如果是请输出yes,否则请输出no。
元音字母包括 a,e,i,o,u ,共五个,其他均为辅音字母。

输入格式
输入一行,包含一个单词,单词中只包含小写英文字母。

输出格式
输出答案,或者为 yes ,或者为 no 。

评测用例规模与约定
对于所有评测用例,单词中的字母个数不超过 100

100%数据 按题意字符串模拟

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

const int maxn = 1e6+10;

string a;

int main(){
	cin>>a;
	int pos = 1;
	int level = 1;
	bool flag = true;
	int len = a.length();
	while(pos < len){
		if(level == 2){ //元音 
			int ago = pos;
			while(pos < len && (a[pos] == 'a'|| a[pos] == 'e' || a[pos] == 'i' || a[pos] == 'o' || a[pos] == 'u')){
				pos++; 
			} 
			if(pos == ago && !((a[pos] == 'a'|| a[pos] == 'e' || a[pos] == 'i' || a[pos] == 'o' || a[pos] == 'u'))) flag = false;
			level++;
		}else if(level == 1){  
			int ago = pos;
			while(pos < len && (a[pos] != 'a'&& a[pos] != 'e' && a[pos] != 'i' && a[pos] != 'o' && a[pos] != 'u')){
				pos++; 
			} 
			if(pos == ago && !(a[pos] != 'a'&& a[pos] != 'e' && a[pos] != 'i' && a[pos] != 'o' && a[pos] != 'u')) flag = false;
			level++;
		}else if(level == 4){ //元音 
			int ago = pos;
			while(pos < len && (a[pos] == 'a'|| a[pos] == 'e' || a[pos] == 'i' || a[pos] == 'o' || a[pos] == 'u')){
				pos++; 
			} 
			if(pos == ago && !((a[pos] == 'a'|| a[pos] == 'e' || a[pos] == 'i' || a[pos] == 'o' || a[pos] == 'u'))) flag = false;
			level++;
		}else if(level == 3){
			int ago = pos;
			while(pos < len && (a[pos] != 'a'&& a[pos] != 'e' && a[pos] != 'i' && a[pos] != 'o' && a[pos] != 'u')){
				pos++; 
			} 
			if(pos == ago && !((a[pos] != 'a'&& a[pos] != 'e' && a[pos] != 'i' && a[pos] != 'o' && a[pos] != 'u'))) flag = false;
			level++;
		}else flag = false;
		if(flag == false) break;
	}
	if(flag && level == 5) puts("yes");
	else puts("no");
	return 0;
} 

8.

问题描述
小明有一块空地,他将这块空地划分为 n 行 m 列的小块,每行和每列的长度都为 1 。

小明选了其中的一些小块空地,种上了草,其他小块仍然保持是空地。

这些草长得很快,每个月,草都会向外长出一些,如果一个小块种了草,则它将向自己的上、下、左、右四小块空地扩展,这四小块空地都将变为有草的小块。

请告诉小明,k 个月后空地上哪些地方有草。

输入格式
输入的第一行包含两个整数 n , m 。

接下来 n 行,每行包含 m 个字母,表示初始的空地状态,字母之间没有空格。如果为小数点,表示为空地,如果字母为 g,表示种了草。

接下来包含一个整数 k。

输出格式
输出 n 行,每行包含 m 个字母,表示 k 个月后空地的状态。如果为小数点,表示为空地,如果字母为 g,表示长了草。

评测用例规模与约定
对于 30% 的评测用例,2<=n,m<=20。
对于 70% 的评测用例,2<=n,m<=100。
对于所有评测用例,2<=n,m<=1000,1<=k<=1000。

70% 模拟

按题意模拟,开一个新数组更新草地,更新完将复制给旧数组。一月更新一次。

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

const int maxn = 1100;

int n,m,k;
char a[maxn][maxn];
char s[maxn][maxn];

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++) {
			cin>>a[i][j];
			s[i][j] = a[i][j];
		}
	}
	cin>>k;
	for(int i=1;i<=k;i++){
		for(int p = 1;p <= n;p++){
			for(int q = 1;q <= m;q++){
				if(a[p][q] == 'g'){
					s[p-1][q] = 'g';
					s[p+1][q] = 'g';
					s[p][q-1] = 'g';
					s[p][q+1] = 'g';
				}
			}
		}
		for(int p=1;p<=n;p++){
			for(int q=1;q<=m;q++) a[p][q] = s[p][q];
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cout<<a[i][j];
		}
		cout<<endl;
	}
	return 0;
} 
/*
2 2
.g
..
1
*/

100% bfs搜索

把最初是'g'的坐标先入队列,跑bfs,bfs分层的性质保证了 土地每次都是向外一次一次扩展(即:每个月用最外层的草地扩展一次),每次扩展把4个方向满足条件的加入队列。直到dist=k 说明从最初的g点已经走了k个距离 不能再走下去了。

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

const int maxn = 1100;

int n,m,k;
char a[maxn][maxn]; 
struct node{
	int x,y,dist;
};
queue<node> que;

void bfs(){
	while(!que.empty()){
		node u = que.front(); //取出队头 
		que.pop();
		if(u.dist == k) continue; //dist=k 说明从最初的g点已经走了k个距离 不能再走下去了 
		int x = u.x,y = u.y,dist = u.dist;
		//把4个方向满足条件的加入队列  作一次扩展 
		if(x+1<=n && a[x+1][y] != 'g'){
			a[x+1][y] = 'g';
			que.push({x+1,y,dist+1});
		}
		if(y+1<=m && a[x][y+1] != 'g'){
			a[x][y+1] = 'g';
			que.push({x,y+1,dist+1});
		}	
		if(x-1>=1 && a[x-1][y] != 'g'){
			a[x-1][y] = 'g';
			que.push({x-1,y,dist+1});
		}
		if(y-1>=1 && a[x][y-1] != 'g'){
			a[x][y-1] = 'g';
			que.push({x,y-1,dist+1});
		}
	}
}

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++) {
			cin>>a[i][j];
			if(a[i][j] == 'g') que.push({i,j,0}); //把最初是'g'的先入队 
		}
	}
	cin>>k;
	bfs();//跑一遍bfs bfs分层的性质保证了 土地每次都是向外一次一次扩展(即:每个月用最外层的草地扩展一次)
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++) {
			cout<<a[i][j];
		}
		cout<<endl;
	}
	return 0;
} 
/*
4 5
.g...
..... 
..g..
.....
2
*/

100% 二维差分

每一个初始点g,影响的范围是一个菱形,用二维差分标记
参考这道题:https://www.cnblogs.com/fisherss/p/10388172.html

9.

问题描述
小明想知道,满足以下条件的正整数序列的数量:

第一项为 n ;
第二项不超过 n ;
从第三项开始,每一项小于前两项的差的绝对值。
请计算,对于给定的 n ,有多少种满足条件的序列。

输入格式
输入一行包含一个整数 n 。

输出格式
输出一个整数,表示答案。答案可能很大,请输出答案除以 10000 的余数。

评测用例规模与约定
对于 20% 的评测用例,1<=n<=5。
对于 50% 的评测用例,1<=n<=10。
对于 80% 的评测用例,1<=n<=100。
对于所有评测用例,1<=n<=1000。

50% dfs暴力搜索

n==2的时候 有n种方案,分别可以放1~n;
dfs判n>3的情况

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

//50% dfs暴力搜索 

const int maxn = 1010;
int n;
ll cnt = 0;
int a[maxn];

void dfs(int pos,int u,int v){ //判n>3的情况
	cnt = (cnt+1)%10000;
	int d = abs(v-u);
	if(d == 0) return;
	for(int i=1;i<d;i++){
		a[pos] = i;
		dfs(pos+1,i,u);
	}
}

int main(){
	cin>>n;
	a[1] = n;
	for(int i=n;i>=1;i--){ //n==2的时候 有n种方案,分别可以放1~n
		a[2] = i;
		dfs(3,i,n);
	}
	cout<<cnt;
	return 0;
} 

80%数据 记忆化搜索

开个map作缓存,能过80%数据

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

//80% 记忆化搜索 

int n;
map<pair<int,int>,int > mp;

int dfs(int u,int v){
	if(mp[make_pair(u,v)]) return mp[make_pair(u,v)];
	int d = abs(v-u);
	if(d == 0) return mp[make_pair(u,v)] = 1;
	ll cnt = 1;
	for(int i=1;i<d;i++){
		cnt = (cnt + dfs(i,u))%10000;
	}
	return mp[make_pair(u,v)] = cnt%10000;
}

int main(){
	cin>>n;
	ll ans = 0;
	for(int i=n;i>=1;i--){
		ans = (ans + dfs(i,n))%10000;
	}
	cout<<ans;
	return 0;
} 

##100%数据 记忆化搜索 + 打表法 在记忆化搜索的基础上,打表 本地打表的测试代码
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

//100% 打表法: 本地打表的测试代码 

int n;
map<pair<int,int>,int > mp;

int dfs(int u,int v){
	if(mp[make_pair(u,v)]) return mp[make_pair(u,v)];
	int d = abs(v-u);
	if(d == 0) return mp[make_pair(u,v)] = 1;
	ll cnt = 1;
	for(int i=1;i<d;i++){
		cnt = (cnt + dfs(i,u))%10000;
	}
	return mp[make_pair(u,v)] = cnt%10000;
}

int main(){
	freopen("9.txt","w",stdout);
	printf("int table[1100] = {0,");
	for(n = 1;n<=1000;n++){
		ll ans = 0;
		for(int i=n;i>=1;i--){
			ans = (ans + dfs(i,n))%10000;
		}
		printf("%d",ans%10000);
		if(n!=1000) printf(",");
	}
	printf("}");
	return 0;
} 

打表后正式上交的代码

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

//100% 打表上交的代码 

int n;
int table[1100] = {0,1,2,4,7,14,26,53,106,220,452,946,1967,4128,8638,8144,8068,........篇幅有限见下图};

int main(){
	cin>>n;
	cout<<table[n];
	return 0;
} 



10.

问题描述
小明要组织一台晚会,总共准备了 n 个节目。然后晚会的时间有限,他只能最终选择其中的 m 个节目。

这 n 个节目是按照小明设想的顺序给定的,顺序不能改变。

小明发现,观众对于晚上的喜欢程度与前几个节目的好看程度有非常大的关系,他希望选出的第一个节目尽可能好看,在此前提下希望第二个节目尽可能好看,依次类推。

小明给每个节目定义了一个好看值,请你帮助小明选择出 m 个节目,满足他的要求。

输入格式
输入的第一行包含两个整数 n , m ,表示节目的数量和要选择的数量。

第二行包含 n 个整数,依次为每个节目的好看值。

输出格式
输出一行包含 m 个整数,为选出的节目的好看值。

评测用例规模与约定
对于 30% 的评测用例,1<=n<=20;
对于 60% 的评测用例,1<=n<=100;
对于所有评测用例,1<=n<=100000,0<=value<=100000。

60% 枚举

按题意模拟
1.每次选1个数 i∈1~m
2.当前这个数就是: 上一次选的数的右边 ~ n-(m-i)的区间内的最大值,这里可以O(n)枚举,也可以O(longn)优化

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

/*
60%
1.每次选1个数 i∈1~m 
2.当前这个数就是: 上一次选的数的右边 ~ n-(m-i)的区间内的最大值,这里可以O(n)枚举,也可以O(longn)优化 
*/ 

const int maxn = 1e5+100;
int n,m;
int a[maxn];
int b[maxn];

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>a[i];
	int pos = 0;
	for(int i = 1;i<=m;i++){ //选第i个数  
		int maxi = a[pos+1];
		for(int j=pos+1;j<n-(m-i)+1;j++){ //pos+1 ~ n-(m-i)+1可以选择 
			if(a[j] > maxi){ //选出这个区间内最大的,并更新最大值和所在位置下标 
				maxi = a[j];
				pos = j;
			}
		}
		b[i] = maxi;
	}
	for(int i=1;i<m;i++) cout<<b[i]<<" ";
	cout<<b[m];
	return 0;
} 

100% 线段树优化查询

按60%的思路中的查询可以用线段树优化,用线段树查询区间最大值,并记录结点的位置下标 ,时间复杂度O(nlongn)

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

/*
100% 开一个线段树维护区间最大值 并记录结点的位置下标 
1.每次选1个数 i∈1~m 
2.当前这个数就是: 上一次选的数的右边 ~ n-(m-i)的区间内的最大值,可以O(longn)优化 
*/ 

const int maxn = 1e5+100;
int n,m;
int a[maxn];
int b[maxn];

struct node{
	int pos;
	ll maxv;
}tree[maxn*4]; 

void pushup(int o){
	if(tree[o<<1].maxv > tree[o<<1|1].maxv){
		tree[o].maxv = tree[o<<1].maxv;
		tree[o].pos = tree[o<<1].pos;
	}else{
		tree[o].maxv = tree[o<<1|1].maxv;
		tree[o].pos = tree[o<<1|1].pos;
	}
}

void build(int o,int l,int r){
	//初始化结点的标记 
	tree[o].maxv = 0;
	//叶子结点 
	if(l == r){
		tree[o].pos = l;
		tree[o].maxv = a[l];
		return;
	}
	int mid = (l+r)>>1;
	build(o<<1,l,mid);
	build(o<<1|1,mid+1,r);
	pushup(o);
}

void update(int o,int l,int r,int pos,int v){
	if(l == r){ //完全包含该l~r区间 
		tree[o].maxv += v;
		return;
	}
	int mid = (l+r)>>1;
	if(pos <= mid) update(o<<1,l,mid,pos,v);
	else update(o<<1|1,mid+1,r,pos,v);
	pushup(o);
}

pair<int,ll> querymax(int o,int l,int r,int ql,int qr){
	if(ql <= l && r <= qr){ //完全包含 直接return 
		return make_pair(tree[o].pos,tree[o].maxv);
	}
	int mid = (l+r)>>1;
	//查询出区间最大的max 
	pair<int,ll> temp,u,v; 
	if(ql<=mid) {  
		u = querymax(o<<1,l,mid,ql,qr);
		temp = u;
	}
	if(qr>mid) {
		v = querymax(o<<1|1,mid+1,r,ql,qr);
		if(v.second > temp.second) temp = v;
	}
	return temp;
}

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>a[i];
	build(1,1,n);
	int pos = 0;
	for(int i = 1;i<=m;i++){ //选第i个数  
		int maxi = a[pos+1];
		//查询pos+1~(n-(m-i) 闭区间的最大值 
		pair<int,ll> u = querymax(1,1,n,pos+1,n-(m-i));
		pos = u.first; //第i个数选了pos位置 
		maxi = u.second; //第i个数选了maxi这个值 
		b[i] = maxi;
	}
	for(int i=1;i<m;i++) cout<<b[i]<<" ";
	cout<<b[m];
	return 0;
} 
/*
5 3
3 1 2 5 4
*/

不保证每个点的正确性...思路仅供参考...

posted @ 2020-03-21 23:05  fishers  阅读(907)  评论(2编辑  收藏  举报