C++ 使用递归、回溯、动态规划算法实现一题多解

１. 引言

为了让大家更好理解递归、回溯、动态规划三者算法之间有关系，本文罗列了几道题目，分别使用递归、回溯、动态规划解决。会发现三者之间同工异曲，都是一种搜索模式，递归是正向搜索且返回；回溯是搜索到尽头后你自己看着办、然后再继续；动态规划可以理解为反向搜索。

要有一定深度的理解，需要自己反复练习且揣摩其中的细节之分。

本文直接提出问题，直接给出答案。

2. 打家劫舍

2.1 问题描述

一个专业的盗贼，计划偷打劫街的房屋。每间房内都藏有一定的现金，你可以进入每一间房子，影响偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被盗贼闯入，系统会自动报警。

现给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

示例1：
输入：[1,2,3,1]

输出：4

解释：偷窃 1号房屋(金额=1)，然后偷窃3号房屋(金额=3)。偷窃到的最高金额=1+3=4。

示例2：

输入：[2,7,9,3,1]

输出：12

解释：偷窃 1 号房屋(金额 = 2)，偷 3 号房屋(金 = 9)，接着偷 5 号房屋(金额 =1)偷窃到的最高金额=2+9+1=12。

2.2 递归实现

#include 
using namespace std;
//房间数量
int n;
//房间的金额
int m[100]={0};
int djjsDg(int idx) {
	if(idx>n)return 0;
	//偷， 进入下下个房间
	int t= m[idx]+djjsDg(idx+2);
	//不偷，可以直接进行相邻房间
	int nt=djjsDg(idx+1);
	return max(t,nt);
}

2.2 回溯实现

#include 
using namespace std;
//房间数量
int n;
//房间的金额
int m[100]={0};
//结果
int maxVal=0;
/*
*  sum 每次偷的金额
*  idx 从第几间房间开始偷
*/
void djjsHs(int sum,int idx) {
	for( int i=0; i<=1; i++ ) {
		sum+= m[idx]*i;
		if(idx>=n) {
			//最后一家
			maxVal=max(maxVal,sum);
		} else {
			//下一家
			djjs(sum, i==0?idx+1:idx+2 );
		}
		sum-= m[idx]*i;
	}
}

2.3 动态规划

