动态规划3

# -*- coding:utf-8 -*-

# 基本概念
'''
Dynamic programming的一般步骤：

1 将原命题分解为子命题
    把原命题分解为若干个子命题，子命题和原命题形式相同或者相似，只不过规模变小了。
    子命题解决，原命题即解决
    子命题一旦被求出就会保存，所以自命题只会求解一次

2 确定状态：
    用动态规划解决问题时，往往将和子命题相关的各个变量的一组取值称之为：状态
    一个状态对应于一个或者多个子问题
    某个状态下的值：就是这个状态所对应的子问题的解
    所有状态的集合，构成问题的状态空间。
    状态空间的大小，于用动态规划解决问题的时间复杂度直接相关。
    整个问题的时间复杂度是： 状态数目 * 计算每个状态所需要的时间

3 确定一些初始状态（边界状态）的值

4 确定状态转移方程（这是递推公式，可不是递归哈！！！）
    定义出什么是状态以及状态下的值后，就要找出不同状态之间如何迁移---即如何从一个或者多个值已知的状态，
    求出另一个状态的值。
    状态迁移方程可以用递推公式表示，即状态状态转移方程


＃　能用dynamic programming解决的问题的特点

1 该问题具有最优子结构性质：
    如如果问题的最优解所包含的子问题的解也是最优的
2 无后效性
    当前的若干状态值一旦确定，这此后过程的演变就只和这若干个状态的值有关，
    和之前采取哪种手段或者经过哪条路径演变到当前的这若干个状态，没有关系

# for example

数字三角形：
               7
             3   8
           8   1   0
         2   7   4   4
        4  5   2   6   5
question:
    数字三角形中寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或 右下走。
    只需要求出这个最大和即可，不必给出具体路径。 三角形的行数大于1小于等于100，数字为 0 - 99
input:
    输入格式：
    5      //表示三角形的行数    接下来输入三角形
    7
    3   8
    8   1   0
    2   7   4   4
    4   5   2   6   5
output:
    最大和

Analysis:
    首先，肯定得用二维数组来存放数字三角形

    然后我们用D( r, j) 来表示第r行第 j 个数字(r,j从1开始算)

    我们用MaxSum(r, j)表示从D(r,j)到底边的各条路径中，最佳路径的数字之和。

    因此，此题的最终问题就变成了求 MaxSum(1,1)

    当我们看到这个题目的时候，首先想到的就是可以用简单的递归来解题：

'''
#　逻辑，初级－－－递归
class Solution:
    def MaxSum(self, r, j):
        if r == N:
            return D[r][j]
        else:
            x = self.MaxSum(r+1, j)
            y = self.MaxSum(r+1, j+1)
            return max(x, y) + D[r][j]
# 超时！！！有太多的重复计算
#　就拿第三行数字1来说，当我们计算从第2行的数字3开始的MaxSum时会计算出从1开始的MaxSum，
# 当我们计算从第二行的数字8开始的MaxSum的时候又会计算一次从1开始的MaxSum，也就是说有重复计算。

# 中级 ---记忆型递归 if maxSum[r][j] != -1:return maxSum[r][j]
class Solution:
    maxSum[r][j] = -1
    def MaxSum(self, r, j):
        if maxSum[r][j] != -1:
            return maxSum[r][j]
        if r == N:
            maxSum[r][j] = D[r][j]
        else:
            x = self.MaxSum(r+1, j)
            y = self.MaxSum(r+1, j+1)
            maxSum = max(x, y) + D[r][j]
        return maxSum
# AC了，但是不能满足，因为递归总是需要大量堆栈上的空间，容易造成栈溢出，我们现在要考虑：
# 如何把  递归--->递推

'''
首先需要计算的是最后一行，因此可以把最后一行直接写出
    7
    3   8
    8   1   0
    2   7   4   4
    4   5   2   6   5     4   5   2   6   5
 现在开始分析倒数第二行的每一个数，现分析数字2，2可以和最后一行4相加，也可以和最后一行的5相加，但是很显然和5相加要更大一点，结果为7，我们此时就可以将7保存起来，然后分析数字7，7可以和最后一行的5相加，也可以和最后一行的2相加，
 很显然和5相加更大，结果为12，因此我们将12保存起来。以此类推。。我们可以得到下面这张图
    7
    3   8
    8   1   0
    2   7   4   4         7   12  10  10
    4   5   2   6   5     4   5   2   6   5
然后按同样的道理分析倒数第三行和倒数第四行，最后分析第一行，我们可以依次得到如下结果：
    7                     30
    3   8                 23  21
    8   1   0             20  13  10
    2   7   4   4         7   12  10  10
    4   5   2   6   5     4   5   2   6   5
理解之后我们就可以写出如下的递推型动态规划程序：
'''
# 高级----递推型动态规划
class Solution:
    def MaxSum(self, r, j):
        for r in range(1,N+1):
            maxSum[N][j] = D[N][j]
        for r in range(1, N, -1): # 注意这里是从N-1行开始循环
            for j in range(1, i+1):
                maxSum[r][j] = max(maxSum[i+1][j], maxSum[r+1][j+1]) + D[r][j]

#　终极版－－－递推型＋节省空间
'''
其实完全没必要用二维maxSum数组存储每一个MaxSum(r,j),只要从底层一行行向上递推，
那么只要一维数组maxSum[100]即可,即只要存储一行的MaxSum值就可以。
    7
    3   8
    8   1   0
    2   7   4   4
    4   5   2   6   5     7   5   2   6   5
    
    7
    3   8
    8   1   0
    2   7   4   4
    4   5   2   6   5     7   12   10   10   5
    
    7
    3   8
    8   1   0
    2   7   4   4
    4   5   2   6   5     20   13   10   10   5

    7
    3   8
    8   1   0
    2   7   4   4
    4   5   2   6   5     23   21   10   10   5
    
    7
    3   8
    8   1   0
    2   7   4   4
    4   5   2   6   5     30   21   10   10   5
进一步考虑，我们甚至可以连maxSum数组都可以不要，直接用D的第n行直接替代maxSum即可。
但是这里需要强调的是：虽然节省空间，但是时间复杂度还是不变的。
'''
class Solution:
    def MaxSum(self, r, j):
        maxSum = D[j]  # 直接用D的第n行直接替代maxSum即可
        for r in range(1, N):
            for j in range(1, r+1):
                maxSum[j] = max(maxSum[j], maxSum[j+1]) + D[r][j]