【No.7】蓝桥杯枚举法与尺取法|第几个幸运数字|42点问题|二进制手写子集代码|排列序数|火星人|回文判定|找指定和的整数对|美丽的区间(C++)

暴力法的最后一块拼图
枚举题
题目需要处理大量同类情况
暴力枚举所有情况
利用计算机强大的算力
注意:不要遗漏任何情况
注意:如果枚举量太大,需要剪枝

  • 枚举法
    • 简单型枚举
    • 组合型枚举
    • 排列型枚举
    • 指数型枚举
  • 尺取算法

枚举法

枚举算法的思想:
将问题的所有可能成为答案的解一一列举,然后根据问题给定的条件判断这些解是否合适。如果合适就保留;反之则舍弃。
枚举算法解题的基本思路:

  1. 确定枚举解的范围和判断条件
  2. 选择适当的枚举方式进行逐一枚举,确保覆盖所有可能的解。避免遗漏任何真正的解,注意防止重复。
  3. 在枚举过程中,应用事先确定的判断条件验证每个解的合法性,保留符合要求的解。
    枚举算法的一般步骤:
  4. 根据题目确定枚举的范围,并选择合适的枚举方式。确保不遗漏任何真正的解,同时避免重复。
  5. 优化解空间:查看是否存在优化的可能性,以缩小可能成为解的答案范围,提高解决问题的效率。
  6. 定义准确验证条件:根据问题找到准确、易编码的验证条件,用于检验每个可能的解。
  7. 枚举和判断:逐一枚举解并验证是否符合事先确定的条件,保留符合条件的解。
  8. 按照要求输出枚举过程中留下的符合条件的解。
第几个幸运数字
题目描述

一个整数如果只含有因子3、5、7,称为幸运数字
前十个幸运数字是3、5、7、9、15、21、25、27、35、45
问59084709587505是第几个幸运数字

题目解析
枚举思路

暴力枚举,这个系列的数可以表示为 3 i ∗ 5 j ∗ 7 k 3^i*5^j*7^k 3i5j7k
从小到大开始枚举
当i,j,k=0
000、100、010、001
然后从有两个是1的开始枚举,一层一层加上去
枚举所有不超过范围的i、j、k组合
通过计算得代码中最小的 3 50 3^{50} 350肯定超过59084709587505
long long a = pow(3,50);
所以 i + j + k < 50 i+j+k< 50 i+j+k<50

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

int main()
{
	long long n = 59084709587505;
	int cnt = 0;
	for (int i = 0; pow(7, i) < n; i++)
		for (int j = 0; pow(5, j) < n; j++)
			for (int k = 0; pow(3, k) < n; k++)
				if (pow(7, i)*pow(5, j)*pow(3, k) <= n)
					cnt++
	count << cnt - 1;
	//1906 - 1 = 1905,幸运数字不包括1
	return 0;
}

简单型枚举

简单型枚举是通过简单的 for 循环嵌套解决的问题类型。在之前的课程中,我们所讨论的题目通常属于简单型枚举的范畴。因此,简单型枚举是一种相对简单且大家接触最多的枚举方式。
这种枚举方式没有特定的固定枚举模式,而且相对简单。只需按照题目的要求设计代码即可完成解题。
让我们通过一个示例题目来复习一下。

42 点问题

蓝桥杯递推与递归法|斐波那契数列|数字三角形|42点问题|数的计算|数的划分(C++)-优快云博客

组合型枚举

排列组合是大家都接触过的概念,而组合型枚举则是在 n 个元素中随机选出 m 个元素的问题。对于每一种可能的选择方案,我们需要确定选择了哪 m 个元素,这就是组合型枚举。
具体而言,组合型枚举解决的是  C n m C^m_{n} Cnm​ 问题,即从 n 个元素中选择 m 个元素的组合数量。
组合型枚举有一套固定的流程和算法模板,需要大家进行记忆。
借助DFS搜索去实现的一个模板

#include<bits/stdc++.h>
using namespace std;
int n;//共计N个数
int m;//选m个数去组合

vector<int> chosen;
string s[1000];
void calc(int x) {
    if (chosen.size() > m || chosen.size() + (n - x + 1) < m) //剪枝,选了的超过m个,就不需要再选了||已经选的数字+还有几个数字没有选如果小于m了,表示把后面所有的数字都选上,也选不够m个数
    //x指 选到第几个数了
    //n-x+1 表示还有几个数没有选,当前选到第三个数,一共有五个数字可以选,5-3,还剩两个数字没处理,+1是因为,处理到第三个数了,第三个数是可以选、可以不选的
        return; //回溯
    if (x == n + 1)  //处理到第n+1个数,如果有答案的话,前面就找到答案了
    { //选够了m个数输出
        for (int i = 0; i < chosen.size(); i++)
            cout<< s[chosen[i]]<<" ";//也可以不输出,存放起来也是可以的,主要是看题目。
        puts("");
        return;
    }
    chosen.push_back(x);
    calc(x + 1);
    chosen.pop_back();//消除痕迹
    calc(x + 1);
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>s[i];
    }
    calc(1);
}

