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

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量104 收藏
点赞数 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
关注
算法导论第十五章动态规划
z84616995z的专栏
08-18 2万+
概述： 动态规划是通过组合子问题的解而解决整个问题的。 动态规划适用于子问题不是独立的情况，也就是各子问题的包含公共的子子问题。 动态规划对每个子问题只求解一次，将其结果保存在一张表中。 动态规划通常用于最优化问题。 动态规划的设计步骤：a.描述最优解的结构b.递归定义最优解的值c.按自底向上的方式计算最优觖的值d.由计算出的结构构造一个最优解 15.1钢条切割
算法导论第15章15.2-1
u010969626的博客
02-06 2645
找了一段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 135
分治方法：子问题互不相交，递归地求解子问题，再将他们组合起来。 动态规划：子问题之间相互重叠 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 525
（dynamic programming）的思想是和。动态规划方法通常用来求解这类问题可以有很多可行的解，每个解都有一个值，我们希望寻找具有最优值（最小值或最大值）的解。我们称这样的解为问题的（an optimal solution），而不是（the optimal solution），因为可能有多个解都是最优值。步骤1~3是动态规划求解问题的基础。如果我们仅仅需要最优解的一个值，而不是最优解本身，可以忽略步骤4。如果要构造最优解，则必须执行步骤4，步骤3中维护的一些额外信息是构造最优解的基础。
《算法导论3rd第十五章》动态规划
懒猫的脚印
12-05 2238
算法导论，第十五章，动态规划，最长公共子序列
算法导论第15章习题15.1-4
u010969626的博客
02-05 1427
定义全局变量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 4908
（库存规划）Rinky Dink公司是一家制造溜冰场冰面修整设备的公司。这种设备每个月的需求量都在变化，因此公司希望设计一种策略来规划生产，需求是给定的，即它虽然是波动的，但是是可预测的。公司希望设计接下来nnn个月的生产计划。对第iii个月，公司知道需求did_idi​，即该月能够销售出去的设备的数量。令D=∑i=1ndiD = \sum_{i=1}^nd_iD=∑i=1n​di​ 为后nnn个...
算法导论第15章-动态规划（1）导论
m0_37578088的博客
02-18 163
动态规划与分治法一样，通过组合子问题的解而解决整个问题。但是动态规划与分治法不同的地方在于，分治法是将问题划分成一些独立的子问题，递归地求解各个子问题，然后合并子问题的解而得到原问题的解，而动态规划则是将问题问题划分成一系列不独立的子问题，也就是各子问题包含相同的孙问题。在这种情况下，分治法会做很多不必要的工作，即重复地求解公共问题的孙问题。而动态规划则只对每个孙问题只求解一次，然后将其结果保留在表中，从而避免在各个子问题的求解过程中重复计算孙问题。 动态规划适用于最优化问题。这种问题有很多可行解，每个解
算法导论第十五章15.2-4
u010969626的博客
02-08 1375
算法导论第15章368页，当思考一个动态规划问题时，我们应该弄清楚所涉及的子问题与子问题的依赖关系，问题的子问题图准确的表达了这些信息。 那么根据此图可以来回答题目15.2-4. 输入链长度为n那么矩阵数目为n-1，所以子问题图一共包含n-1个定点，一共包含1+2+3+......+n-1=1/2(n^2-n)条边，这些边连接原问题顶点和比其更小的子问题的顶点
算法导论1-4章、15-16章
qq_60987997的博客
05-27 536
算法导论复习ing
算法导论第15章课后习题答案
01-14
算法导论第15章-动态规划的课后习题参考答案，对于算法爱好者而言，是不错的参考资料。
算法导论 第二十五章 答案
12-21
算法导论 第二十五章 答案 算法导论 第二十五章 答案 算法导论 第二十五章 答案
算法导论第1-16章编程题答案
08-21
11. **第十五章：概率与信息论** - 虽然这不是典型的编程主题，但可能会涉及到计算概率或信息熵的Java实现。 12. **第十六章：近似算法** - 当问题无法得到精确解时，近似算法可以找到接近最优的解，如旅行商问题的...
算法导论-第三版(中文).rar
09-18
第十五章 动态规划（Dynamic Programming） 第十六章 贪婪算法（Greedy Algorithms） 第十七章 分摊分析（Amortized Analysis） 第五部分（Part V） 高级的数据结构（Advanced Data Structures） 第十八章 B-树...
算法导论--教师手册
04-05
《算法导论--教师手册》是一本针对计算机科学专业学生及教师的重要参考书籍，由Thomas H. Cormen、Charles E. Leiserson、Ronald L. Rivest和Clifford Stein四位作者共同编撰，第二版由Thomas H. Cormen、Clara Lee...
HJ51输出单向链表中倒数第k个结点
晴山の博客
10-29 304
HJ51输出单向链表中倒数第k个结点。
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 144
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
查找算法简记
well_fly的博客
10-30 607
简单记录查找算法相关知识点
C++算法第五天
2302_80418176的博客
10-31 1053
1. 首这个解法叫滑动窗口，本质是同向双指针2. 使用这个解法的原因是利用了单调性3.滑动窗口的正确性：利用的单调性，规避了没必要的枚举行为4.枚举二字算是在博主的文章中第一次出现，那么我也解释枚举是什么意思，枚举就是将每一种情况都一一列举出来。
算法导论习题详解：第2-5章答案集
这份参考资料包含了该书的部分章节习题的详细解答，包括第2章至第9章、第15章、第16章及第24章和第25章的内容。" 在《算法导论》这本书中，各章节涉及的知识点广泛而深入，下面将分别概述提及的章节习题所涵盖的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值