动态规划（一）

最新推荐文章于 2024-10-01 00:56:19 发布

jkask

最新推荐文章于 2024-10-01 00:56:19 发布

阅读量304

点赞数

CC 4.0 BY-SA版权

分类专栏：动态规划算法导论文章标签：动态规划

本文链接：https://blog.youkuaiyun.com/jkask/article/details/82490731

动态规划同时被 2 个专栏收录

1 篇文章

订阅专栏

算法导论

1 篇文章

订阅专栏

#动态规划（一）
算法导论动态规划——钢条切割

**Serling公司购买长钢条，将其切割为短钢条出售。切割工序本身没有成本支出。公司管理层希望知道最佳的切割方案。假定我们知道Serling公司出售一段长为i英寸的钢条的价格为pi(i=1,2,…，单位为美元)。钢条的长度均为整英寸。图15-1给出了一个价格表的样例。

钢条切割问题是这样的：给定一段长度为n英寸的钢条和一个价格表 ${p_i}$ (i=1,2,…n)，求切割钢条方案，使得销售收益 ${r_n}$ 最大。注意，如果长度为n英寸的钢条的价格 ${p_n}$ 足够大，最优解可能就是完全不需要切割。

问题分析

分割钢条的所有方案共有 $2^{n-1}$ (长度为n的钢条，可切割点有n-1个，可以选择切或不切）

假设最佳方案为将钢条切割为k段，分别为 ${i_1}$ ， ${i_2}$ ，··· ${i_k}$ ；对于各段得到的最大收益分别为人 ${r_1}$ , ${r_2}$ ,··· ${r_k}$ ;
计算ri是小于规模n的新的子问题，且 ${r_1}$ , ${r_2}$ ,··· ${r_k}$ ，可能有相互重叠部分。
这个题可以用深搜做，遍历所有方案做比较，时间效率为指数级。
若用动态规划做：分析样例表：
n=1时， ${r_1}$ =1；
n=2时， ${r_2}$ =5；
n=3时， ${r_3}$ =8；
n=4时， ${r_4}$ = ${r_2}$ + ${r_2}$ =10；
n=5时， ${r_5}$ = ${r_2}$ + ${r_3}$ =13；
n=6时， ${r_6}$ =17；
n=7时， ${r_7}$ = ${r_2}$ + ${r_5}$ = ${r_2}$ + ${r_2}$ + ${r_3}$ =18
n=8时， ${r_8}$ = ${r_3}$ + ${r_5}$ =21
n=9时， ${r_9}$ = ${r_3}$ + ${r_6}$ = ${r_4}$ + ${r_5}$ =25
n=10时， ${r_{10}}$ =30；
方法一：选择第一个切割点:
${r_n}$ =max( ${p_n}$ , ${r_1}$ + ${r_{n-1}}$ ,··· ${r_i}$ + ${r_{n-i}}$ ）i>=1&&i<=n/2;
代码块（一）

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int p[1001];
int r[1001];
int N;
int main() {
	memset(r,-1,sizeof(r));
	cin>>N;
	for(int i =1; i<=N; i++) {
		cin>>p[i];
	}

	int CutRod(int n);
	int ans;
	ans=CutRod(N);
	cout<<ans<<endl;
}
int CutRod(int n) {
	if(n==1)return p[n];
	int m=p[n];
	for(int i =1; i<=n/2; i++) {
		m=max(m,CutRod(i)+CutRod(n-i));
	}
	return m;
}

方法二：将钢条从左边切割下长度为i的一段，只对右边剩下的长度为n-i的一段继续进行切割，对左边的一段则不再进行切割。这样得到的公式为：。这样原问题的最优解只包含一个相关子问题（右端剩余部分）的解，而不是两个。:
这里写图片描述
${r_n}$ =max( ${p_i}$ + ${r_{n-i}}$ ),其中i>=n/2&&i<=n;
当i=n时， ${r_n}$ =( ${p_n}$ + ${r_{0}}$ )= ${p_n}$ ,即对长度为n的钢条不切割的状态。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int p[1001];
int r[1001];
int N;
int main() {
	int CutRod2(int n);
	memset(r,-1,sizeof(r));
	cin>>N;
	for(int i =1; i<=N; i++) {
		cin>>p[i];
	}
	int ans;
	ans=CutRod2(N);
	cout<<ans<<endl;
}
int CutRod2(int n) {
	int m=p[n];
	if(n==0)return 0;
	else if(n==1)return p[n];
	else {
		for(int i =n/2; i<=n; i++) {//因为n=1时，n/2==0，p[0]越界，所以，n==1要单独拿出来。 
			int t=p[i]+CutRod2(n-i);
			if(t>m)
				m=t;
		}
		return m;
	}
}

方法三：在递归过程中涉及到很多次的重复递归计算，可以将曾经计算过的数据保存到数组，后续直接从数组中找，没有再计算。下面在方法二的基础上加入记忆数组。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int p[1001];
int r[1001];
int N;
int memory[1001];
int main() {
    int CutRod2(int n);
    memset(r,-1,sizeof(r));
    cin>>N;
    for(int i =1; i<=N; i++) {
        cin>>p[i];
    }
    int ans;
    memset(memory,-1,sizeof(memory));//对memory数组初始化;因为收益不为负数，所以初始化为-1 
    memory[0]=0 ;
    memory[1]=p[1];
    ans=CutRod2(N);
    cout<<ans<<endl;
}
int CutRod3(int n) {
     
    if(memory[n]>=0)return memory[n];
    else {
        for(int i =n/2; i<=n; i++) {
		//因为n=1时，n/2==0，p[0]中没有存有效数据，所以，n==1的情况要单独拿出来。 
            int t=p[i]+CutRod2(n-i);
            if(t>memory[n])
                memory[n]=t;
        }
        //memory数组保存中间计算结果。且结果一旦保存，不会再发生改变。 
        return memory[n];
    }
}

重构解（即保存切割策略）

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int p[1001];
int r[1001];
int N;
int memory[1001];
int main() {
	int CutRod3(int n);
	memset(r,-1,sizeof(r));
	cin>>N;

	for(int i =1; i<=N; i++) {
		cin>>p[i];
	}
	int ans;
	memset(memory,-1,sizeof(memory));//对memory数组初始化因为收益不为负数，所以初始化为-1
	memory[0]=0 ;
	memory[1]=p[1];
	r[1]=1;//对r[1]直接赋值 
	ans=CutRod3(N);
	cout<<"最大收益为："<<ans<<endl;
	cout<<"可最大收益的策略为：";
	while(N>0&&r[N]>0) {
		cout<<r[N]<<" ";
		N-=r[N];
	}

}

int CutRod3(int n) {

	if(memory[n]>=0)return memory[n];
	else {
		for(int i =n/2; i<=n; i++) {
			//因为n=1时，n/2==0，p[0]中没有存有效数据，所以，n==1要单独拿出来。
			int t=p[i]+CutRod3(n-i);
			if(t>=memory[n]) {//当N=7时，t>memory[n] 输出方案为3 2 2
				memory[n]=t;           //t>=memory[n] 输出方案为 6 1
				r[n]=i;
			}
		}
		//memory数组保存中间计算结果。且结果一旦保存，不会再发生改变。
		return memory[n];
	}
}

方法一、二、三、及重构解均为自顶向下设计算法的。下面分析如何自底向上设计算法：
这里写图片描述
由子问题图可以发现，上层问题只依赖于比自己低的子问题。

#include<iostream>
using namespace std;
int p[1001];
int memory[1001];
int r[1001];
int N;
int main() {
	cin>>N;
	for(int i =1; i<=N; i++) {
		cin>>p[i];
	}
	memory[0]=0;
	
	for(int i=1; i<=N; i++) {
		int max=p[i];//假设当前不切割为最大收益 
		int length=i;//假设当前不切割为最大收益的，策略长度为i 
		for(int j =1; j<i; j++) {
			int t=memory[j]+memory[i-j];//由图可知，规模为i的问题，只与所有规模为j(j<i)的问题有关联。 
			if(max<t) {
				max=t;
				length=j;
			}
		}
		memory[i]=max;
		r[i]=length;
	}
	cout<<"最大收益为："<<memory[N]<<endl;
	cout<<"获得最大收益的策略是：";
	while(N>0&&r[N]>0) {
		cout<<r[N]<<" ";
		N-=r[N];
	}


}