详述钢条切割问题--算法导论

于 2024-09-18 21:51:25 发布
阅读量1.3k 收藏 34
点赞数 21
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Hennan_Dianzi_C/article/details/142330269
版权

        我们知道Serling公司出售一段长度为i英寸的钢条的价格为p_{i}(i=1,2,3......n)钢条的长度为整英寸。价格表样例如：

钢条切割问题：

给定一段长度为n英寸的钢条和一个价格表p_{i}，求切割钢条的方案，使得销售收益r_{n}最大。注意，如果长度为n英寸的钢条的价格足够大，最优解可能就是完全不需要切割。

        下面给出4英寸的不同切割方案：

长度为n英寸的钢条有n-1个切割点，每个点都可选择切割与不切割，则共有2*2*2......*2*2(n-1个2相乘)=2^{n-1}种切割方案。

        4英寸长度的钢条的最大收益切割为2+2，收益为10。我们从中可以知道n英寸的钢条最大收益可由切割后的小钢条的最大收益组合而成，这就是“大事化小，小事化了”。

        下面给出了10英寸及以内（价格表只给到了10英寸的价格）的钢条最佳切割方案：

        我们发现它们最优解都是由无切割的长度组合，这些无法切割的长度就是最优的子结构。

一，自顶向下递归法

        我们将钢条从左边切割下长度为i的一段，只对右边剩下的长度为n-i的一段继续进行切割(递归)。这样，不做任何切割的方案可以描述为：切割的长度为n，剩余长度为0。

        以4英寸的钢条为例，可得如下的树：

代码实现：

#pragma once
#include<iostream>
using namespace std;
//钢条长度的价值
typedef struct Steel_Bar
{
	int value[11] = {0,1,5,8,9,10,17,17,20,24,30};
}SB;

//返回最大值
int MAX(int a, int b)
{
	if (a > b)
		return a;
	else
		return b;
}
//递归
int CUT_ROD(SB s,int n)
{
	if (n == 0)
		return 0;
	int q=-1;              //q来存储最大收益
	for (int i = 1; i <= n; i++)
	{
		q = MAX(q, s.value[i] + CUT_ROD(s, n - i));//观察树，找出一层中最大收益
	}
	return q;
}



void tests()
{

	SB s;
	for (int i = 0; i <= 10; i++)
	{

		cout <<"长度为"<<i<<"英寸的钢条最大收益为：" << CUT_ROD(s, i) << endl;

	}
}

输出：

长度为0英寸的钢条最大收益为：0
长度为1英寸的钢条最大收益为：1
长度为2英寸的钢条最大收益为：5
长度为3英寸的钢条最大收益为：8
长度为4英寸的钢条最大收益为：10
长度为5英寸的钢条最大收益为：13
长度为6英寸的钢条最大收益为：17
长度为7英寸的钢条最大收益为：18
长度为8英寸的钢条最大收益为：22
长度为9英寸的钢条最大收益为：25
长度为10英寸的钢条最大收益为：30

当n为4时剖析图： 

        当你在计算机上运行它时，你会发现，一旦输入的规模稍稍变大，程序运行时间会变的非常长。这是因为他反复的求解了相同的子问题。

我们来分析分析该算法的运行时间，可根据上方树列出如下公式，1是根结点对应的最初一次调用，后面是每次分割后的递归。

T(n)=1+\sum_{j=0}^{n-1}T(j)

数学归纳法求解：

T(0)=1=2^0

T(1)=1+T(0)=2^1

T(2)=1+T(0)+T(1)=4=2^2

假设n=k   T(k)=2^k

要证T(k+1)=2^(k+1)

T(k+1)=1+T(0)+T(1)+...+T(k)=1+2^0+2^1+2^2+...+2^k

=1+1*(1-2^(n+1))/1-2=2^(k+1)

证毕

即T(n)=2^n

该算法的运行时间是n的指数函数，效率是非常低的，我们不让它重复计算相同的子问题不就大大缩减了运行时间，这就是我们接下来的动态规划算法。

