递归和回溯（续）
目录
接上一篇递归和回溯，本篇介绍一些基本的例题。
1、求最小整数
分析
这个题可能不太知道怎么下手，但是我们仔细看这个题，就可以用我们之前讲到的全排列，然后把结果用动态规划里面的数字金字塔来进行做。
直接用库
python：
import itertools # 引入库
s = [i for i in range(1, 11)]
res = []
for k in itertools.permutations(s, 10): # 生成全排列
dp = [[0] * 10 for i in range(10)]
x = list(k)
for j in range(10):
dp[-1][j] = x[j]
for i in range(8,-1,-1): # 倒推金字塔的做法，也可以用顺推
for j in range(i+1):
if i==8 and j==4:
dp[i][j]=0
else:
dp[i][j]=dp[i+1][j+1]+dp[i+1][j]
res.append(dp[0][0])
print(f'最小的数字:{min(res)}')
# 结果1194
回溯写法：
python：
vis = [False] * 11
min_nu = float('inf')
res = []
def check(res: list):
dp = [[0] * 10 for i in range(10)]
for j in range(10):
dp[-1][j] = res[j]
for i in range(8, -1, -1):
for j in range(i + 1):
if i == 8 and j == 4:
dp[i][j] = 0
else:
dp[i][j] = dp[i + 1][j + 1] + dp[i + 1][j]
return dp[0][0]
def back(t):
global min_nu
if t > 10:
min_nu = min(check(res[:]), min_nu)
return
for i in range(1, 11):
if not vis[i]:
vis[i] = True
res.append(i)
back(t + 1)
vis[i] = False
res.pop()
back(1)
print(min_nu)
# 结果1194
c++回溯：
#include "iostream"
#include "algorithm"
#include "vector"
using namespace std;
vector<int>res;
int min_num=100000,vis[11];
int check(vector<int>& res){
int dp[10][10],i,j;
for(i=0;i<10;i++)
dp[9][i]=res[i];
for(i=8;i>=0;i--)
for(j=0;j<=i;j++){
if(i==8&&j==4) dp[i][j]=0;
else dp[i][j]=dp[i+1][j+1]+dp[i+1][j];
}
return dp[0][0];
}
void back(int k){
if(k>10){
min_num=min(check(res),min_num);
return;
}
for(int i=1;i<=10;i++){
if(vis[i]) continue;
vis[i]++;
res.emplace_back(i);
back(k+1);
res.pop_back();
vis[i]--;
}
}
int main(){
back(1);
cout<<min_num; //结果1194
return 0;
}
2、排列数
分析
这个题就是讲前面讲的的全排列问题，直接模板套用，这里给出两种方法
python：
# 方法一
import itertools
n=int(input())
s=[i for i in range(10)]
cnt=0
for i in itertools.permutations(s,10):
cnt+=1
if cnt==n:
for j in i:
print(j,end='')
break
# 方法二，回溯
n = int(input())
vis = [False] * 10 # 标记数组
res = []
ans = 0
f = False
def back(t):
global ans # 全局变量
global f
if t > 10:
ans += 1
if ans == n: # 满足条件输出
for i in range(10):
print(res[i], end='')
f = True
return
if f: return
for i in range(10): # 0-9的全排列
if not vis[i]:
vis[i] = True
res.append(i)
back(t + 1)
vis[i] = False # 回溯
res.pop()
back(1)
c++
//方法一
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
string s = "0123456789";
int n;
cin >> n;
int cnt = 1;
do {
if(cnt == n) {
cout << s;
break;
}
cnt++;
} while(next_permutation(s.begin(), s.end()));
return 0;
}
//方法二 回溯
include "iostream"
using namespace std;
int vis[10],res[10];
int n,ans,f= false;
void dfs(int temp){
if(temp>=10){
ans++;
if(ans==n){
for(int i=0;i<10;i++)
cout<<res[i]<<"";
cout<<endl;
f= true;
}
return;
}
if(f) return;
for(int i=0;i<10;i++){
if(not vis[i]){
vis[i]++;
res[temp]=i;
dfs(temp+1);
vis[i]--;
}
}
}
int main(){
cin>>n;
dfs(0);
return 0;
}
3、数的计数
分析
这个可以直接搜索，也可以动态规划
python：
n = int(input())
h = [0]*1001
h[1] = 1
for i in range(2, n + 1):
h[i] = h[i - 1]
if i % 2 == 0:
h[i] = h[i - 1] + h[i // 2]
print(h[n])
c++:
#include<iostream>
using namespace std;
int ans;
void dfs(int m) //统计m所扩展出的数据个数
{
int i;
ans++; //每出现一个原数，累加器加1；
for (i = 1; i <= m/2; i++) //左边添加不超过原数一半的自然数，作为新原数
dfs(i);
}
int main()
{
int n;
cin >> n;
dfs(n);
cout << ans;
return 0;
}
4、组合数的个数
分析
这个题也是直接套用模板
python：
n, r = map(int, input().split())
vis = [False] * (n + 1) # 标记数组
res = []
ans = 0
def back(t, r):
global ans # 全局变量
if len(res) == r:
ans += 1
return
if t > n:
return
for i in range(t, n + 1): # 0-9的全排列
if not vis[i]:
vis[i] = True
res.append(i)
back(i + 1, r)
vis[i] = False # 回溯
res.pop()
back(1, r)
print(ans)
但其实还有一中方法那就是中学的排列组合公式直接进行运算
python：
import math # 引入库
n,r=map(int,input().split())
s=math.factorial(n)//(math.factorial(n-r)*math.factorial(r)) # 公式
print(s)
给出c++的回溯形式:
#include "iostream"
#include "vector"
using namespace std;
int vis[30],ans=0,n,m;
vector<int>res;
void backtrack(int k,int r){
if(res.size()==r){
ans++;
return;
}
if(k>n) return;
for(int i=k;i<=n;i++){//1到4的全排列
if(vis[i]) continue;
vis[i]++;
res.emplace_back(i);
backtrack(i+1,r); //保证前面的数小于后面的数
vis[i]--;
res.pop_back();
}
}
int main(){
cin>>n>>m;
backtrack(1,m);
cout<<ans;
return 0;
}
5、背包问题
分析
这个题我们直接搜索所有的解
python：
n, t = map(int,input().split())
bag = list(map(int, input().split()))
def dfs(k, t):
if t == 0: # 满足解直接返回
return True
if k == n: # 搜索完了都没有结果，直接返回
return False
if t < 0: # 小于0也结束
return False
if dfs(k + 1, t - bag[k]): # 继续下一个
return True
return dfs(k + 1, t)
if dfs(0, t):
print(1)
else:
print(0)
其实这个题还可以用动态规划来做
python：
n,t=map(int,input().split())
a=list(map(int,input().split()))
a.insert(0,0)
dp=[0]*10000
dp[0]=1
for i in range(1,n+1):
for j in range(t,a[i]-1,-1): # 类似01背包，dp表示当前容量下的最大值
dp[j]+=dp[j-a[i]]
if dp[t]>0:
print(1)
else:print(0)
这里不理解的话后面还会讲动态规划的题
c++实现
#include<iostream>
using namespace std;
int n,T,ans=0;
int w[100];
bool dfs(int k, int t){
if(t==0 ) return true;
if(k>n ){
return false;
}
if(t<0) return false;
if(dfs(k+1,t-w[k]))
return true;
else
return dfs(k+1,t);
}
int main()
{
cin>>n>>T;
for(int i=1;i<=n;i++)
cin>>w[i];
if(dfs(1,T))cout <<1;
else cout<<0;
}
6、图的m着色问题
分析
python：
n, M, m = map(int, input().split()) # n表示顶点数，M表示边数，m表示颜色数
a = [[0] * 100 for _ in range(100)] # 邻接矩阵
x = [0] * 100 # 标记数组，表示当前顶点的颜色
ans = 0 # 记录结果总数
for i in range(M):
u, v = map(int, input().split()) # 输入邻接矩阵
a[u][v] = 1
a[v][u] = 1
def check(k, c): # 判断函数
for y in range(1, k):
if a[k][y] == 1 and c == x[y]: # 如果边相连且颜色相同不满足
return False
return True
def backtrack(t):
global ans
if t > n: # 搜索到叶子节点
ans += 1 # 结果+1
return
for j in range(1, m + 1): # 遍历这m种颜色
x[t] = j # 将当前的顶点t标记为j这个颜色
if check(t, j): # 满足条件继续搜索下一个顶点
backtrack(t + 1)
x[t] = 0 # 回溯
backtrack(1)
print(ans)
c++：
#include<iostream>
using namespace std;
#define N 100
int m,n,M,a[N][N],x[N],textNum;
int sum=0;
bool ok(int k)
{
for(int j=1;j<=n;j++)
if(a[k][j]&&(x[j]==x[k]))
return false;
return true;
}
void backtrack(int t) {
if(t>n) {
sum++;
}
else
for(int i=1;i<=m;i++)
{
x[t]=i;
if(ok(t))
backtrack(t+1);
x[t]=0;
}
}
int main() {
int i,j,z=1;
cin>>n>>M>>m;
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
a[i][j]=0;
for(int k=1;k<=M;k++)
{
cin>>i>>j;
a[i][j]=1;
a[j][i]=1;
}
for(i=0;i<=n;i++)
x[i]=0;
backtrack(1);
cout<<sum<<endl;
sum=0;
return 0;
}
7、子集求和
分析
这个题和背包问题差不多
python：
n, m = map(int,input().split())
a = list(map(int, input().split()))
a.sort() # 排序加快搜索速度
res = 0 # 记录结果
def dfs(k, su):
global res # 全局变量
if k >= n: # 搜索到叶子节点退出
return
x = su + a[k] # 选择当前数
if x == m: # 满足条件结果+1
res += 1
return
if x > m: # 大于m直接退出
return
dfs(k + 1, x) # 搜索下一个
dfs(k + 1, su) # 跳过当前，搜索下一个
dfs(0, 0)
print(res)
8、装载问题
分析
这个题和子集求和差不多的，不同的是求最大的重量
python：
n, c = map(int, input().split())
a = list(map(int, input().split()))
a.sort() # 排序加快搜索速度
Max = 0 # 记录最大重量
flage = False
def dfs(k, su):
global Max
global flage # 全局变量
if k >= n: # 搜索到叶子节点，更新最大重量
if su < c:
Max = max(su, Max)
return
if flage:
return
x = su + a[k] # 算则当前的重量
if x == c: # 如果刚好等于载重量，直接给最大值，并将flage置为True
Max = c
flage = True
return
if x > c: # 如果大于载重量，比较当前最大值和su的大小
Max = max(Max, su)
return
dfs(k + 1, x) # 继续向下搜索
dfs(k + 1, su) # 跳过当前，继续下一步
dfs(0, 0)
print(Max)
c++:
#include <iostream>
#include<algorithm>
using namespace std;
int n,c,a[100]={0},Max=0;
bool flag=0;
void dfs(int k,int sum){
if(k>=n){
if(sum<=c){
Max=max(Max,sum);
}
return;
}
if(flag) return;
int x=sum+a[k];
if(x==c){
Max=c;
flag=1;
return;
}
if(x>c){
Max=max(Max,sum);
return;
}
dfs(k+1,x);
dfs(k+1,sum);
}
int main(){
cin>>n>>c;
for(int i=0;i<n;i++)
cin>>a[i];
sort(a,a+n);
dfs(0,0);
cout<<Max<<endl;
9、括号生成
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
为了生成所有序列，我们可以使用递归。长度为 nnn 的序列就是在长度为 n−1n - 1n−1 的序列前加一个 ‘(’\text{('}‘(’ 或 ‘)’\text{)'}‘)’。
为了检查序列是否有效，我们遍历这个序列，并使用一个变量 balance\textit{balance}balance 表示左括号的数量减去右括号的数量。
如果在遍历过程中 balance\textit{balance}balance 的值小于零，或者结束时 balance\textit{balance}balance 的值不为零，
那么该序列就是无效的，否则它是有效的。
‘’’
分析
这里的话也是直接回溯，这里的话我们知道左括号如果小于n那我们可以放左括号，如果右括号小于左括号可以放个右括号
python：
n = int(input())
ans = [] # 结果
def backtrack(S: list, left, right):
if len(S) == 2 * n: # 总长度
ans.append("".join(S))
return
if left < n: # 左括号小于n加左括号
S.append('(')
backtrack(S, left + 1, right)
S.pop()
if right < left: # 右括号小于左括号添加右括号
S.append(')')
backtrack(S, left, right + 1)
S.pop()
backtrack([], 0, 0)
print(ans)
10、最佳调度问题
分析
这个题和图的m着色问题差不多
c++:
#include<bits/stdc++.h>
using namespace std;
int n,k;
int x[100]; //记录每个机器完成任务的时间
int x1[100]; //记录每个任务所需要的时间
int maxnum=1000000; //初始化设为很大
void task(int level){
if(level>n){
int temp=0;
for(int i=1;i<=k;i++){ //找到最小时间
if(x[i]>temp){
temp=x[i];
}
}
if(temp<maxnum){
maxnum=temp; //记录最小的时间
}
}
else{
for(int i=1;i<=k;i++){
x[i]+=x1[level]; //记录当前的任务之前的所用机器的所有时间
task(level+1);
x[i]-=x1[level]; // 回溯
}
}
}
int main(){
cin >> n;
cin >> k;
for(int i=1;i<=n;i++){
cin >>x1[i];
}
task(1);
cout << maxnum;
return 0;
}
11、数字卡片
分析
这个题也是直接使用模板，最后再判断质数就可以
python：
n, m = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
vis = [False] * 10
def pd(x): # 判断质数
if x < 2:
return False
for i in range(2, int(x ** 0.5) + 1):
if x % i == 0:
return False
return True
def dfs(k, s):
global ans
if k >= m:
if pd(s): ans += 1 # 搜索完全
return
if pd(s): ans += 1 # 满足条件
for i in range(n):
x = s * 10 + a[i] # 表示选出来的数能组合成的数字
if vis[i]: continue # 如果选择过了，跳过
vis[i] = True # 置为选择
dfs(k + 1, x) # 下一步搜索
vis[i] = False # 回溯
dfs(0, 0)
print(ans)
c++:
#include "iostream"
using namespace std;
int vis[10] = {0}, a[10], n, m, res = 0;
bool check(int x) {
if (x < 2) return false;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) return false;
}
return true;
}
void dfs(int k, int s) {
if (k >= m) {
if (check(s)) res++;
return;
}
if (check(s)) res++;
for (int i = 0; i < n; i++) {
int x = s * 10 + a[i];
if (not vis[i]) {
vis[i]++;
dfs(k + 1, x);
vis[i]--;
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> a[i];
dfs(0, 0);
cout << res << endl;
return 0;
}
蓝桥杯真题
1、凑算式（LQB2016）
分析
这个题也是一样的使用全排列的模板就可以了
python:
vis = [False] * 10 # 标记数组
res = []
ans = 0
def back(t):
global ans # 全局变量
if t == 10:
if res[0] + res[1] / res[2] + (res[3] * 100 + res[4] * 10 + res[5]) / (
res[6] * 100 + res[7] * 10 + res[8]) == 10: # 看是否满足条件
ans += 1
return
for i in range(1, 10): # 0-9的全排列
if not vis[i]:
vis[i] = True
res.append(i)
back(t + 1)
vis[i] = False # 回溯
res.pop()
back(1)
print(ans)
# 29
c++:
#include "iostream"
using namespace std;
int vis[10]={0},ans=0;
double a[10]; //注意c里面要说明数据类型
void dfs(int k){
if(k>9){
if(a[1]+a[2]/a[3]+(a[4]*100+a[5]*10+a[6])/(a[7]*100+a[8]*10+a[9])==10) ans++;
return;
}
for(int i=1;i<=9;i++){
if(vis[i]) continue;
vis[i]++;
a[k]=i;
dfs(k+1);
vis[i]--;
}
}
int main(){
dfs(1);
cout<<ans<<endl; //29
return 0;
}
2、寒假作业(LQB2016）
分析
这里也是直接全排列模板，然后根据题意进行剪枝
python：
ans = 0 # 记录结果种数
b = [0 for _ in range(15)] # 存放一种排列
vis = [0 for _ in range(15)] # 标记数组
def check3(): return b[1] + b[2] == b[3] # 剪枝策略，
def check6(): return b[4] - b[5] == b[6]
def check9(): return b[7] * b[8] == b[9]
def check12(): return b[10] == b[11] * b[12] # 注意除法我们把它写成乘法
def dfs(num):
global ans
if num == 13:
if check12(): ans += 1
return
if num == 4 and not check3(): return # 依次剪枝判断
if num == 7 and not check6(): return
if num == 10 and not check9(): return
for i in range(1, 14): # 1-13的排列
if not vis[i]:
b[num] = i # 搜索的当前位置置为i
vis[i] = 1 # 标记搜索过
dfs(num + 1) # 下一步
vis[i] = 0 # 回溯
return ans
print(dfs(0))
# 64
c++：
#include "iostream"
using namespace std;
int vis[14],res[14],ans=0;
int check3(){return res[1]+res[2]==res[3];}
int check6(){return res[4]-res[5]==res[6];}
int check9(){return res[7]*res[8]==res[9];}
int check12(){return res[10]==res[11]*res[12];}
void dfs(int index){
if(index>13){
if(check12()) ans++;
return;
}
if(index==4 && not check3()) return;
if(index==7 && not check6()) return;
if(index==10 && not check9()) return;
for(int i=1;i<=13;i++){
if(vis[i]) continue;
vis[i]++;
res[index]=i;
dfs(index+1);
vis[i]--;
}
}
int main(){
dfs(1);
cout<<ans;
return 0;
}
3、算式900(LQB2017)
分析
这里介绍回溯法，也可以直接顺推
python：
vis = [False] * 10
res = []
def dfs(k):
if k == 10:
if ((res[0] * 1000 + res[1] * 100 + res[2] * 10 + res[3]) - (
res[4] * 1000 + res[5] * 100 + res[6] * 10 + res[7])) * (res[8] * 10 + res[9]) == 900 and res[
0] != 0 and res[4] != 0 and res[8] != 0:
print(f'{res[0] * 1000 + res[1] * 100 + res[2] * 10 + res[3]} '
f'{res[4] * 1000 + res[5] * 100 + res[6] * 10 + res[7]} '
f'{res[8] * 10 + res[9]}')
return
for i in range(10):
if vis[i]: continue
vis[i] = True
res.append(i)
dfs(k + 1)
res.pop()
vis[i] = False
dfs(0)
# 结果
# 5012 4987 36
# 6048 5973 12
c++:
#include "iostream"
using namespace std;
int vis[10], res[10], ans = 0;
void dfs(int k) {
if (k == 10) {
if (((res[0] * 1000 + res[1] * 100 + res[2] * 10 + res[3]) - (
res[4] * 1000 + res[5] * 100 + res[6] * 10 + res[7])) * (res[8] * 10 + res[9]) == 900 && res[0] != 0
&& res[4] != 0 && res[8] != 0)
cout << res[0] * 1000 + res[1] * 100 + res[2] * 10 + res[3] << " "
<< res[4] * 1000 + res[5] * 100 + res[6] * 10 + res[7] << " " << res[8] * 10 + res[9] << endl;
return;
}
for (int i = 0; i < 10; i++) {
if (vis[i]) continue;
vis[i]++;
res[k] = i;
dfs(k + 1);
vis[i]--;
}
}
int main() {
dfs(0);
return 0;
}
// 结果
// 5012 4987 36
// 6048 5973 12
4、平方十位数 2017
分析
这里的话也是可以直接暴力的，那这里我还是介绍回溯法，注意的是从最大的10位数开始搜素，搜索到的第一个一定就是最大的平方十位数
python：
vis = [False] * 10
res = []
s = [str(i) for i in range(10)] # 字符串的形式存0-9
f = False
def dfs(k):
global f
if k == 10:
# print(res)
t = int(''.join(res))
if int(t ** 0.5) == t ** 0.5: # 判断完全平方数
print(t)
f = True
if f: return
for i in reversed(range(10)): # 从10开始搜索
if vis[i]: continue
vis[i] = True
res.append(s[i])
dfs(k + 1)
vis[i] = False
res.pop()
dfs(0)
# 9814072356
c++:
#include<iostream>
#include<cmath>
#include<set>
using namespace std;
typedef long long ll;
int check(ll x) //判断十位数是否不同
{
set<int> a;
while (x) {
a.insert(x % 10);
x /= 10;
}
if (a.size() == 10) return true; //十位数都不同
else return false;
}
int main() {
int ans;
for (ll i = 9876543210;; i--) {
ll x = sqrt(i);
if (x * x == i && check(i)) //是平方数 && 十位数不一样
{
cout << i; //第一个找到的就是最大的平方数
break;
}
}
return 0;
}
总结
递归和回溯到这里差不多就介绍完了，很多题都可以按照这个模板去套，欢迎大家留言学习交流。
3509
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