#include 
#include  
using namespace std;
//房间数量
int n;
//房间的金额
int m[100];
int dp[100]={0}; 
//结果
int res=0;
int main(int argc, char** argv) {
	ios::sync_with_stdio(false);
	cin>>n;
	for(int i=1; i<=n; i++) {
		cin>>m[i];
	}
	for(int i=1;i<=n;i++){
		dp[i]=max( dp[i-1],m[i]+dp[i-2] );
		res=max(res,dp[i]);
	}
    cout<

3. 找零钱

3.1 问题描述

给你k种面值的硬币，面值分别为c1, c2 ... ck，每种硬币的数量无限，再给一个总金额amount，问最少需要几枚硬币凑出这个金额，如果不可能凑出，算法返回 -1 。

比如说k = 3，面值分别为 1，2，5，总金额amount = 11。那么最少需要 3 枚硬币凑出，即 11 = 5 + 5 + 1。

3.2 递归实现

#include 
using namespace std;
int coins[5]= {1,5,10,21,25};
int money=10; //完全背包
// 记忆搜索
int cache[100]= {0}; //索引号：表示金额  值：结果，最少的硬币数
int zl(int m) {
	int res=m;
	//出口一的写法
    //if(m==0)return 0;
	//出口二的写法
	for(int i=0; i<5; i++) {
		if( m==coins[i] )return 1;
	}
	if(cache[m]!=0) {
		res =cache[m];
	} else {
		//子问题有哪些（子节点有多少个）
		for(int i=0; i<5; i++) {
			if(coins[i]<=m ) {
				res=min(res, 1+zl(m-coins[i]) ) ;
			}
		}
		cache[m]=res;
	}
	return res;
}

3.3 回溯实现

#include 
using namespace std;
//选择
int coins[5]= {1,5,10,21,25};
int money=10; 
//结果
int res[100]= {0};
int minLen=money;
int show() {
	int count=0;
	for(int i=1; i<=money; i++) {
		if(res[i]) {
			count++;
			cout<=coins[i] ) {
			//选择
			res[idx]= coins[i];
			if( m-coins[i]==0 ) {
				//显示结果
				int res= show();
				minLen=min(minLen,res);
			} else {
				//下一个流程
				zlhs(idx+1,m-coins[i]);
			}
			res[idx]=0;
		}
	}
}

3.4 动态规划实现

#include 
#include 
using namespace std;
int main(int argc, char** argv) {
	int money=0;
	cout<<"请输入零钱数:"<>money;
	//硬币类型
    int coins[5]= {1,5,10,21,25};
	//状态数组，零钱需要找回的硬币数
	vector dp(money+1, money+1);
	dp[0]=0;
	for(int i=1; i<=money; i++) {
		for(int j=0; i>=coins[j]; j++) {
             //求最小值            
			dp[i]=dp[i] < dp[ i-coins[j] ]+1 ? dp[i] : dp[ i-coins[j] ]+1;	    	
		}
	}
	cout<

4. 0-1背包

4.1 问题描述

有一个可装载重量为W的背包和N个物品，每个物品有重量和价值两个属性。其中第i个物品的重量为wt[i]，价值为val[i]，现在用这个背包装物品，最多能装的价值是多少？

题目中的物品不可以分割，要么装进包里，要么不装，不能切成两块装一半。

如输入如下数据：

N = 3, W = 6
wt = [ 1,2,7 ]
val = [4,3,2 ]

可以选择前两件物品装进背包，总重量 3 小于W，可以获得最大的价值是 7。

4.2 递归实现

#include 
#include 
using namespace std;
struct Goods {
	//重量
	int weight;
	//价值
	int price;
	//物品状态 1 已经使用，0 未使用
	int isUse;
};
//0  1 （不可分割，数量有限）
//所有物品              0        1      2        3       4
Goods allGoods[5]= { {20,60,false},{30,120,false},{10,50,false},{20,20,false},{40,100,false} };
//背包重量
int bagWeight = 100;
//物品总数量
int totalNumber = 5;
int bag(int i,int wei) {
	int totalPrice=0;
	if(i==totalNumber)return 0;
	if( allGoods[i].weight>wei  ) {
		//物理存储空间：就是不能放下
		totalPrice= bag(i+1,wei);
	} else {
		//能放下：出现选择 放还是不放，看收益多少
		totalPrice=max(bag(i+1,wei-allGoods[i].weight)+allGoods[i].price , bag(i+1,wei) );
	}
	return totalPrice;
}

4.3 回溯实现

#include 
#include 
using namespace std;
struct Goods {
	//重量
	int weight;
	//价值
	int price;
	//物品状态 1 已经使用，0 未使用
	int isUse;
};
//0  1 （不可分割，数量有限）
//所有物品              0        1      2        3       4
Goods allGoods[5]= { {20,60,false},{30,120,false},{10,50,false},{20,20,false},{40,100,false} };
//背包重量
int bagWeight = 100;
//物品总数量
int totalNumber = 5;
void showBag() {
	for(int i=0; i<5; i++) {
		if(allGoods[i].isUse)
			cout<=allGoods[idx].weight*i) {
			allGoods[idx].isUse=i;
			totalPrice+=allGoods[idx].price*i;
			if(idx==4) {
				if(totalPrice>maxPrice ) {
					maxPrice=totalPrice;
					showBag();
					cout<

4.4 动态规划实现

#include 
#include 
using namespace std;
int main(int argc, char** argv) {
	//物品信息
	int goods[3][3]= { {1,4},{2,3} };
	//背包容量
	int bagWeight=0;
	cout<<"请输入背包容量："<>bagWeight;
	//状态表
	int db[4][bagWeight+1]= {0};
	for(int i=0; i<4; i++) {
		for(int j=0; jwt ) {
				//如果背包不能装下物品，保留背包上一次的结果
				db[w][wt]=db[w-1][wt];
			} else {
				//能装下,计算本物品价值和剩余容量的最大价值
				int val=goods[w-1][1] + db[w-1][ wt- goods[w-1][0] ];
				//背包原来的价值
				int val_= db[w-1][wt];
				//计算最大值
				db[w][wt]=val>val_?val:val_;
			}
		}
	}
	for(int i=1; i<3; i++) {
		for(int j=1; j<=bagWeight; j++) {
			cout<

5. 小结

只看不练假把式，只练不思假学问。