二，动态规划方法求解最优钢条切割问题

        我们已经看到，朴素递归算法之所以效率很低，是因为它反复求解相同的子问题。因此，动态规划方法仔细安排求解顺序，对每个子问题只求解一次，并将结果保存下来。如果随后再次需要此子问题的解，只需要查找保存的结果，而不必重新计算。因此，动态规划方法是付出额外的内存空间来节省计算时间。

1.带备忘的自顶向下法

#pragma once
#include<iostream>
using namespace std;
//钢条长度的价值
typedef struct Steel_Bar
{
	int value[11] = {0,1,5,8,9,10,17,17,20,24,30};
}SB;

//返回最大值
int MAX(int a, int b)
{
	if (a > b)
		return a;
	else
		return b;
}
//输出备忘录
void PrintMemo(int r[])
{
	for (int i = 0; i <= 10; i++)
	{
		cout << "备忘录r[" << i << "]=" << r[i] << endl;
	}
}
int CUT_ROD(SB s, int n, int r[])
{
	if (r[n]>=0)       
		return r[n];    //n>=0说明以找到最优解，直接放回，不需要重复计算
	int q=-1;
	for (int i = 1; i <= n; i++)
	{
		q = MAX(q, s.value[i] + CUT_ROD(s, n - i,r));
	}
	r[n] = q;          //将找到的最优解储存在备忘录
	return q;
}
//带备忘的自顶向下法
int MEMOIZED_CUT_ROD(SB s, int n)
{
	int r[11];          //备忘录数组
	r[0] = 0;           //n为0时，价值为0
	for (int i = 1; i < 11; i++)
	{
		r[i] = -1;      
	}
	int result= CUT_ROD(s, n,r);
	PrintMemo(r);
	return result;
}


void tests()
{

	SB s;
	for (int i = 0; i <= 10; i++)
	{
	

		cout <<"长度为"<<i<<"英寸的钢条最大收益为：" << MEMOIZED_CUT_ROD(s, i) << endl;


	}
}

输出：

备忘录r[0]=0
备忘录r[1]=-1
备忘录r[2]=-1
备忘录r[3]=-1
备忘录r[4]=-1
备忘录r[5]=-1
备忘录r[6]=-1
备忘录r[7]=-1
备忘录r[8]=-1
备忘录r[9]=-1
备忘录r[10]=-1
长度为0英寸的钢条最大收益为：0
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=-1
备忘录r[3]=-1
备忘录r[4]=-1
备忘录r[5]=-1
备忘录r[6]=-1
备忘录r[7]=-1
备忘录r[8]=-1
备忘录r[9]=-1
备忘录r[10]=-1
长度为1英寸的钢条最大收益为：1
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=-1
备忘录r[4]=-1
备忘录r[5]=-1
备忘录r[6]=-1
备忘录r[7]=-1
备忘录r[8]=-1
备忘录r[9]=-1
备忘录r[10]=-1
长度为2英寸的钢条最大收益为：5
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=-1
备忘录r[5]=-1
备忘录r[6]=-1
备忘录r[7]=-1
备忘录r[8]=-1
备忘录r[9]=-1
备忘录r[10]=-1
长度为3英寸的钢条最大收益为：8
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=-1
备忘录r[6]=-1
备忘录r[7]=-1
备忘录r[8]=-1
备忘录r[9]=-1
备忘录r[10]=-1
长度为4英寸的钢条最大收益为：10
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=-1
备忘录r[7]=-1
备忘录r[8]=-1
备忘录r[9]=-1
备忘录r[10]=-1
长度为5英寸的钢条最大收益为：13
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=17
备忘录r[7]=-1
备忘录r[8]=-1
备忘录r[9]=-1
备忘录r[10]=-1
长度为6英寸的钢条最大收益为：17
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=17
备忘录r[7]=18
备忘录r[8]=-1
备忘录r[9]=-1
备忘录r[10]=-1
长度为7英寸的钢条最大收益为：18
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=17
备忘录r[7]=18
备忘录r[8]=22
备忘录r[9]=-1
备忘录r[10]=-1
长度为8英寸的钢条最大收益为：22
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=17
备忘录r[7]=18
备忘录r[8]=22
备忘录r[9]=25
备忘录r[10]=-1
长度为9英寸的钢条最大收益为：25
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=17
备忘录r[7]=18
备忘录r[8]=22
备忘录r[9]=25
备忘录r[10]=30
长度为10英寸的钢条最大收益为：30

