第15章动态规划------算法导论

最新推荐文章于 2024-06-14 09:50:01 发布
最新推荐文章于 2024-06-14 09:50:01 发布
阅读量89 收藏
点赞数 1
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/l2017/p/10284323.html
版权

 

15.1钢条切割

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
#include<ctime> 
#include<string>
using namespace std;
int p[1000]{ 0,1,5,8,9,10,17,17,20,24,30 };//钢条价格。长度i的价格为p[i]
int ordinary(int *p, int n)//递归法
{
	if (n == 0)
		return 0;
	else
	{
		int q = -1;
		for (int i = 1; i <= n; ++i)
		{
			q = max(p[i] + ordinary(p, n - i), q);
		}
		return q;
	}
}
int top_down_memory(int *p, int n)//动态规划 带备忘的自顶向下法  与递归法类似，只是结果存储起来了
{
	static int b[1000];
	if (n == 0)
		return 0;
	if (b[n] != 0)
	{
		return b[n];
	}
	else
	{
		int q = -1;
		for (int i = 1; i <= n; ++i)
		{
			q = max(p[i] + top_down_memory(p, n - i), q);
		}
		b[n] = q;
		return q;
	}
}
int bottom_up_method(int *p, int n)//动态规划 自底向上 把子结果都先求出来，再求总结果
{
	static int b[1000];
	for (int i = 1; i <= n; ++i)
	{
		int q = -1;
		for (int j = 1; j <= i; ++j)
		{
			q = max(q, p[j] + b[i - j]);
		}
		b[i] = q;
	}
	return b[n];
}
int bottom_up_method_result(int *p, int n)//动态规划 自底向上 把子结果都先求出来，再求总结果 同时把如何切割求出来
{
	static int b[1000];
	static int s[1000];//切割方案
	for (int i = 1; i <= n; ++i)
	{
		int q = -1;
		int ss = -1;
		for (int j = 1; j <= i; ++j)
		{
			if (q < p[j] + b[i - j])
			{
				q = p[j] + b[i - j];
				ss = j;
			}
		}
		s[i] = ss;
		b[i] = q;
	}
	return b[n];
}
int main()
{
	int n;
	clock_t start;

	while (cin >> n)
	{
		start = clock();
		cout << ordinary(p, n);
		cout << "ordinary：" << double(clock() - start) <<endl;
		start = clock();
		cout << bottom_up_method_result(p, n);
		cout << "bottom_up_method_result：" << double(clock() - start) << endl;
		start = clock();
		cout << top_down_memory(p, n);
		cout << "top_down_memory：" << double(clock() - start) << endl;
	}
}

　　结果：前面是结果，后面是函数运行时间

25
73ordinary：4497
73bottom_up_method_result：0
73top_down_memory：1

　　

 

15.2矩阵链乘法

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<algorithm>
#include<ctime>
#include<string>
using namespace std;
int p[1000]{ 0, 30,35,15,5,10,20,25,99,65,32,45,79,96,15 };
#define N 14

