暴力法的最后一块拼图
枚举题
题目需要处理大量同类情况
暴力枚举所有情况
利用计算机强大的算力
注意：不要遗漏任何情况
注意：如果枚举量太大，需要剪枝
- 枚举法
- 简单型枚举
- 组合型枚举
- 排列型枚举
- 指数型枚举
- 尺取算法
枚举法
枚举算法的思想：
将问题的所有可能成为答案的解一一列举，然后根据问题给定的条件判断这些解是否合适。如果合适就保留；反之则舍弃。
枚举算法解题的基本思路：
- 确定枚举解的范围和判断条件
- 选择适当的枚举方式进行逐一枚举，确保覆盖所有可能的解。避免遗漏任何真正的解，注意防止重复。
- 在枚举过程中，应用事先确定的判断条件验证每个解的合法性，保留符合要求的解。
枚举算法的一般步骤： - 根据题目确定枚举的范围，并选择合适的枚举方式。确保不遗漏任何真正的解，同时避免重复。
- 优化解空间：查看是否存在优化的可能性，以缩小可能成为解的答案范围，提高解决问题的效率。
- 定义准确验证条件：根据问题找到准确、易编码的验证条件，用于检验每个可能的解。
- 枚举和判断：逐一枚举解并验证是否符合事先确定的条件，保留符合条件的解。
- 按照要求输出枚举过程中留下的符合条件的解。
第几个幸运数字
题目描述
一个整数如果只含有因子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
3i∗5j∗7k
从小到大开始枚举
当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}
a0…an−1}，它的子集有{
空集
空集
空集}，{
a
0
a_{0}
a0}，{
a
1
a_{1}
a1}，…，{
a
0
…
a
n
−
1
a_{0}\dots a_{n-1}
a0…an−1}。共
2
n
2^n
2n个
用二进制的概念进行对照，子集正好对应了二进制，例如n=3的集合{{
a
0
,
a
1
,
a
2
a_{0}, a_{1}, a_{2}
a0,a1,a2}，它的子集和二进制数的对应关系是
| 子集 | 二进制数 | 十进制数 |
|---|---|---|
| 空集 | 000 | 0 |
| a 0 a_{0} a0 | 001 | 1 |
| a 1 a_{1} a1 | 010 | 2 |
| a 0 , a 1 a_{0}, a_{1} a0,a1 | 011 | 3 |
| a 2 a_{2} a2 | 100 | 4 |
| a 0 , a 2 a_{0},a_{2} a0,a2 | 101 | 5 |
| a 1 , a 2 a_{1}, a_{2} a1,a2 | 110 | 6 |
| a 0 , a 1 , a 2 a_{0}, a_{1}, a_{2} a0,a1,a2 | 111 | 7 |
| 怎么去枚举二进制 | ||
| 因为二进制数所对应的十进制数为0~7，所以只需要从0开始枚举到 2 n − 1 2^{n-1} 2n−1 | ||
| 在转化为二进制，在把二进制的每个数位拆分出来，这个题就做出来了 | ||
| 每个子集对应了一个二进制数，二进制数中的每个一，对应了子集中的某个元素 | ||
| 子集中的元素，是不分先后的，这正符合组合的要求 | ||
| 输出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
1≤∣s∣≤106，保证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
10≤N≤105,1≤ai≤104,1≤S≤108
【输出描述】输出共一行，包含一个整数，表示最美丽的区间的长度。若不存在任何美丽的区间，则输出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;
}
扫一扫
432
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