n为4时剖析图： 

观察上面剖析图，分析消耗的运行时间，由于直接查备忘录返回的时间忽略不计，得如下图：

如图可看出，循环和递归构成了一个等差数列，不难分析出运行的时间为\Theta (n^{2})

2.自底向上

#pragma once
#include<iostream>
using namespace std;
//钢条长度的价值
typedef struct Steel_Bar
{
	int value[11] = {0,1,5,8,9,10,17,17,20,24,30};
}SB;

//返回最大值
int MAX(int a, int b)
{
	if (a > b)
		return a;
	else
		return b;
}
//输出备忘录
void PrintMemo(int r[])
{
	for (int i = 0; i <= 10; i++)
	{
		cout << "备忘录r[" << i << "]=" << r[i] << endl;
	}
}

//带备忘的自底向上法
int BOTTOM_UP_CUT_ROD(SB s, int n)
{
	int r[11];          //备忘录数组
	r[0] = 0;           //n为0时，价值为0
	for (int j = 1; j <= n; j++)
	{
		int q = -1;
		for (int i = 1; i <= j; i++)
		{
			q = MAX(q, s.value[i] + r[j - i]);
		}
		r[j] = q;
	}
	PrintMemo(r);
	return r[n];
}


void tests()
{

	SB s;
	for (int i = 0; i <= 10; i++)
	{
		cout <<"长度为"<<i<<"英寸的钢条最大收益为：" << BOTTOM_UP_CUT_ROD(s, i) << endl;
	}
}

输出：

备忘录r[0]=0
备忘录r[1]=-858993460
备忘录r[2]=-858993460
备忘录r[3]=-858993460
备忘录r[4]=-858993460
备忘录r[5]=-858993460
备忘录r[6]=-858993460
备忘录r[7]=-858993460
备忘录r[8]=-858993460
备忘录r[9]=-858993460
备忘录r[10]=-858993460
长度为0英寸的钢条最大收益为：0
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=-858993460
备忘录r[3]=-858993460
备忘录r[4]=-858993460
备忘录r[5]=-858993460
备忘录r[6]=-858993460
备忘录r[7]=-858993460
备忘录r[8]=-858993460
备忘录r[9]=-858993460
备忘录r[10]=-858993460
长度为1英寸的钢条最大收益为：1
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=-858993460
备忘录r[4]=-858993460
备忘录r[5]=-858993460
备忘录r[6]=-858993460
备忘录r[7]=-858993460
备忘录r[8]=-858993460
备忘录r[9]=-858993460
备忘录r[10]=-858993460
长度为2英寸的钢条最大收益为：5
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=-858993460
备忘录r[5]=-858993460
备忘录r[6]=-858993460
备忘录r[7]=-858993460
备忘录r[8]=-858993460
备忘录r[9]=-858993460
备忘录r[10]=-858993460
长度为3英寸的钢条最大收益为：8
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=-858993460
备忘录r[6]=-858993460
备忘录r[7]=-858993460
备忘录r[8]=-858993460
备忘录r[9]=-858993460
备忘录r[10]=-858993460
长度为4英寸的钢条最大收益为：10
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=-858993460
备忘录r[7]=-858993460
备忘录r[8]=-858993460
备忘录r[9]=-858993460
备忘录r[10]=-858993460
长度为5英寸的钢条最大收益为：13
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=17
备忘录r[7]=-858993460
备忘录r[8]=-858993460
备忘录r[9]=-858993460
备忘录r[10]=-858993460
长度为6英寸的钢条最大收益为：17
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=17
备忘录r[7]=18
备忘录r[8]=-858993460
备忘录r[9]=-858993460
备忘录r[10]=-858993460
长度为7英寸的钢条最大收益为：18
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=17
备忘录r[7]=18
备忘录r[8]=22
备忘录r[9]=-858993460
备忘录r[10]=-858993460
长度为8英寸的钢条最大收益为：22
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=17
备忘录r[7]=18
备忘录r[8]=22
备忘录r[9]=25
备忘录r[10]=-858993460
长度为9英寸的钢条最大收益为：25
备忘录r[0]=0
备忘录r[1]=1
备忘录r[2]=5
备忘录r[3]=8
备忘录r[4]=10
备忘录r[5]=13
备忘录r[6]=17
备忘录r[7]=18
备忘录r[8]=22
备忘录r[9]=25
备忘录r[10]=30
长度为10英寸的钢条最大收益为：30

