递归实现指数型枚举
其他文章
备战蓝桥杯系列全部文章
从 1∼n 这 n 个整数中随机选取任意多个，输出所有可能的选择方案。
输入格式
输入一个整数 n。
输出格式
每行输出一种方案。
同一行内的数必须升序排列，相邻两个数用恰好 1 个空格隔开。
对于没有选任何数的方案，输出空行。
本题有自定义校验器（SPJ），各行（不同方案）之间的顺序任意。
数据范围
1≤n≤15
输入样例：
3
输出样例：
3
2
2 3
1
1 3
1 2
1 2 3
时/空限制：5s / 256MB
问题分析：输入N，填坑（坑的数目是从1-N的），并且要求是升序进行的，因此我们可以枚举坑位的数量，并且标记一下当前的坑位最小的数是多少，从而实现升序的填坑
确定dfs的参数：1.因为是有不同的坑位数目，因此要记录本次要填多少个坑 2.当前填到第几个坑位了 3.升序填数，必须记录开始的最小值
坑位用数组a表示、并用vis数组标记是否填过
#include<iostream>
using namespace std;
const int N = 16;
bool vis[N];
int n;
int a[N];
//当前是第几位 最小值 一共几个坑位
void dfs(int cur, int start, int target) {
if(cur > target) { //坑位填满了就输出
for(int i = 1; i <= target; i++) {
printf("%d ", a[i]); }
cout << endl ;
return ;
}
//开始向当前坑位（cur）进行填数了
for(int i = start; i <= n; i++) {
if(!vis[i]) {
vis[i] = true;
a[cur] = i; //填数
dfs(cur + 1, i + 1, target); //填下一个坑位的数
vis[i] = false; //回溯
}
}
}
int main()
{
cout << endl;
cin >>n;
for (int i = 1; i <= n; i++) {
//填i个坑
dfs(1, 1, i);
}
return 0;
}
递归实现组合型枚举
从 1∼n 这 n 个整数中随机选出 m 个，输出所有可能的选择方案。
输入格式
两个整数 n,m ,在同一行用空格隔开。
输出格式
按照从小到大的顺序输出所有方案，每行 1 个。
首先，同一行内的数升序排列，相邻两个数用一个空格隔开。
其次，对于两个不同的行，对应下标的数一一比较，字典序较小的排在前面（例如 1 3 5 7 排在 1 3 6 8 前面）。
数据范围
n>0 ,
0≤m≤n ,
n+(n−m)≤25
输入样例：
5 3
输出样例：
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
时/空限制：5s / 256MB
问题分析：N个数中选M个数的组合（组合的话123 132 213 231 312 321代表的是同一种组合）因此我们全部都按照升序的方式进行输出就行，正好题目也是要求如此。同上题，填的坑位数是M，选择的数是从1-N进行选择，因为是全部严格升序，没必要再用vis标记是否选过了。
dfs参数：N、M为全局变量不用加，1.当前填的坑位 2.最小从那个数开始填（start）
#include<iostream>
#include<cstring>
using namespace std;
const int N = 30;
int n, m;
int a[N];
void dfs(int cur, int start) {
if(cur == m + 1) {
for(int i = 1; i <= m; i++) {
printf("%d ", a[i]);
}
cout << endl;
return ;
}
for (int i = start; i <= n; i++) {
a[cur] = i;
dfs(cur + 1, i + 1);
}
}
int main()
{
cin >> n >> m;
//全部都是按照字典序升序进行排列
dfs(1, 1);
return 0;
}
递归实现排列型枚举
把 1∼n 这 n 个整数排成一行后随机打乱顺序，输出所有可能的次序。
输入格式
一个整数 n。
输出格式
按照从小到大的顺序输出所有方案，每行 1 个。
首先，同一行相邻两个数用一个空格隔开。
其次，对于两个不同的行，对应下标的数一一比较，字典序较小的排在前面。
数据范围
1≤n≤9
输入样例：
3
输出样例：
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
时/空限制：5s / 256MB
题目分析：输入N,输出全排列，整体做法还是进行填坑
是否需要加vis标记（个人想法）：如果在一行中不是严格升序打印的就代表着我们在填数的时候选项是1-N随便选的，那么你就必须记录一下你是否选过了。每一行的第一个数是递增，行内也是严格递增的，我们在填数的时候不用看是否遍历过了，因为是严格递增的，后面的一定没选过，前面的数我们也不选。
样例1（排列型枚举）：
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
这样行内不是严格递增的我们就有必要加vis数组进行判断是否填充过
样例2(组合型枚举)：
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
这组样例包括行内都是严格递增的，我们不用加vis数组判断了，因为选择数的时候，比这个数大的都没选过，小的我们不选
言归正传了，相信通过上面的分析，应该很容易写出来本题目的代码了
#include<iostream>
#include<stdio.h>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 10;
int n;
int a[N];
bool vis[N];
void dfs(int cur) {
if(cur == n + 1) {
for (int i = 1; i <= n; i++) {
printf("%d ", a[i]);
}
cout << endl ;
return ;
}
for (int i = 1; i <= n; i++) {
if(!vis[i]) {
vis[i] = true;
a[cur] = i;
dfs(cur + 1);
vis[i] = false;
}
}
}
int main()
{
cin >> n;
dfs(1);
return 0;
}
蓝桥杯原题：带分数
100 可以表示为带分数的形式：100=3+69258714
还可以表示为：100=82+3546197
注意特征：带分数中，数字 1∼9 分别出现且只出现一次（不包含 0）。
类似这样的带分数，100 有 11 种表示法。
输入格式
一个正整数。
输出格式
输出输入数字用数码 1∼9 不重复不遗漏地组成带分数表示的全部种数。
数据范围
1≤N<106
输入样例1：
100
输出样例1：
11
输入样例2：
105
输出样例2：
6
时/空限制：1s / 64MB
题目分析：输入一个数N，让你表示成为整数+ 分数（没约分的整数）的形式
并且数由1-9组成（每个数都出现一次）。比较直接的想法就是我们枚举一下9的全排列，对于每一种全排列我们都判断是否满足题目要求，如果满足就输出。
判断一个排列是否满足：将这个排列分成三段，得到数a 、 b 、c 三个数，
target = a + (b / c ) => target * c = a * c + b
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 12;
int target, cnt = 0;
int a[N];
bool vis[N];
int calculate(int l, int r) { //给边界值获得数
int sum = 0;
for (int i = l; i <= r; i++) {
sum = sum * 10 + a[i];
}
return sum;
}
void dfs(int cur) {
if(cur == 10) { //枚举1-9完成了
for (int i = 1; i <= 7; i++) { //第一段的末尾位置
for (int j = i + 1; j <= 8; j++) { //第二段的末尾位置
int a = calculate(1, i);
int b = calculate(i + 1, j);
int c = calculate(j + 1, 9);
if(a * c + b == target * c) { //target == a + (b / c)
cnt ++;
}
}
}
return ;
}
for (int i = 1; i <= 9; i++) {
if(!vis[i]) {
vis[i] = true;
a[cur] = i;
dfs(cur + 1);
vis[i] = false;
}
}
}
int main()
{
cin >> target;
dfs(1); //枚举全排列
cout << cnt ;
}
翻硬币
小明正在玩一个“翻硬币”的游戏。
桌上放着排成一排的若干硬币。我们用 * 表示正面，用 o 表示反面（是小写字母，不是零）。
比如，可能情形是：**oo***oooo
如果同时翻转左边的两个硬币，则变为：oooo***oooo
现在小明的问题是：如果已知了初始状态和要达到的目标状态，每次只能同时翻转相邻的两个硬币,那么对特定的局面，最少要翻动多少次呢？
我们约定：把翻动相邻的两个硬币叫做一步操作。
输入格式
两行等长的字符串，分别表示初始状态和要达到的目标状态。
输出格式
一个整数，表示最小操作步数
数据范围
输入字符串的长度均不超过100。
数据保证答案一定有解。
输入样例1：
**********
o****o****
输出样例1：
5
输入样例2：
*o**o***o***
*o***o**o***
输出样例2：
1
时/空限制：1s / 64MB
题目分析：每次都翻转两个硬币，我们可以在两个硬币中间假设有一个开关，启动开关就将开关两侧的硬币进行翻转。从头进行start与target的对比，可以发现，每一个开关仅能改变一次（如果改变两次跟没改变没有区别）。所以我们遍历一遍，如果不同就改变开关，直到末尾位置。记录改变开关的次数
start :
o x x x x o x x x
- - - - - - - - //两个硬币之间的开关
target :
x x x x o o x x x
step1：
发现s[0] != t[0] ,改变开关1的状态
start-> x o x x x o x x x
step2:
发现s[1] != t[1] ,改变开关2状态
start-> x x o x x o x x x
step3:
发现s[2] != t[2] ,改变开关3的状态
start-> x x x o x o x x x
step4:
发现s[3] != t[3] ,改变开关4的状态
start-> x x x x o o x x x
(现在发现已经变成了target的状态了，以后再判断也不会更改开关状态，总共改变了4次)
上代码：
#include<cstring>
#include<iostream>
using namespace std;
string start, target;
int fins;
void turn(int i) {
start[i] = (start[i] == '*') ? 'o' : '*';
}
int main()
{
cin >> start >> target;
int len = start.size();
for (int i = 0; i <= len - 1; i++) {
if(start[i] != target[i]) {
turn(i);
turn(i + 1);
fins ++;
}
}
cout << fins;
}
费解的开关
你玩过“拉灯”游戏吗？
25 盏灯排成一个 5×5 的方形。
每一个灯都有一个开关，游戏者可以改变它的状态。
每一步，游戏者可以改变某一个灯的状态。
游戏者改变一个灯的状态会产生连锁反应：和这个灯上下左右相邻的灯也要相应地改变其状态。
我们用数字 1 表示一盏开着的灯，用数字 0 表示关着的灯。
下面这种状态
10111
01101
10111
10000
11011
在改变了最左上角的灯的状态后将变成：
01111
11101
10111
10000
11011
再改变它正中间的灯后状态将变成：
01111
11001
11001
10100
11011
给定一些游戏的初始状态，编写程序判断游戏者是否可能在 6 步以内使所有的灯都变亮。
输入格式
第一行输入正整数 n，代表数据中共有 n 个待解决的游戏初始状态。
以下若干行数据分为 n 组，每组数据有 5 行，每行 5 个字符。
每组数据描述了一个游戏的初始状态。
各组数据间用一个空行分隔。
输出格式
一共输出 n 行数据，每行有一个小于等于 6 的整数，它表示对于输入数据中对应的游戏状态最少需要几步才能使所有灯变亮。
对于某一个游戏初始状态，若 6 步以内无法使所有灯变亮，则输出 −1。
数据范围
0<n≤500
输入样例：
3
00111
01011
10001
11010
11100
11101
11101
11110
11111
11111
01111
11111
11111
11111
11111
输出样例：
3
2
-1
题目分析：本题目与翻硬币相似，同时具有一些特性。题目要求将所有的灯都打开，如果开一盏灯则周围四盏灯的状态会更改。我们令上面一层的灯都由（并且只能由）正下方一层的灯进行改变，从第一层开始进行更改。因此如果你第一层状态确定了，整个布局的改变状态也就确定了。因此我们可以枚举所有的第一层的状态，求得所有状态对应的最小的步数。
枚举第一层（5个）状态可以用二进制方式进行判断0-32代表5盏灯的状态
具体实现看代码就明白了
#include<iostream>
#include<cstring>
#include<stdio.h>
#include<algorithm>
using namespace std;
const int N = 6;
char a[N][N], source[N][N];
int fins;
int dir[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};
void turn(int x, int y) {
//改变此点和四个方向的位置的状态
a[x][y] = (a[x][y] == '1') ? '0' : '1';
for (int i = 0; i < 4; i++) {
int nextx = x + dir[i][0];
int nexty = y + dir[i][1];
if (nextx < 0 || nextx >= 5 || nexty < 0 || nexty >= 5) continue;
a[nextx][nexty] = (a[nextx][nexty] == '1') ? '0' : '1';
}
}
int main()
{
int T;
cin >> T;
while (T -- )
{
for (int i = 0; i < 5; i++ ) cin >> a[i];
fins = 5000;
for (int st = 0; st < 32; st ++ ) { //2 ^ 5 ->32 用32代表第一行的状态
memcpy(source, a, sizeof a); //保存一下原本的值
int step = 0;
for (int i = 0; i < 5; i++) { //枚举第一行的改变状态
if(st >> i & 1) { //为真就代表第i位改变，否则不改变状态
step ++;
turn(0, i);
}
}
for (int i = 0; i < 4; i++) { //对前四行进行判断
for (int j = 0; j < 5; j++) {
if(a[i][j] == '0') {
step ++;
turn(i + 1, j); //这个灯的状态由下面的灯进行改变
}
}
}
bool isok = true;
for (int i = 0; i < 5; i++) { //查看最后一行是否有熄灭的灯
if(a[4][i] == '0') {
isok = false;
break;
}
}
if(isok) fins = min(fins, step);
memcpy(a, source, sizeof a);
}
if(fins > 6) fins = -1;
cout << fins << endl;
}
}
祝大家蓝桥杯都能取得好成绩！
270
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