int ordinary(int *p, int a, int b)//递归法
{
	if (a == b)return 0;
	if (a + 1 == b)return p[a] * p[b] * p[b + 1];
	int min = INT_MAX;
	for (int i = a; i < b; ++i)
	{
		if (min >(ordinary(p, a, i) + ordinary(p, i + 1, b) + p[a] * p[i + 1] * p[b + 1]))
			min = ordinary(p, a, i) + ordinary(p, i + 1, b) + p[a] * p[i + 1] * p[b + 1];
	}
	return min;
}
int top_down_memory(int *p, int a, int b)//动态规划 带备忘的自顶向下法  与递归法类似，只是结果存储起来了
{
	static int dd[1000][1000];
	if (dd[a][b])return dd[a][b];
	if (a == b)return 0;
	if (a + 1 == b)return p[a] * p[b] * p[b + 1];
	int min = INT_MAX;
	for (int i = a; i < b; ++i)
	{

		if (min >(top_down_memory(p, a, i) + top_down_memory(p, i + 1, b) + p[a] * p[i + 1] * p[b + 1]))
			min = top_down_memory(p, a, i) + top_down_memory(p, i + 1, b) + p[a] * p[i + 1] * p[b + 1];
	}
	dd[a][b] = min;
	return min;
}
static int s[1000][1000];
int bottom_up_method(int *p, int a, int b)//动态规划 自底向上 把子结果都先求出来，再求总结果
{
	static int q[1000][1000];
	for (int i = 2; i <= b; ++i)
		for (int j = 1; j <= b - i + 1; ++j)
		{
			for (int k = 1; k < i; ++k)
			{
				if (q[j][i] != 0 && q[j][i] > q[j][k] + q[j + k][i - k] + p[j] * p[j + k] * p[i + j])
				{
					q[j][i] = q[j][k] + q[j + k][i - k] + p[j] * p[j + k] * p[i + j];
					s[j][i + j - 1] = k + j - 1;
				}
				if (q[j][i] == 0)
				{
					q[j][i] = q[j][k] + q[j + k][i - k] + p[j] * p[j + k] * p[i + j];
					s[j][i + j - 1] = k + j - 1;
				}
			}
		}

	return q[1][b];
}
void print_result(int s[][1000], int i, int j)
{
	if (i == j)
		cout << "A" << i;
	else
	{
		cout << "(";
		print_result(s, i, s[i][j]);
		print_result(s, s[i][j] + 1, j);
		cout << ")";
	}
}
int main()
{
	int n=N;
	clock_t start;
	start = clock();
	cout << ordinary(p, 1, n-1);//递归法;
	cout << "ordinary：" << double(clock() - start) << " " << endl;
	start = clock();
	cout << top_down_memory(p, 1, n - 1) ;
	cout << "top_down_memory：" << double(clock() - start) << " " << endl;
	start = clock();
	cout << bottom_up_method(p, 1, n - 1) ;
	cout << "bottom_up_method：" << double(clock() - start) << " " << endl;
	start = clock();
	print_result(s, 1, n - 1);
	cout << endl;

	return 0;
}

　　结果：前面是结果，后面是函数运行时间

138670ordinary：406
138670top_down_memory：1
138670bottom_up_method：0
((A1(A2A3))(((((((((A4A5)A6)A7)A8)A9)A10)A11)A12)A13))
请按任意键继续. . .

　　

 

15.4最长公共子序列

#include<iostream>
#include<vector>
#include<set>
#include<string>
#include<ctime>
#include<algorithm>
using namespace std;

void subset2(const char *a, int n, vector<string> &sub2, string temp = string(), int t = 0)//产生子串，上一篇文章有介绍
{
	if (t == n)
	{
		sub2.push_back(temp);
		return;
	}
	subset2(a, n, sub2, temp, t + 1);
	temp += (a[t]);
	subset2(a, n, sub2, temp, t + 1);
}
int violence(string a, string b)//暴力子串匹配
{
	vector<string> sub2;
	subset2(a.c_str(), a.size(), sub2);
	int max_s = 0;
	for (int i = 0; i < sub2.size(); ++i)
	{
		int k = 0;
		for (int j = 0; j < b.size() && k < sub2[i].size(); ++j)
		{
			if (b[j] == sub2[i][k])
				++k;
		}
		if (k == sub2[i].size())
			max_s = max(max_s, k);
	}
	return max_s;
}

int ordinary(string a, string b, int ii, int jj)//递归法
{
	if (ii == 0 || jj == 0)return 0;
	if (a[ii] == b[jj])
	{
		return ordinary(a, b, ii - 1, jj - 1) + 1;
	}
	return max(ordinary(a, b, ii, jj - 1), ordinary(a, b, ii - 1, jj));
}
int top_down_memory(string a, string b, int ii, int jj)//动态规划 带备忘的自顶向下法  与递归法类似，只是结果存储起来了
{
	static int p[1000][1000];
	if (p[ii][jj])return p[ii][jj];
	if (ii == 0 || jj == 0)return 0;
	if (a[ii] == b[jj])
	{
		p[ii][jj] = top_down_memory(a, b, ii - 1, jj - 1) + 1;
		return p[ii][jj];
	}
	p[ii][jj] = max(top_down_memory(a, b, ii, jj - 1), top_down_memory(a, b, ii - 1, jj));
	return p[ii][jj];
}
int bottom_up_method(string a, string b)//动态规划 自底向上 把子结果都先求出来，再求总结果
{
	int **p = new int *[a.size() + 1];
	for (int i = 0; i < a.size() + 1; ++i)
		p[i] = new int[b.size() + 1];
	for (int i = 0; i < a.size() + 1; ++i)
		for (int j = 0; j < b.size() + 1; ++j)
			p[i][j] = 0;
	for (int i = 0; i < a.size(); ++i)
		for (int j = 0; j < b.size(); ++j)
		{
			if (a[i] == b[j])
				p[i + 1][j + 1] = p[i][j] + 1;
			else
				p[i + 1][j + 1] = max(p[i][j + 1], p[i + 1][j]);
		}
	//for (int i = 0; i < a.size() + 1; ++i)
	//{
	//	for (int j = 0; j < b.size() + 1; ++j)
	//		cout<<p[i][j]<<" ";
	//	cout << endl;
	//}
	return p[a.size()][b.size()];
}