样例:

        由样例图可看出自底向上算法嵌套的是双重循环，内层for循环的迭代次数构成一个等差数列，不难分析过程的运行时间是\Theta (n^{2})

3.优化(保存最优解第一段钢条的切割长度)

#pragma once
#include<iostream>

#include<iomanip>
using namespace std;
//钢条长度的价值
typedef struct Steel_Bar
{
	int value[11] = {0,1,5,8,9,10,17,17,20,24,30};

}SB;

//返回最大值
int MAX(int a, int b)
{
	if (a > b)
		return a;
	else
		return b;
}
//输出备忘录
void PrintMemo(int r[],int length[],int n)
{
	cout << "钢条的长度：";
	for (int i = 0; i <= n; i++)
	{
		cout << left << setw(5) << i << "   ";
	}
	cout << endl;
	cout << "最大的收益：";
	for (int i = 0; i <= n; i++)
	{
		cout<< left << setw(5) << r[i] << "   ";
	}
	cout << endl;
	cout << "第一段长度：";
	for (int i = 0; i <= n; i++)
	{
		cout << left << setw(5) << length[i] << "   ";
	}
	cout << endl;

}

//带备忘的自底向上法
int BOTTOM_UP_CUT_ROD(SB s, int n)
{
	int r[11];          //备忘录数组
	int length[11];//存储第一段长度
	r[0] = 0;           //n为0时，价值为0
	length[0] = 0;
	
	for (int j = 1; j <= n; j++)
	{
		int q = -1;
		for (int i = 1; i <= j; i++)
		{
			if (q < s.value[i] + r[j - i])       //前一个分割收益小于该分割收益，替换收益并修改其对应的第一条钢条的切割长度
			{
				q = s.value[i] + r[j - i];   
				length[j] = i;
			}
		}
		r[j] = q;
	}
	PrintMemo(r, length,n);
	return r[n];
}


void tests()
{

	SB s;
	for (int i = 0; i <= 10; i++)
	{
		cout <<"长度为"<<i<<"英寸的钢条最大收益为：" << BOTTOM_UP_CUT_ROD(s, i) << endl;
	}
}

输出：

