目录
深度优先搜索问题
递归实现指数型枚举（枚举）
思路解析：
典型的深度优先搜索问题：在脑海中想象一棵树，逐层递归
（1）可以从第一层开始或者从第0层开始，但要注意对应边界的节点
当选择以第一层为开始时：边界结束条件为：（递归的层次大于目标）
当选择以第0层为开始时：边界结束条件为：（递归的层次等于目标）
（2）对于一个数字有两种状态：选择和不选择
但其实还有隐藏的第三个状态：即还没有做出选择时的状态：此时为0
用st[u]=1表示这层选择数字 用st[u]=2表示这层不选择数字
选择该数字后，对该数字进行标记
（3）到达边界后要执行的操作：
如果说st[i]==1，表示在这层选择了数字，那么就需要将这层的数字进行打印
如果说st[i]==2，表示这层不选择了数字，所以直接跳过这层
#include<iostream>
using namespace std;
const int N=16;
int st[N];
int n;
void dfs(int u)
{
if(u>n)
{
for(int i=1;i<=n;i++)
{
if(st[i]==1)
{
printf("%d ",i);
}
}
printf("\n");
return;
}
//不选
st[u]=2;
dfs(u+1);
st[u]=0;
//选择
st[u]=1;
dfs(u+1);
st[u]=0;
}
int main()
{
cin>>n;
dfs(1);
return 0;
}递归实现排列型枚举（排列）
思路解析：
（1）确定开始位置和边界
（2）用st数组标记已经选过的数字，用path数组存储选的数字
#include<iostream>
using namespace std;
const int N=10;
bool st[N];
int path[N];
int n;
void dfs(int u)
{
if(u>n)
{
for(int i=1;i<=n;i++)
{
printf("%d ",path[i]);
}
printf("\n");
return;
}
for(int i=1;i<=n;i++)
{
if(!st[i])
{
path[u]=i;
st[i]=true;
dfs(u+1);
st[i]=false;
}
}
}
int main()
{
cin>>n;
dfs(1);
return 0;
}递归实现组合型枚举(组合)
思路解析：
与上面两个不同的是：多了一个参数start
因为这里是组合，所以说我们需要有序来维持秩序，且path数组中的数字一定不会重复
#include<iostream>
using namespace std;
const int N=25;
int path[N];
int n,m;
void dfs(int u,int start)
{
if(u>m)
{
for(int i=1;i<=m;i++)
{
printf("%d ",path[i]);
}
printf("\n");
return;
}
for(int i=start;i<=n;i++)
{
path[u]=i;
dfs(u+1,i+1);
path[u]=0;
}
}
int main()
{
cin>>n>>m;
dfs(1,1);
return 0;
}剪枝优化：
当遍历到以4为开头，或者为5开头的树枝时，由于最大值为5，无法凑出3个数字，所以可以将该树枝剪掉！
表示方法：(u-1)+(n-start+1)<m：该层+（最大数-最小数+1）：之间还有多少个数<m
#include<iostream>
using namespace std;
const int N=25;
int path[N];
int n,m;
void dfs(int u,int start)
{
if(u+n-start<m) return;
if(u>m)
{
for(int i=1;i<=m;i++)
{
printf("%d ",path[i]);
}
printf("\n");
return;
}
for(int i=start;i<=n;i++)
{
path[u]=i;
dfs(u+1,i+1);
path[u]=0;
}
}
int main()
{
cin>>n>>m;
dfs(1,1);
return 0;
}运行时间对比：
开关问题
翻硬币
思路解析：
核心：假设在两个硬币之间有一个开关，点击开关，开关两边的硬币将会翻转
目标：从初始状态到->目标状态
由于点击开关一次，开关两边的硬币就会翻转，点击开关两次，那么相当于没有变化，所以要求最小次数，就必然每个开关最多只会点击一次，且与顺序无关
遍历初始和目标两个数组，如果有不同，那么就摁下开关
由于题目保证了一定有解，我们只需一个res变量，来记录步数即可
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int N=100;
char start[N];
char aim[N];
void turn(int i)
{
if(start[i]=='o') start[i]='*';
else start[i]='o';
}
int main()
{
cin>>start>>aim;
int n=strlen(start);
int res=0;
for(int i=0;i<n;i++)
{
if(start[i]!=aim[i])
{
res++;
turn(i);//注意动一个开关，要翻转两个硬币
turn(i+1);
}
}
cout<<res<<endl;
return 0;
}费解的开关
思路解析：
第一行的所有方案，如果第一行的有暗的，那么就将其点亮，遍历第二，三，四行，如果这一行有暗的，那么就将其的下一行的对应列位置点亮，如果最后一行全都是亮的证明其成功点亮所有
疑惑点详解：
（1）为什么要让N=6,题目只要求的5*5的矩阵？
答：因为我们存的字符串，最后的一是留给字符串末尾的'\0'
(2)为什么要有这一步 for (int op = 0; op < 32; op ++ ) ？直接点亮第一行暗的地方不就好了吗？
答：因为点亮这个暗那个，所以我们无法简单地推出来正确的解法，所以只有暴力枚举第一行的所有点亮法，寻找最小的step
（3）为什么要进行备份memcpy?
答：注意观察memcpy的开始位置和还原位置，因为在枚举所有方案时，会对原矩阵进行破坏，所以，需要进行备份
代码如下：
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 6;
char g[N][N], backup[N][N];
int dx[5] = {-1, 0, 1, 0, 0}, dy[5] = {0, 1, 0, -1, 0};
void turn(int x, int y)
{
for (int i = 0; i < 5; i ++ )
{
int a = x + dx[i], b = y + dy[i];
if (a < 0 || a >= 5 || b < 0 || b >= 5) continue; // 在边界外，直接忽略即可
g[a][b] ^= 1;
}
}
int main()
{
int T;
cin >> T;
while (T -- )
{
for (int i = 0; i < 5; i ++ ) cin >> g[i];
int res = 10;
for (int op = 0; op < 32; op ++ )
{
memcpy(backup, g, sizeof g);
int step = 0;
for (int i = 0; i < 5; i ++ )
if (op >> i & 1)
{
step ++ ;
turn(0, i);
}
for (int i = 0; i < 4; i ++ )
for (int j = 0; j < 5; j ++ )
if (g[i][j] == '0')
{
step ++ ;
turn(i + 1, j);
}
bool dark = false;
for (int i = 0; i < 5; i ++ )
if (g[4][i] == '0')
{
dark = true;
break;
}
if (!dark) res = min(res, step);
memcpy(g, backup, sizeof g);
}
if (res > 6) res = -1;
cout << res << endl;
}
return 0;
}
飞行员兄弟
思路解析：
核心：与上题同理，但这里的turn(i,j)变成了，改变第i行和第j列的所有元素的状态
由于本题的数据较小，4*4的矩阵，所以可以遍历所有的位置，也就是16个位置，在每个位置上有两种状态：开或关，所以总共有：2^16，这个是主要的，剩下的是一些杂碎的遍历
同样是暴力枚举，2^16，并将每个位置进行编号，因为
注意：如果存在多种打开冰箱的方式，则按照优先级整体从上到下，同行从左到右打开。
关于op的解释：
op代表一个二进制数，给每个开关编号，为0~15，op >> get(i, j) & 1的意思就是op右移多少位再与上1，如果结果为1说明对(i, j)位置上的开关按一次，为0则是不按，这是来枚举所有开关的情况的
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
const int N = 5;
char g[N][N], backup[N][N];
int get(int x, int y)
{
return x * 4 + y;
}
void turn_one(int x, int y)
{
if (g[x][y] == '+') g[x][y] = '-';
else g[x][y] = '+';
}
void turn_all(int x, int y)
{
for (int i = 0; i < 4; i++)
{
turn_one(x, i);
turn_one(i, y);
}
turn_one(x, y);
}
int main()
{
for (int i = 0; i < 4; i++) cin >> g[i];
vector<PII> res;
for (int op = 0; op < 1 << 16; op++)
{
vector<PII> temp;
memcpy(backup, g, sizeof g); // 备份
// 进行操作
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
if (op >> get(i, j) & 1)
{
temp.push_back({ i, j });
turn_all(i, j);
}
// 判断所有灯泡是否全亮
bool has_closed = false;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
if (g[i][j] == '+')
has_closed = true;
if (has_closed == false)
{
if (res.empty() || res.size() > temp.size()) res = temp;
}
memcpy(g, backup, sizeof g); // 还原
}
cout << res.size() << endl;
for (auto op : res) cout << op.x + 1 << ' ' << op.y + 1 << endl;
return 0;
}带分数(深搜)
思路解析：
如果a不大于n且a非0，那么就节外生枝c
a，c的大小采用排列思想
如果a,c满足这个条件，即检查b是否满足条件
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=10;
bool st[N],backup[N];
int n;
int ans;
bool check(int a,int c)
{
long long b=n*(long long)c-a*c;//移项转换
if(!a||!b||!c) return false;
memcpy(backup,st,sizeof st);
while(b)
{
int x=b%10;
b/=10;
if(!x || backup[x]) return false;
backup[x]=true;
}
for(int i=1;i<=9;i++)
{
if(!backup[i]) return false;
}
return true;
}
void dfs_c(int u,int a,int c)
{
if(u>9) return;
if(check(a,c)) ans++;
for(int i=1;i<=9;i++)
{
if(!st[i])
{
st[i]=true;
dfs_c(u+1,a,c*10+i);
st[i]=false;
}
}
}
void dfs_a(int u,int a)
{
if(a>=n) return;
if(a) dfs_c(u,a,0);
for(int i=1;i<=9;i++)
{
if(!st[i])
{
st[i]=true;
dfs_a(u+1,a*10+i);
st[i]=false;
}
}
}
int main()
{
cin>>n;
dfs_a(0,0);
cout<<ans<<endl;
return 0;
}
2656
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
