题目一：递归实现排列型枚举
把 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解题思路：
n范围小可以采取暴搜
考虑递归顺序:采用考虑每一位填哪一个数字,从小到大枚举可以保证字典序
边界条件:当枚举完n位即填充完所有数字
重复处理:用bool数组记录数字是否使用过,每次枚举未使用过的数字
建立一个递归搜索树
完整代码：
c++
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
const int N = 10;
int st[N];//存储方案
bool used[N];//标记数字是否被用过，true表示被用过，false表示没被用过
int n;
void dfs(int u){//当前枚举第u位
if(u > n){
for(int i = 1; i <= n; i ++) printf("%d ", st[i]);//打印方案
puts("");
return ;
}
for(int i = 1; i <= n; i ++){//依次枚举每个数
if(!used[i]){//当前数可用
st[u] = i;
used[i] = true;
dfs(u + 1);
//恢复现场
st[u] = 0;//可省略
used[i] = false;//不可省
}
}
}
int main(){
scanf("%d", &n);
dfs(1);
return 0;
}
python
n = int(input())
res = [0]*n
st = [0]*n
def dfs(x):
if x == n:
print(" ".join(list(map(lambda x:str(x + 1),res))))
return
for item in range(0, n):
if st[item] == 1:
continue
res[x] = item
st[item] = 1
dfs(x + 1)
st[item] = 0
dfs(0)
题目二：带分数
100 可以表示为带分数的形式：100=3+69258/714
还可以表示为：100=82+3546/197
注意特征：带分数中，数字 1∼9 分别出现且只出现一次（不包含 0）。
类似这样的带分数，100 有 11 种表示法。
输入格式
一个正整数。
输出格式
输出输入数字用数码 1∼9 不重复不遗漏地组成带分数表示的全部种数。
数据范围
1≤N<1e6
输入样例1：
100
输出样例1：
11
输入样例2：
105
输出样例2：
6解题思路 ：
给定一个数N，问有多少组a,b,c满足a+b/c=N，且a,b,c三个数不重不漏地涵盖1−9这9个数字，输出总组数
核心思想是：我们如果用暴力解法的话，n 是用不到的，只能用于最后的判断，所以这个时候我们考虑把两边同时乘上 c，把乘法转换为除法， 然后等式就成了 n×c=c×a+b，那么我们就可以用上 n 了,而且我们通过观察这个式子，我们本来需要枚举 a 和 b 和 c ， 但是我们现在只需要枚举一下 a 和 c 就可以了，因为这样子的话 b 可以通过 b=c×n-c×a 直接把 b 算出来，就不需要枚举 b 了
然后写一下dfsa ，首先判断一下，如果 a≥n 了，那么就不满足条件了对吧，那就直接 return 了。如果 a 是可行的，那么我们就dfs一下 c
对于dfsa，然后我们来枚举一下当前这个位置能用哪几个数字，从 1 到 9 进行循环，如果说当前这个位置上的数没有被用过的话，那么我们就用它，并做上标记，然后我们再dfs到下一层，同时更新一下 a ，传到下一层的参数应该是第一个参数+1，然后aa应该变成 a×10+i。然后最后要记得恢复现场，因为这里存在一个回溯。
void dfs_a(int u, int a)
{
if (a >= n) return;
if (a) dfs_c(u, a, 0);//如果说a是满足情况的，那么我们就枚举一下c,后面那个0表示c的大小
for (int i = 1; i <= 9; i++)//枚举一下当前这个位置可以用哪些数字
{
if (!st[i])
{
st[i] = true;
dfs_a(u + 1, a * 10 + i);//如果这个数没有被用过，那么我们就加上它，并且dfs下一层
st[i] = false;//恢复现场，回溯一下
}
}
}
那么我们现在实现一下 dfsc，dfsc的话有三个参数，dfsc的第一个参数和dfsa的参数一样，表示我们当前已经用了多少个数，第二参数的话是 a 的值，因为我们要利用 a 的值，第三个参数代表当前 c 的值。
如果说第一个参数已经等于 n 了，那就说明我们用完 n 个数字了对吧，那我们就可以直接 return 了。否则的话那我们就可以 check 一下，如果说 check 成功的话，那我们的答案就++。（check 函数的话就是用来判断一下 a 和 c 是否满足要求，传的第一个参数为 a，第二个参数为 b）
否则的话我们就从 1 到 9 枚举一下 c，如果这个数没被用过的话，那我们就把它标记一下，并把它放在 c 的后面，再dfs下一层，下一层的参数就是第一个参数+1，然后第二个参数不变，第三个参数就是 c×10+i ，然后我们还是要恢复现场。
void dfs_c(int u, int a, int c)//u表示我们已经用了多少个数字
{
if (u > 9)return;//如果我们把9个数字都用了的话，那就直接return了
if (check(a, c)) res++;//如果满足要求，那我们判断一下a,c是否符合题目要求，如果符合，那么答案++
for (int i = 1; i <= 9; i++)//否则的话我们把c从1到9全部枚举一遍
{
if (!st[i])
{
st[i] = true;
dfs_c(u + 1, a, c * 10 + i);//如果这个数没用过，那么我们就把它放在c的后面,继续dfs下一层
st[i] = false;
}
}
}
然后最后再实现一下这个 check 函数，函数的第一个参数就是 a ，第二个参数就是 c
我们来判断一下 a 和 c 是不是满足要求的。那判断a和c是否满足要求我们需要先利用 b=c×n-c×a 把计算出来对吧，然后我们再对b的每一位数字分析，第一点看一下它有没有和 a 和 c 有相同的数字冲突
第二点看一下 a，b，c 是否已经把 9 个数字全部用完了
那这里的话我们可以搞一个判重数组，我们先把原来的那个数组 copy 过来，因为我们要对这个判重数字进行修改，但是我们原来的判重数组是需要保证其是原样的，因为它需要恢复现场（回溯），所以这就是我们多开一个判重数组的原因。
bool check(int a, int c)
{
long long b = n * (long long)c - a * c;//把公式整理一下，然后先把b计算出来
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;
}
完整代码：
c++
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 20;
bool st[N], backup[N];
int n, res;
bool check(int a, int c)
{
//这一行中的c可能有8位数，那么和n乘起来以后就会溢出int，那么b就可能变成负数，从而它的个位数字的余数也可能是负数，那么backup[x]的下标就可能是负数，所以下标就越界了
//所以c和b转化成了long long类型，已经没有这个问题了
long long b = n * (long long)c - a * c;//把公式整理一下，然后先把b计算出来
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)//u表示我们已经用了多少个数字
{
if (u > 9)return;//如果我们把9个数字都用了的话，那就直接return了
if (check(a, c)) res++;//如果满足要求，那我们判断一下a,c是否符合题目要求，如果符合，那么答案++
for (int i = 1; i <= 9; i++)//否则的话我们把c从1到9全部枚举一遍
{
if (!st[i])
{
st[i] = true;
dfs_c(u + 1, a, c * 10 + i);//如果这个数没用过，那么我们就把它放在c的后面,继续dfs下一层
st[i] = false;
}
}
}
void dfs_a(int u, int a)
{
if (a >= n) return;
if (a) dfs_c(u, a, 0);//如果说a是满足情况的，那么我们就枚举一下c,后面那个0表示c的大小
for (int i = 1; i <= 9; i++)//枚举一下当前这个位置可以用哪些数字
{
if (!st[i])
{
st[i] = true;
dfs_a(u + 1, a * 10 + i);//如果这个数没有被用过，那么我们就加上它，并且dfs下一层
st[i] = false;//恢复现场，回溯一下
}
}
}
int main()
{
cin >> n;
dfs_a(0, 0);//第一个0表示我们已经用了多少个数字,后面那个0表示我们当前的a是多少
cout << res << endl;
return 0;
}
python
vis = [False for i in range(0, 10)]
ans = 0
n = 0
def judge(a, c):
b = n * c - a * c # 求出b
if b <= 0 or a <= 0 or c <= 0:
return False
backup = [data for data in vis]
while b > 0:
x = b % 10
b = b // 10
if x == 0 or backup[x]:
# 检查b每一位是否为0，并且是否已经在a、c中出现过
return False
backup[x] = True
for i in range(1, 10):
# 检查0-9是否都出现过一次
if not backup[i]:
return False
return True
def dfs_c(cnt, a, c):
global vis, ans
if cnt >= 10:
return
if judge(a, c):
ans = 1 + ans
for i in range(1, 10):
if not vis[i]:
vis[i] = True
dfs_c(cnt + 1, a, c * 10 + i)
vis[i] = False
def dfs_a(cnt, a): # cnt表示为当前总共用了多少位数字
global vis
if a >= n:
return
if a != 0:
dfs_c(cnt, a, 0)
for i in range(1, 10):
if not vis[i]:
vis[i] = True
dfs_a(cnt + 1, a * 10 + i)
vis[i] = False
if __name__ == '__main__':
n = int(input()) # 注意转换为int类型
dfs_a(0, 0)
print(ans)
191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
