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

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
请按任意键继续. . .