大家有个疑虑,我这里全是数字而且是从 1 开始的能好用吗,我题目要是字母怎么办,那么请看下面的题目。

排列型枚举

上面说过,组合型枚举就是让你在 n 个中,随机选出 m 个 ,问你有多少种方案,而且每一种方案选择了哪 m 个,这就是组合型枚举。
而排列型枚举相对组合型枚举就简单了一点,就是 n 个的全排列,即从 n 个中选取 n 个但是关心内部的顺序。
相比较组合只关心有多少个集合,而排列是关心集合内的排列方式。即排列型枚举就是寻找  A n n A^n_{n} Ann​ 问题。
而且排列型枚举也是有着比较成熟的模板需要大家进行记忆。

int n; //共计N个数
int order[20];
bool chosen[20];
void calc(int k)
{
    if (k == n + 1) //一个数一个数去处理,处理到k=n+1的时候,说明处理完前n个数了
    {
        for (int i = 1; i <= n; i++)
            cout << order[i] << " ";

        puts("");

        return;
    }
    for (int i = 1; i <= n; i++)
    {
        if (chosen[i])
            continue;
        order[k] = i;
        chosen[i] = 1;
        calc(k + 1);
        //恢复现场
        chosen[i] = 0;
        order[k] = 0;
    }
}
int main()
{
    cin >> n;
    calc(1);
}

20 够不够,排列问题是阶乘阶的时间复杂度,如果超过这个复杂度,那么这个题也就不用做了,算不出来。
所以肯定够用。

4
1 2 3 4
1 2 4 3
1 3 2 4
1 3 4 2
1 4 2 3
1 4 3 2
2 1 3 4
2 1 4 3
2 3 1 4
2 3 4 1
2 4 1 3
2 4 3 1
3 1 2 4
3 1 4 2
3 2 1 4
3 2 4 1
3 4 1 2
3 4 2 1
4 1 2 3
4 1 3 2
4 2 1 3
4 2 3 1
4 3 1 2
4 3 2 1

4 的排列就已经这么多了,大家可以尝试跑一下 10。

枚举技术:排列

C++ STL:求下一个排列组合的函数next_permutation()
返回值:如果没有下一个排列组合,返沪false,否则返回true
每执行next_permutation()一次,会把新的排列放到原来的空间里
注意,它排列的范围是[first,last),包括first,不包括last
next_permutation()从当前的全排列开始,逐个输出更大的全排列,而不是输出所有的全排列

#include <bits/stdc++.h>
using namespace std;
int main()
{
	string s = "bca";
	sort(s.begin(), s.end()); //字符串内部排序,得到最小的排列"abc"
	do{
		cout << s << "\n";
	}while (next_permutation(s.begin(), s.end()));
	return 0;
}
手写子集代码:二进制法

