算法导论 第十五章：动态规划之棒的切割（Rod Cutting）

    和分治法一样，动态规划（Dynamic programming）是通过组合子问题的解而解决整个问题的。

其不同点在于：

1）分治法是将问题划分成一些独立的子问题，递归求解各个子问题，然后合并子问题的解而得到原问题的解

2）动态规划使用于子问题不独立的情况，也就是各个子问题包含公共的部分。若采用分治法，会有重复的求解公共部分，而动态规划算法对每个子问题只求解一次，然后抢劫过保存在一张表中，从而避免重复的运算。

动态规划具有如下特征：

1）最优子结构

2）重叠子问题

动态规划算法设计可以分为如下步骤：

1）描述最优解的结构

2）递归定义最优解的值

3）按自底向上的方式计算最优解的值

3）由计算出的结果构造一个最优解

棒切割（Rod Cutting）问题：

    一段长为n的棒，若长为i，其价格为Price(i)  其中i=1,2,...,n （价格表如下）， 如何切割可以使得收益r(n)最大？

     若最优解将棒分成k段，1 ≤ k ≤ n,则可以分解为：

                

收益为表示为:

                   

更一般地，我们可以从更短切割的收益中重构最优收益：

                     

简化上式可得：

                                            

最优解决方法：

1）递归(Recursive)

伪代码如下：

运行时间为：T(n)=2^n

2)带备忘录的自顶向下方法（Top-down with memoization）

伪代码如下：

3）自底向上方法（Bottom-up method）

上面三种方法可以求得最大收益，但是不能给出具体切割方法，为此我们需要重构最优解，伪代码如下：

完整代码如下：

#include<iostream>
#include<cstdlib>
#include<climits>
using namespace std;
int Recursive_CutRod(int *p,int n)
{
	if(n==0)
		return 0;
	int r=INT_MIN;
	for(int i=1;i<=n;i++)
		r=max(r,p[i]+Recursive_CutRod(p,n-i));
	return r;
	}

int Memoized_CutRod_Aux(int *p,int n,int *r)
{
	int q;
	if(r[n]>=0)
		return r[n];
	if(n==0)
		q=0;
	else
	{
		q=INT_MIN;
		for(int i=1;i<=n;i++)
			q=max(q,p[i]+Memoized_CutRod_Aux(p,n-i,r));
		}
	
	r[n]=q;
	return q;
	}
int Memoized_CutRod(int *p,int n)
{
	int *r=new int[n+1];	
	for(int i=0;i<=n;i++)
		r[i]=INT_MIN;
	return Memoized_CutRod_Aux(p,n,r);
	}

int *BottomUp_CutRod(int *p,int n)
{
	int q;
	int *r=new int[n+1];
	r[0]=0;
	for(int j=1;j<=n;j++)
	{
		q=INT_MIN;
		for(int i=1;i<=j;i++)
			q=max(q,p[i]+r[j-i]);
		r[j]=q;
		}
	return r;
	}
void Ex_BottomUp_CutRod(int *p,int n,int *r,int *s)
{
	r[0]=0;
	for(int j=1;j<=n;j++)
	{
		int q=INT_MIN;
		for(int i=1;i<=j;i++)
			if(q<p[i]+r[j-i]){
				q=p[i]+r[j-i];
				s[j]=i;
			}
		r[j]=q;
		}
	}
void Print_OpValue(int *r,int n)
{
	for(int i=1;i<=n;i++)
		cout<<r[i]<<"   ";
	cout<<endl;
	}
void Print_Solution(int *s,int n)
{
	while(n>0)
	 {
		cout<<s[n]<<"   ";
		n=n-s[n];
		}
	cout<<endl;
	}

int main()
{
	int price[]={1,5,8,9,10,17,17,20,24,30};
	//int n=sizeof(price)/sizeof(int);
	int n;
	cout<<"Please input the length of Rod:";
	cin>>n;
	int *p=new int[n+1];
	p[0]=n;
	for(int i=0;i<n;i++)
		p[i+1]=price[i];
	
	cout<<"/*--------------Recursive top-down implemetnation--------------*/"<<endl;
	int res1=Recursive_CutRod(p,n);
	cout<<"The optimal revenue is:"<<res1<<endl;
	cout<<"/*--------------top-down with memoization---------------------*/"<<endl;
	int res2=Memoized_CutRod(p,n);
	cout<<"The optimal revenue is:"<<res2<<endl;
	cout<<"/*--------------------Bottom-up method------------------------*/"<<endl;
	int *res3=new int[n+1];
	res3=BottomUp_CutRod(p,n);
	cout<<"The optimal revenue is:"<<res3[n]<<endl;
	cout<<"/*-----------Bottom-up method with actual solution------------*/"<<endl;
	int *res4=new int[n+1];
	int *s=new int[n+1];
	Ex_BottomUp_CutRod(p,n,res4,s);
	cout<<"The optimal reveue is:"<<endl;
	Print_OpValue(res4,n);
	cout<<"The actual solution is:"<<endl;
	Print_Solution(s,n);

	delete []p;
	return 0;
	}

运行结果：

【注：若有错误，请指正~~~】