int main()
{
	string a, b;
	clock_t start;

	cin >> a >> b;

	start = clock();

	cout << violence(a, b);
	cout << "violence：" << double(clock() - start) << " " << endl;
	start = clock();
	cout << bottom_up_method(a, b);
	cout << "bottom_up_method：" << double(clock() - start) << " " << endl;
	start = clock();
	cout << ordinary(a, b, a.size(), b.size());
	cout << "ordinary：" << double(clock() - start) << " " << endl;
	start = clock();
	cout << top_down_memory(a, b, a.size(), b.size());
	cout << "top_down_memory：" << double(clock() - start) << " " << endl;
	start = clock();

}

　　结果：前面是结果，后面是函数运行时间

{1,3,4,5,6,7,7,8}
{3,5,7,4,8,6,7,8,2}
12violence：4400
12bottom_up_method：1
12ordinary：5798
12top_down_memory：7
请按任意键继续. . .

　　

 

转载于:https://www.cnblogs.com/l2017/p/10284323.html

dew0927
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法导论第十五章动态规划
z84616995z的专栏
08-18 2万+
概述： 动态规划是通过组合子问题的解而解决整个问题的。 动态规划适用于子问题不是独立的情况，也就是各子问题的包含公共的子子问题。 动态规划对每个子问题只求解一次，将其结果保存在一张表中。 动态规划通常用于最优化问题。 动态规划的设计步骤：a.描述最优解的结构b.递归定义最优解的值c.按自底向上的方式计算最优觖的值d.由计算出的结构构造一个最优解 15.1钢条切割
算法导论第15章15.2-1
u010969626的博客
02-06 2603
找了一段C实现的矩阵链乘法 #include "stdafx.h" #include #include #define N 1000 int m[N][N];  //m[i][j]表示从第i个矩阵乘到第j个矩阵所需的最小代价 int s[N][N];  //s[i][j]表示最优值m[i][j]对应的分割点 int p[N];     //p[]代表矩阵链 void MATRIX_
第15章 动态规划
qingxuan_1993的博客
06-08 120
分治方法：子问题互不相交，递归地求解子问题，再将他们组合起来。 动态规划：子问题之间相互重叠 15.1 钢条切割 购买的长钢管切割为短钢管出售，求最佳切割方案。 价格表： 长度 i 1 2 3 4 5 6 7 8 9 10 价格 Pi 1 5 8 9 10 17 17 20 24 30 问题：给定一段长度为n英寸的钢条和一个价格表pi，求切割钢条方案，使得销售收益最大。 最优子结构：问题的最优解由相关子问题的最优解组合而成，而这些子问题可以独立求解。 ...
算法导论-第15章-动态规划
CSDN博客
07-05 335
（dynamic programming）的思想是和。动态规划方法通常用来求解这类问题可以有很多可行的解，每个解都有一个值，我们希望寻找具有最优值（最小值或最大值）的解。我们称这样的解为问题的（an optimal solution），而不是（the optimal solution），因为可能有多个解都是最优值。步骤1~3是动态规划求解问题的基础。如果我们仅仅需要最优解的一个值，而不是最优解本身，可以忽略步骤4。如果要构造最优解，则必须执行步骤4，步骤3中维护的一些额外信息是构造最优解的基础。
《算法导论3rd第十五章》动态规划
懒猫的脚印
12-05 2046
算法导论，第十五章，动态规划，最长公共子序列
算法导论第15章习题15.1-4
u010969626的博客
02-05 1405
定义全局变量k存储子函数计算最大收益时的变量i #include "stdafx.h" #include using namespace std; int k=0; int Max(int a, int b) { return a>b ? a : b; } int MEMOIZED_CUT_ROD_AUX(int p[], int n, int r[],int &k) {
算法导论 — 思考题15-11 库存规划
yangtzhou的专栏
11-24 4788
（库存规划）Rinky Dink公司是一家制造溜冰场冰面修整设备的公司。这种设备每个月的需求量都在变化，因此公司希望设计一种策略来规划生产，需求是给定的，即它虽然是波动的，但是是可预测的。公司希望设计接下来nnn个月的生产计划。对第iii个月，公司知道需求did_idi​，即该月能够销售出去的设备的数量。令D=∑i=1ndiD = \sum_{i=1}^nd_iD=∑i=1n​di​ 为后nnn个...
算法导论第15章-动态规划（1）导论
m0_37578088的博客
02-18 141
动态规划与分治法一样，通过组合子问题的解而解决整个问题。但是动态规划与分治法不同的地方在于，分治法是将问题划分成一些独立的子问题，递归地求解各个子问题，然后合并子问题的解而得到原问题的解，而动态规划则是将问题问题划分成一系列不独立的子问题，也就是各子问题包含相同的孙问题。在这种情况下，分治法会做很多不必要的工作，即重复地求解公共问题的孙问题。而动态规划则只对每个孙问题只求解一次，然后将其结果保留在表中，从而避免在各个子问题的求解过程中重复计算孙问题。 动态规划适用于最优化问题。这种问题有很多可行解，每个解
算法导论1-4章、15-16章
qq_60987997的博客
05-27 441
算法导论复习ing
算法导论第十五章15.2-4
u010969626的博客
02-08 1325
算法导论第15章368页，当思考一个动态规划问题时，我们应该弄清楚所涉及的子问题与子问题的依赖关系，问题的子问题图准确的表达了这些信息。 那么根据此图可以来回答题目15.2-4. 输入链长度为n那么矩阵数目为n-1，所以子问题图一共包含n-1个定点，一共包含1+2+3+......+n-1=1/2(n^2-n)条边，这些边连接原问题顶点和比其更小的子问题的顶点
算法导论第15章课后习题答案
01-14
算法导论第15章-动态规划的课后习题参考答案，对于算法爱好者而言，是不错的参考资料。
算法导论 第二十五章 答案
12-21
算法导论 第二十五章 答案 算法导论 第二十五章 答案 算法导论 第二十五章 答案
算法导论-第三版(中文).rar
09-18
第十五章 动态规划（Dynamic Programming） 第十六章 贪婪算法（Greedy Algorithms） 第十七章 分摊分析（Amortized Analysis） 第五部分（Part V） 高级的数据结构（Advanced Data Structures） 第十八章 B-树...
算法导论第十五章习题解答
03-18
能用代码表示的都用代码表示，不能表示的写出思路，思路都没写的就是我也做不出来
算法导论-麻省理工（中文）
11-22
　第十五章 动态规划（Dynamic Programming） 　第十六章 贪婪算法（Greedy Algorithms） 　第十七章 分摊分析（Amortized Analysis） 　第五部分（Part V） 高级的数据结构（Advanced Data Structures） 　第十八章...
【redis的基本数据类型】
m0_50116974的博客
06-13 487
压缩列表的基本信息包括压缩列表的大小，压缩列表的长度以及最后一个entry的偏移，之所以要有这个偏移，是为了找到最后一个entry,而每个entry都记录上一个元素的大小，通过计算就知道上一个entry的地址，这样方便的从后向前进行遍历。的结构，其分为两部分，8字节的Redis对象元数据信息，8字节的指针，其中Redis对象的元数据信息存储了类型的LRU信息，真正的编码格式等等，而如果字符串存储的是数字类型，则复用了8字节的指针的位置。的操作，但是当列表的元素非常少的时候，其内部使用。
基于JavaScript 如何实现爬山算法以及优化方案
乐闻世界
06-10 1239
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
背包问题—动态规划
weixin_50470247的博客
06-10 144
与找521 零钱兑换的方式的区别，这个是排列，顺序不同，也统计次数。01背包问题：没有物品（元素）只能选择1次。完全背包，物品(元素)个数有无限个。
2024.6.13刷题记录
最新发布
lshx4658的博客
06-14 285
当时没有想到怎么保证队内全都是窗口内的元素，答案：“当队头元素在窗口的左边的时候，弹出队头”，虽然不能保证队内一直没有窗口外的元素，但是能保证使用到的队内元素（队头）全是窗口内元素。当时是有想到这个方法的，但是以为不行，一下没转过来弯。队列储存索引而不是元素，通过储存索引使我们能够快速判断元素是否出窗口。不会，思路来自题解（
动态规划算法实验----最大子段和
11-17
下面是一个动态规划算法的实现，可以解决最大子段和问题。 ```python def max_subarray(nums): if not nums: return 0 n = len(nums) dp = [0] * n dp[0] = nums[0] for i in range(1, n): dp[i] = max(dp[i...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值