课程笔记矩阵连乘问题（动态规划、递归、备忘录优化）

动态规划

这道题感觉和Dijkstra算法有点类似，都是循环先确定一个值后，再去找有没有更优的解法去替换，不过这个题用来学动态规划真的很好理解，要是当时能用这个题这个理解方法也许就继续ACM了…

1. 此图即为dp数组的填充过程，首先完成左上到右下的斜对角线的赋0工作，因为矩阵自己乘没有运算，dp[i][i]全部为0 。
2. 整体的填充过程为按照对角线依次向右上方，r=2->n，最后一个对角线n只需要填充一个数值，dp[1][6]即为最后的答案。
3. 在每一个对角线中，i都是从1开始，到n-r+1。由于每次对角线的结尾处都会减1，i的结尾处与r也有关系。
4. 每次填的j也即为对角线上的位置，j与r、i都有关系j=i+r-1

确定了循环的方式后，就要确定动态规划方程。
对于dp[i][j]数组的含义，为矩阵 i 到 矩阵 j 之前乘积的最小次数。那么对于每一次的i与j之间的最小次数，我们都先默认从i处先断开为最优解，然后记录下来这个值，再从i与j之间找到一个k，如果dp[i][k]+dp[k+1][j]+p[i-1]p[k]p[j]的值小于dp[i][j]，那么k应该为dp[i][j]中的间断位置，在k处间断后能使dp[i][j]有更好的乘积策略。
动态规划方程：

#include<iostream>
using namespace std;
const int NUM = 105;
int p[NUM];
int s[NUM][NUM]; // s[i][j]表示矩阵从i到j的断开处
int dp[NUM][NUM]; // dp[i][j]表示矩阵从i乘到j的最少乘次数
void MatrixChain(int n)
{
	for (int i = 1; i <= n; ++i)
		dp[i][i] = 0;
	for (int r = 2; r <= n; ++r) // r为对角线数，r=1时矩阵自己与自己乘一定为0
	{
		for (int i = 1; i <= n - r + 1; ++i)
		{
			int j = i + r - 1;
			dp[i][j] = dp[i + 1][j] + p[i - 1] * p[i] * p[j];
			s[i][j] = i; // 首先假设从i处断开
			for (int k = i + 1; k < j; ++k) // 枚举后续位置，如果有更优解则进行转化
			{
				int t = dp[i][k] + dp[k + 1][j] + p[i - 1] * p[k] * p[j];
				if (t < dp[i][j])
				{
					dp[i][j] = t;
					s[i][j] = k;
				}
			}
		}
	}
}
void TraceBack(int i, int j)
{
	if (i == j) 
	{
		cout << i;
	}
	else
	{
		cout << "(";
		TraceBack(i, s[i][j]);
		TraceBack(s[i][j] + 1, j);
		cout << ")";
	}
}
int main()
{
	int n; // 矩阵数量
	cin >> n;
	int a, b;
	for (int i = 0; i < n; ++i)
	{
		cin >> a >> b;
		p[i] = a;
	}
	p[n] = b;
	MatrixChain(n);
	for (int i = 1; i <= n; ++i)
	{
		for (int j = 1; j <= n; ++j)
		{
			cout << dp[i][j] << " "; // dp[i][j]的存储矩阵
		}
		cout << endl;
	}
	cout << dp[1][n] << endl;
	TraceBack(1, n);
	return 0;
}
/*测试用例
3
2 3
3 2
2 4

结果：
28
*/

递归

但是不得不说，递归起来解这道题更加简单，一个很基本简单的递归问题，也用到了循环找最优解的那部分思想。

#include<iostream>
using namespace std;
const int NUM = 105;
int p[NUM];
int s[NUM][NUM]; // s[i][j]表示矩阵从i到j的断开处
int dp[NUM][NUM]; // dp[i][j]表示矩阵从i乘到j的最少乘次数
int Recurve(int i, int j)
{
	if (i == j)
	{
		return 0;
	}
	int u = Recurve(i, i) + Recurve(i + 1, j) + p[i - 1] * p[i] * p[j];
	s[i][j] = i;
	for (int k = i + 1; k < j; ++k)
	{
		int t= Recurve(i, k) + Recurve(k + 1, j) + p[i - 1] * p[k] * p[j];
		if (t < u)
		{
			u = t;
			s[i][j] = k;
		}
	}
	dp[i][j] = u;
	return u;
}
void TraceBack(int i, int j)
{
	if (i == j) 
	{
		cout << i;
	}
	else
	{
		cout << "(";
		TraceBack(i, s[i][j]);
		TraceBack(s[i][j] + 1, j);
		cout << ")";
	}
}
int main()
{
	int n; // 矩阵数量
	cin >> n;
	int a, b;
	for (int i = 0; i < n; ++i)
	{
		cin >> a >> b;
		p[i] = a;
	}
	p[n] = b;
	Recurve(1, n);
	for (int i = 1; i <= n; ++i)
	{
		for (int j = 1; j <= n; ++j)
		{
			cout << dp[i][j] << " "; // dp[i][j]的存储矩阵
		}
		cout << endl;
	}
	cout << dp[1][n] << endl;
	TraceBack(1, n);
	return 0;
}
/*
3
2 3
3 2
2 4
*/

备忘录优化

如果搜索到i j ，就不妨把这个数据直接查找，因为dp[i][j]本身就是存储数值的，如果之前已经存储了，没必要进行多余的操作，又叫记忆化搜索。
代码只加了一步判断，能节省许多时间。

int Recurve(int i, int j)
{
	if (dp[i][j] > 0)
	{
		return dp[i][j];
	}
	if (i == j)
	{
		return 0;
	}
	int u = Recurve(i, i) + Recurve(i + 1, j) + p[i - 1] * p[i] * p[j];
	s[i][j] = i;
	for (int k = i + 1; k < j; ++k)
	{
		int t= Recurve(i, k) + Recurve(k + 1, j) + p[i - 1] * p[k] * p[j];
		if (t < u)
		{
			u = t;
			s[i][j] = k;
		}
	}
	dp[i][j] = u;
	return u;
}