钢条的长度：0
最大的收益：0
第一段长度：0
长度为0英寸的钢条最大收益为：0
钢条的长度：0       1
最大的收益：0       1
第一段长度：0       1
长度为1英寸的钢条最大收益为：1
钢条的长度：0       1       2
最大的收益：0       1       5
第一段长度：0       1       2
长度为2英寸的钢条最大收益为：5
钢条的长度：0       1       2       3
最大的收益：0       1       5       8
第一段长度：0       1       2       3
长度为3英寸的钢条最大收益为：8
钢条的长度：0       1       2       3       4
最大的收益：0       1       5       8       10
第一段长度：0       1       2       3       2
长度为4英寸的钢条最大收益为：10
钢条的长度：0       1       2       3       4       5
最大的收益：0       1       5       8       10      13
第一段长度：0       1       2       3       2       2
长度为5英寸的钢条最大收益为：13
钢条的长度：0       1       2       3       4       5       6
最大的收益：0       1       5       8       10      13      17
第一段长度：0       1       2       3       2       2       6
长度为6英寸的钢条最大收益为：17
钢条的长度：0       1       2       3       4       5       6       7
最大的收益：0       1       5       8       10      13      17      18
第一段长度：0       1       2       3       2       2       6       1
长度为7英寸的钢条最大收益为：18
钢条的长度：0       1       2       3       4       5       6       7       8
最大的收益：0       1       5       8       10      13      17      18      22
第一段长度：0       1       2       3       2       2       6       1       2
长度为8英寸的钢条最大收益为：22
钢条的长度：0       1       2       3       4       5       6       7       8       9
最大的收益：0       1       5       8       10      13      17      18      22      25
第一段长度：0       1       2       3       2       2       6       1       2       3
长度为9英寸的钢条最大收益为：25
钢条的长度：0       1       2       3       4       5       6       7       8       9       10
最大的收益：0       1       5       8       10      13      17      18      22      25      30
第一段长度：0       1       2       3       2       2       6       1       2       3       10
长度为10英寸的钢条最大收益为：30