一个包含n个元素的集合{ a 0 … a n − 1 a_{0}\dots a_{n-1} a0an1},它的子集有{ 空集 空集 空集},{ a 0 a_{0} a0},{ a 1 a_{1} a1},…,{ a 0 … a n − 1 a_{0}\dots a_{n-1} a0an1}。共 2 n 2^n 2n
用二进制的概念进行对照,子集正好对应了二进制,例如n=3的集合{{ a 0 , a 1 , a 2 a_{0}, a_{1}, a_{2} a0,a1,a2},它的子集和二进制数的对应关系是

子集二进制数十进制数
空集0000
a 0 a_{0} a00011
a 1 a_{1} a10102
a 0 , a 1 a_{0}, a_{1} a0,a10113
a 2 a_{2} a21004
a 0 , a 2 a_{0},a_{2} a0,a21015
a 1 , a 2 a_{1}, a_{2} a1,a21106
a 0 , a 1 , a 2 a_{0}, a_{1}, a_{2} a0,a1,a21117
怎么去枚举二进制
因为二进制数所对应的十进制数为0~7,所以只需要从0开始枚举到 2 n − 1 2^{n-1} 2n1
在转化为二进制,在把二进制的每个数位拆分出来,这个题就做出来了
每个子集对应了一个二进制数,二进制数中的每个一,对应了子集中的某个元素
子集中的元素,是不分先后的,这正符合组合的要求
输出n个数的任意组合子集
通过处理每个二进制数中的1,打印出了所有的子集
#include <bits/stdc++.h>
using namespace std;
int a[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
void print_subset(int n)
{
	for (int i = 0; i < (1 << n); i ++)
	//1左移一次10表示2的0次,左移两次100,4表示2的2次,左移n次,表示2的n次,表示从0到2^n-1的枚举
	//i:0~2^n,每个i的二进制数对应一个子集,一次打印一个子集,最后得到所有子集
	{   
		for (int j = 0; j < n; j ++) //打印一个子集,即打印i的二进制数中所有的1,3个数就是3位二进制,n个数就是n位。枚举位数
		[
			if (i & (1 << j)) //从i的最低位开始,逐个检查每一位,如果是1,打印 (让1左移,从第一位开始和i的每一位比较,同为1,表示存在这一位对应的a[j],输出打印)
			//& 同时为1,才为1
				cout << a[j] << " ";
		]
		cout << "\n";
	}
}
int main()
{
	int n = 3;
	print_subset(n);
	//打印前n个元素a[0]~a[n-1]的所有子集
}
排列序数

【题目描述】如果用abcd这4个字母组成一个串,有4!=24种。现在有不多于10个两两不同的小写字母,给出它们组成的串,你能求出该串在所有排列中的序号吗?
【输入描述】输入一行,一个串。
【输出描述】输出一行,一个整数,表示该串在其字母所有排列生成的串中的序号。注意:最小的序号是0.

题目解析

先对输入的串s排序,然后用next_permutation()输出全排列,当全排列与初始的串相等时结束

#include <bits/stdc++.h>
using namespace std;
int main()
{
	string s, olds;  
	cin >> s;
	olds = s;  //用olds记录最初的串

	int cnt = 0;
	sort (s.begin(), s.end()); //字符串内部排序,得到最小的排列
	do {
		if (s == olds)
		{
			cout << cnt << endl;
			break;
		}
		cnt ++;
	}while (next_permutation(s.begin(), s.end()));
	return 0;
}
火星人
题目描述

人类终于登上了火星的土地并且见到了神秘的火星人。人类和火星人都无法理解对方的语言,但是我们的科学家发明了一种用数字交流的方法。这种交流方法是这样的,首先,火星人把一个非常大的数字告诉人类科学家,科学家破解这个数字的含义后,再把一个很小的数字加到这个大数上面,把结果告诉火星人,作为人类的回答。
火星人用一种非常简单的方式来表示数字–掰手指。火星人只有一只手,但这只手上有成千上万的手指,这些手指排成一列,分别编号为1,2,3…….。火星人的任意两根手指都能随意交换位置,他们就是通过这方法计数的。
一个火星人用一个人类的手演示了如何用手指计数。如果把五根手指——拇指、食指、中指、无名指和小指分别编号为 1,2,3,4,5,当它们按正常顺序排列时,形成了5位数 12345,当你交换无名指和小指的位置时会形成5位数 12354,当你把五个手指的顺序完全颠倒时,会形成 54321,在所有能够形成的120个5位数中,12345 最小,它表示1:12354第二小,它表示2;54321最大,它表示 120。下表展示了只有3根手指时能够形成的 6个3位数和它们代表的数字:
三进制数

123
132
213
231
312
321

代表的数字

1
2
3
4
5
6

现在你有幸成为了第一个和火星人交流的地球人。一个火星人会让你看他的手指,科学家会告诉你要加上去的很小的数。你的任务是,把火星人用手指表示的数与科学家告诉你的数相加,并根据相加的结果改变火星人手指的排列顺序。输入数据保证这个结果不会超出火星人手指能表示的范围。

题目描述

给出N个数的排列,输出这个排列后面的第M个排列。

输入描述

第一行有一个正整数 N,1≤N≤10000。第二行是一个正整数 M。下一行是1到N个整数的一个排列,用空格隔开

输出描述

输出一行,这一行含有 N 个整数,表示原排列后面第M个排列。每两个相邻的数中间用一个空格分开,不能有多余的空格

输入样例
5
3
1 2 3 4 5
输出样例
1 2 4 5 3
题目解析

用C++编码十分容易,因为next_permutation()直接按元素大小顺序进行排列,它能从当前排列开始,按顺序输出下一个更大的排列,连续做m次,就是答案

#incldue <bits/stdc++.h>
using namespace std;
int a[100000];
int main()
{
	int n, m;
	cin >> n >> m;
	for (int i = 1; i <= n; ++ i)
		cin >> a[i];
	for (int i = 1; i <= m; ++ i)
		next_permutation(a + 1, a + n + 1);
	for (int i = 1; i <= n; ++ i)
		cout << a[i] << " ";
	return 0;
}

尺取法

尺取法(双指针法、two pointers)

  • 一种常用的优化技巧
  • 特别适用于解决序列的区间问题
  • 操作简单,易于编程,
    是一种线性高效的算法
    尺取法的核心思想是维护一个区间(L,R),其中 L 为起点,R 为终点,该区间是序列内以 L 为起点的最短合法区间。关键在于 R 随着 L 的增大而增大。通过不断枚举L,同时求解相应的 R,可以高效地解决问题。
    具体的实现步骤是,不断移动 L 指针,同时更新 R 指针,直到 R 随着 L 的增大而增大。因为 R 随着 L 的增大而增大,所以总的时间复杂度为 O(n)。
    通过维护两个指针,即左指针 l 和右指针 r。通过不断确定区间的左端点,让右指针 r 不断向右移动,直到满足条件停下,然后维护答案。这个过程重复进行,直到左指针 l 超过右指针 r 或满足其他特定情况(根据题目而定)。
    尺取法的应用范围广泛,特别适用于需要寻找满足某种条件的连续子序列的问题。通过灵活运用尺取法,可以在保持算法简洁的同时,提高解题效率。
    为什么尺取法能用来优化
for (int i = 0; i < n; i++)  //i从头扫到尾
	for (int j = n - 1; i > 0; j--)  //j从尾扫到头
		...
//双循环O(n^2)

改为

i = 0; j = n - 1;
while (i < j)
{
	...
	i += 1; //i从头扫到尾
	j -= 1; //j从尾扫到头
}
//单循环O(n)

//第二种写法
for (int i = 0, j = n - 1; i < j; i++, j--)
{
	...
}

不是每个双循环都能改为单循环
双指针
反向扫描:i、j方向相反,i从头到尾,j从尾到头,在中间相会
同向扫描:i、j方向相同,都从头到尾,速度不同,例如让j跑在i的前面,快慢指针

回文判定

【题目描述】给定一个长度为n的字符串 S。请你判断字符串 S是否回文。
【输入描述】输入仅1行包含一个字符串S。 1 ≤ ∣ s ∣ ≤ 1 0 6 1\le |s| \le 10^6 1s106,保证S只包含大小写、字母。
【输出描述】若字符串S为回文串,则输出Y,否则输出N。

题目解析

反向扫描的两个指针i、j,指针i从左向右扫描,指针j从右向左扫描,在中间i<j处相遇并停止

输入s
i = 0;
j = len(s) - 1;
if i == j:  print ('Y')
else:
	while s[i] == s[j]:
		i += 1;
		j -= 1;
		if j <= i
			print ('Y')
			break
	else:
		print ('N')
找指定和的整数对

【问题描述】输入n个整数,放在数组a[]中。找出其中的两个数,它们之和等于整数m。

尺取法:
(1)对数组从小到大排序
(2)i和j分别指向头和尾,i和j向中间移动:
a[i]+ a[j]>m,让j减1:大的变小
a[i]+ a[j]< m,让i加1:小的变大直至a[i]+ a[j]= m

美丽的区间

【题目描述】给定一个长度为n的序列 a 1 , a 2 … , a n a_{1},a_{2}\dots,a_{n} a1,a2,an和一个常数 S。对于一个连续区间如果它的区间和大于或等于 S,则称它为美丽的区间。对于一个美丽的区间,如果其区间长度越短,它就越美丽。请你从序列中找出最美丽的区间。
【输入描述】第一行包含两个整数 n,S,其含义如题所述。接下来一行包含 n 个整数,分别表示 a 1 , a 2 … , a n a_{1},a_{2}\dots,a_{n} a1,a2,an
10 ≤ N ≤ 1 0 5 , 1 ≤ a i ≤ 1 0 4 , 1 ≤ S ≤ 1 0 8 10\le N \le 10^5,1\le a_{i} \le 10^4,1\le S \le 10^8 10N105,1ai104,1S108
【输出描述】输出共一行,包含一个整数,表示最美丽的区间的长度。若不存在任何美丽的区间,则输出0。

题目解析

很直接的滑动窗门
求窗口内的区间和,满足大于S的最小长度。
i指针在前,j指针在后,计算两个指针之间的区间和。当i指针到达末尾时,结束计算。
计算复杂度为0(n)。

#include <bits/stdc++.h>
using namespace std;
int a[100010];
int main()
{
	int n, S;
	cin >> n >> S;
	for (int i = 0; i < n; i++)
		cin >> a[i];
	int sum = 0, ans = 1e8;
	for (int i = 0; j = 0; j < n) //i和j从左端开始走
	{
		//j不动,i往右走,把区间的和累加到sum里,直到sum大于S,得到最美区间
		if (sum < S)
		{
			sum += a[i];
			i++;
		}
		else 
		{
			//得到最美区间之后,更新答案,j往右走,判断是否还为最美区间,是的话更新答案和sum,不是的话j不动,i继续往后走,直到i走到最后一个数字
			ans = min (i - j, ans);
			sum -= a[j];
			j++;
		}
	}
	if (ans == 1e8)
		cout << 0;
	else
		cout << ans;
	return 0;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值