一、动态规划的简单介绍
1. 动态规划的定义：
动态规划，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。
2. 动态规划的特征：
重叠子问题、最优子结构、无后效性
最优子结构是指一个问题的最优解如果包含其子问题的最优解，则这个问题具有最优子结构。
无后效性的定义是某阶段的状态一旦确定，则此后过程的演变不再受此前各种状态及决策的影响。
判断一个问题适不适合用动态规划解决，可以判断问题是不是具有以上3种特征。具有则适合用动态规划方法解决。
3. 解决动态规划问题的步骤：
a. 确定子问题
b.确定状态转移方程
c.确定边界条件
二、矩阵链相乘案例：
1. 题目：
给定n个矩阵序列，(A1,A2,A3,A4,...,An). 计算他们的乘积：A1A2A3...An，求使得乘法次数最小的代价方法
由于矩阵的乘法运算符合结合律，因而可以通过调整计算顺序，从而降低计算量。
示例：
输入p = [5, 10, 3, 12, 5]，即: A1 为 5*10的矩阵，A2为10*3的矩阵， A3为3*12的矩阵，A4为12*5的矩阵，求A1*A2*A3*A4 的最小代价方法。
输出为：最优计算代价：405
最优方案为：((A1A2)(A3A4))
2. 分析：
A1*A2*A3*A4可化为A1~4。
m[i,j]表示Ai一直到Aj相乘的乘法最小次数。
Ai~j可化为Ai~j = Ai~k * Ak~j。其中i<k<j
则m[i,j] = m[i,k]+m[k+1, j]+pi-1*pk+pj
针对示例来说：m[1,4]=m[1, 3]+m[3, 4]+p0*p3*p4=m[1,2]+m[2,4]+p0*p2*p4=m[1,1]+m[1,4]+p0*p1*p4
所以转化为求m[i,j]的问题。
使用前要确定这个问题是不是适合动态规划，即有没有重叠子问题，有没有最优子结构，有没有无后效性质。
a. 有没有重叠子的问题
A1*A2*A3*A4有A1(A2(A3A4))、A1((A2A3)A4))、(A1A2)(A3A4)、A1A2A3A4四种方案
分析过程：
可以看到其中有很多的重叠子。比如 A1*A2，A3A4等等
b. 有没有最优子结构
m[i,j] = m[i,k]+m[k+1, j]+pi-1*pk+pj
m[i,j]的最优解，需要求m[i,k]的最优解和m[k+1, j]的最优解，所以是包含子问题的最优解的
所以具有最优子结构
c. 有没有无后效性
m[i,k]的最优解确定后，无论其他的最优解怎么变化，m[i,k]的最优解是不变的。
综上此问题可以使用动态规划问题解决。
3. 解决步骤：
a. 确定子问题 m[i,j]
b.明确状态，明确选择，确定状态转移方程 m[i,j] = m[i,k]+m[k+1, j]+pi-1*pk+pj
c.确定计算顺序及边界条件 m[i,i] = 0
最优子问题m[i,j]的每一步结果都要存储的话，最适合的存储结构是二维数组。
可以看出，计算顺序最适合的方式是：先求第一条对角线上的解，在求第二条对角线上的解，最后求第三条对角线上的解。因为这样，前边的问题都已经有了计算结果
4. 代码：
'''
matrixChain方法：
设置i为行号，j为列号,n为矩阵个数，目标求m[i，j]
i的取值范围0～n-1，j的取值范围0～n-1
求解顺序，先求第一条对角线上的，在求第二条对角线上的，以此类推，直到最后一条对角线
对角线d的取值范围0～n-1
在每个对角线上，i，j，d之间的关系为 j=i+d
a. 确定对角线d
b. 确定i
c. 确定j
d. 确定k
m 记录的是乘法次数最小的次数
s 记录的是最优解对应的k值
getFun方法：获取最优解的括号位置
同样是一个动态规划问题
s[i,j]记录的是AiAj最优解时k的值
同样以k做为区分点，s[i,k]记录的是AiAk的最优解时对应的k值， s[k+1,j]记录的是Ak+1Aj的最优解时对应的k值
k = s[i-1][j-1]
边界条件，i = j, 意味着就是一个矩阵，故可以直接返回Ai
'''
def matrixChain(p):
num = len(p) - 1
m = [[0] * num for _ in range(num)]
s = [[0] * num for _ in range(num)]
for d in range(1, num):
for i in range(1, num-d+1):
j = i + d
m[i - 1][j - 1] = 9999999999
for k in range(i, j):
template = m[i-1][k-1] + m[k][j-1] + p[i-1]*p[k]*p[j]
if template < m[i-1][j-1]:
m[i-1][j-1] = template
s[i-1][j-1] = k
return m, s
def getFun(s, i, j):
if i == j:
print("A" + str(i), end="")
else:
print("(", end="")
getFun(s, i, int(s[i-1][j-1]))
getFun(s, int(s[i-1][j-1])+1, j)
print(")", end = "")
p = [5, 10, 3, 12, 5]
res, s = matrixChain(p)
print(res)
print(s)
getFun(s, 1, 4)
5. 复杂度
时间复杂度：计算代价的时间：三层循环 O(n^3)
构造最优解的时间：O(n)
总的时间复杂度:O(n^3)
空间复杂度：使用了两个数组，需要空间2*O(n^2)，即O(n^2)