长脚的鱼
关注
钢条切割问题：动态规划算法的典型应用
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
04-11 1933
在工业生产和物流管理中，钢条切割问题是一个常见的优化问题。企业在购买长钢条并将其切割为短钢条出售时，往往面临着如何切割以最大化利润的问题。这个问题不仅关系到企业的成本控制和利润最大化，也涉及到资源的有效利用和生产效率的提升。本文将介绍钢条切割问题的数学模型，以及如何运用动态规划算法来寻找最优的切割方案。
钢条切割问题（自顶向下）
Hensonli的博客
05-30 303
钢条切割问题 其实这个问题与我们大家熟知的背包问题本质上是一样的，我们来看一下问题本身：首先这里有一个价格表（表格摘自《算法导论》），表中列出了不同长度的钢条的价格： 长度 1 2 3 4 5 6 7 8 9 10 价格 1 5 8 9 10 17 17 20 24 30 假如现在我们有一块长度为5的钢条，那么我们通过切割这块钢条为不同大小的钢条后可以获得的最大利益是多少。 我们可以先从一块长度为5的钢条上截一块长度为a_legth（初始值为1）的钢条，然后考虑如何切割剩下长度为5-le
算法导论 — 15.1 钢条切割
yangtzhou的专栏
06-01 7457
笔记        本节给出一个寻找钢条最优切割方案的问题。公司购买长钢条，将其切割为短钢条出售。为简化分析，假设切割过程本身没有成本，并且切割下来的短钢条长度都为一英寸的整数倍。下表给出了不同长度的钢条的价格。        钢条切割问题：给定一根长度为n英寸的长钢条，求最优切割方案，使得销售收益最大。注意，最优方案也有可能是完全不用切割。       长度为n英寸的钢条有种切割方案，...
动态规划--钢条切割问题
2301_76618920的博客
05-14 1603
动态规划算法通常基于一个递推公式及一个或多个初始状态。当前子问题的解将由上一次子问题的解推出。动态规划和分治法相似，都是通过组合子问题的解来求解原问题。分治法讲问题划分成互不相交的子问题，递归求解子问题，再将他们的解组合起来，求出原问题的解。与之相反，动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题。在这种情况下，分治算法会做出许多不必要的工作，它会反复的求解那些公共子问题。而动态规划算法对每个子子问题只求解一次，将结果保存到表格中，从而无需每次求解一个子子问题都要重新计算。
切割钢条问题
alidadaaaa的博客
03-25 322
切割钢条问题给出每种长度钢条对应的价格，对于长为n的钢条，怎样切割使得总利益最大。找到一个分割点，左边不再切割，右边递归求解。自顶向下，带备忘：R[n]保存对应解，避免重复求解#include &lt;stdio.h&gt; #include &lt;iostream&gt; using namespace std; int p[] = {0,1,5,8,9,10,17,17,20,24,3...
钢条切割问题
一路向北
04-03 220
对应于算法导论上的钢条切割问题。 package Dynamic_Programming; /* * 动态优化问题之钢条切割问题 * 长度i: 1 2 3 4 5 6 7 8 9 10 * 价格p: 1 5 8 9 10 17 17 20 24 30 * * 问题，对于长度为i的钢条，怎么切割，使之价值最大。 * */ publi...
《算法导论》学习（十七）----动态规划之钢条切割（C语言）
weixin_52042488的博客
10-01 3052
本文主要讲解了钢条切割问题的解决方案，并且给出了C语言代码。其中涉及到了动态规划的思想，会在之后的文章中详细讲解文章不妥之处请各位读者包涵指正。
算法导论----算法经典书籍
04-26
通过学习《算法导论》，读者不仅可以掌握各种算法的实现，还能了解算法设计的通用方法，培养解决问题的逻辑思维能力。这本书适合计算机科学专业的学生，以及任何对算法感兴趣的读者。不论你是初学者还是经验丰富的...
matlab实现扩展卡尔曼滤波无人机-无人车协同定位算法-EKF-UAV-UGV-协同定位算法
最新发布
02-10
内容概要：本文详述了基于扩展卡尔曼滤波（EKF）的无人机（UAV）和无人车（UGV）协同定位算法原理，包括状态建模、观测模型、预处理、预测步、更新步、信息融合、循环迭代以及一致性校正等关键步骤。文章提供了...
k-means聚类算法.docx
05-30
### K-Means聚类算法知识点详述 #### 一、K-Means聚类算法简介 K-Means聚类算法是一种典型的无监督学习算法，它的主要目标是将一个给定的数据集划分为K个不同的簇（clusters），使得每个簇内的数据点尽可能相似，...
算法导论-动态规划(钢条切割问题）
weixin_38168322的博客
07-10 335
动态规划(dynamic programming)与分之方法相似，都是通过组合子问题的解来求解原问题。分治方法将问题划分为互不相交的子问题，递归地求解子问题，再将它们的解组合起来，求出原问题的解(如归并排序)。而动态规划应用于子问题重叠的情况，即不同的子问题具有公共的子子问题(子问题的求解是递归进行的，将其划分为更小的子子问题)。在这种情况下，分治算法会做许多不必要的工作，它会反复地...
算法导论-动态规划（钢条切割问题）
fff1412的博客
03-03 2638
写下文章来记录下自己学习算法导论的笔记 文章目录写下文章来记录下自己学习算法导论的笔记动态规划的目的设计动态规划算法钢条切割问题问题描述刻画问题结构（建立方程）递归方程建立带备忘录的自顶向下法自底向下的方法如何保留切割方案源代码 动态规划的目的 求出最优子结构 设计动态规划算法 1.刻画一个最优解的结构特征 2.递归定义最优解的值 3.计算最优解的值 4.利用计算出的信息构造一个最优解 钢条切割问题 问题描述 ​ Serling公司购买长钢条，将其切割为短钢条出售。切割工序本身没有成本支出。公司管理层希.
算法导论---钢条切割
qq_61185410的博客
03-29 1113
题目： Serling公司购买长钢条，将其切割为短钢条出售。切割工序本身没有成本支出。公司管理层希望知道最佳的切割方案。 ​ 假定我们知道Serling公司出售一段长度为i英寸的钢条的价格为p;(i=1，2，…，单位为美元)。钢条的长度均为整英寸。表1给出了一个价格表的样例。 ​ 钢条切割问题是这样的:给定一段长度为n英寸的钢条和一个价格表p;(i=1，2，…，n)，求切割钢条方案，使得销售收益r。最大。注意，如果长度为n英寸的钢条的价格pn足够大，最优解可能就是完全不需要切割。 方法一：dfs深
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值