算法专题：DP（1）

  DP即Dynamic Programming，按照wiki上面的解释， dynamic programming  (also known as  dynamic optimization ) is a method for solving a complex problem by breaking it down into a collection of simpler subproblems, solving each of those subproblems just once, and storing their solutions - ideally, using a memory-based data structure.这里关键词有两个，一个是subproblem，一个是 memory-based，大概意思就是把复杂问题拆分为若干子问题，然后储存子问题的值用以未来的计算。
  但是仅仅这样还不够， There are two key attributes that a problem must have in order for dynamic programming to be applicable:  optimal substructure  and  overlapping sub-problems . If a problem can be solved by combining optimal solutions to  non-overlapping  sub-problems, the strategy is called " divide and conquer " instead. This is why  merge sort  and  quick sort  are not classified as dynamic programming problems. Optimal substructure  means that the solution to a given optimization problem can be obtained by the combination of optimal solutions to its sub-problems. Overlapping  sub-problems means that the space of sub-problems must be small, that is, any recursive algorithm solving the problem should solve the same sub-problems over and over, rather than generating new sub-problems. 意思就是能用最优的子问题得到最优的总问题，然后就是子问题之间要是相重叠 的。

  光看概念挺玄乎，这是因为DP的覆盖范围其实很大，而在Leetcode算法题和各种面试里遇到的DP问题，大部分都是一个套路，那样就好总结多了。根据个人经验，DP套路如下：
1.首先看是不是DP问题，DP一般求的是最优解的结果，不在乎最优解的形状和过程。其实DP在决策的时候也是可以记录如何选择的，不过不知为何做过的题里面一般都不问。
2.然后确定dp[i][j]的含义。一般从二维开始就行了，够用，而且清晰，后面看情况可能还能减少省空间。至于dp[i][j]的含义，一般是（i，j）范围内，题目所要求的东西。
3.确定方向以及写递归公式。其实dp有点像数学归纳法，子问题之前互相推导。方向有自下而上和自上而下，一个方向不好写就换一个，这个和已知边界是在下还是在上也有关系，毕竟是从已知推未知的。
4.有了公式之后，确定边界条件，也就是开始的地方，然后用公式推导出去就可以得出解法。
5.优化。时间上一般没有太多优化的，空间往往可以优化，把dp矩阵从二维降为一维，或者变成几个变量，具体看推导公式要什么东西。
最核心的还是推导公式。
下面通过看一些例题来具体说明：
1.斐波拉契数列。   0, 1, 1, 2, 3, 5, 8……每一个都是之前两项的和，求第n项的值（例如，第1项是0）。
【解】最基础的dp问题，很直观的可以用一维数组来表达：dp[i]=dp[i-2]+dp[i-1]，dp[i]很自然就是index为i的 斐波拉契数列值。初始边界自然就是最开始的两个数。优化方面，由于只需要最近的两个值，所以可以省掉dp数组：
# T:O(n)

# S:O(1)
class example1:
    def Fibonacci(self, n):
        # @param n: int
        # @return int
        if n == 1:
            return 0
        if n == 2:
            return 1
        n_2,n_1 = 0,1
        for _ in range(2, n):
            temp = n_1 + n_2
            n_2, n_1 = n_1, temp
        return temp

if __name__ == "__main__":

     print (example1().Fibonacci( 10 ))  #34  

2.路径数目。假设现在有mxn的矩阵，一个机器人要从左上角走到右下角，每次只能走一步，每一步只能向右一格或者向下一格，求所有的不同路径数目。 
【解】说实话这道题排列组合就能做，也是很基础的dp问题。
根据之前说的套路，我们假设dp[i][j]就是从起点到(i,j)这个点的不同路径数目。
那么就要推导递推公式了，一般而言只要dp值的概念对了，方向对了，推导一般也不会很难。这里既然只能向右和向下，那么自然一个点只能是从上方到或者从左方到，路径数也是之前两个的和：
dp[i][j] = dp[i-1][j]+dp[i][j-1]
然后考虑边界问题。很明显，机器人一直沿两条边走的话路径数都是1，即dp[i][0]=dp[0][j]=1.
最后就是优化了。按照之前的思路我们需要一个二维的数组，但看上去在公式里面我们只用到了两个参数，是不是可以像上面那样只用两个变量呢？
答案是否定的，画一画就知道，因为牵扯到行列，之前的值其实也需要存储。由此也得出一个经验式的结论：优化一般降一维。 
降一维就是滚动dp了，可以想象有一行dp数组，依行滚动来计算。
# T:O(n^2)
# S:O(n)
class example2 :
     def countPath ( self ,  m ,  n):
         # @param int m,n
        # @return int
         if not  m * n:
             return  0
         rolling = [ 1 ] * n
         for _   in  range ( 1 ,  m):
             for  j  in  range ( 1 ,  n):
                rolling[j] += rolling[j- 1 ]
         return  rolling[- 1 ]

if  __name__ ==  "__main__" :
       print (example2().countPath( 4 , 3 ))  #10  

3.抢劫问题。假设有一排房屋，每间房里面有一些数目的钱，用数组n表示。假设你是强盗，晚上去抢这些房屋，但是如果两间相邻的房间都被抢，警报设施就会报警。求在不惊动警报设置的情况下能抢到的最大金额数目。
【解】这道题就没有之前那么明显的dp痕迹了，所以说判断什么问题用dp也是有技巧的。这道题求最优值，明显子问题之间有联系，dp很合适。
然后确定dp含义。直指要害，就设dp[i][j]是在房屋i和j之内能弄到的最多的钱。这道题由于可以认为是从左边开始的，因此这里就可以省掉一维，dp[i]就是从左边到房屋i之内弄到的最多的钱。
然后就是公式了。这个比之前又难了一点点。面对一间房屋只有两种选择抢还是不抢，因此问题就清楚了：假设之前一间抢了，这间就不能抢，否则抢。亦即dp[i] = max(dp[i-2]+n[i], dp[i-1]) 
可能这里会有疑问，有没有可能可以抢但是不抢，最后结果更优呢？
这个问题主要是弄清楚我们现在研究的问题，这里研究的是范围内的dp的解，在这个范围内就是最优的，至于范围外的东西，那个由以后的dp负责。例如8,4,5,8，全局来看当然选择两个8，dp的时候到5了，这时候看不到后面的8，因此这时候845的最优解是13。等到了8，就会发现之前的选择更优，还是能找到最优解。
优化：类似于问题1，用几个变量代替数组。
# T:O(n)
# S:O(1)
class example3 :
     # @param num, a list of integer
    # @return an integer
     def rob ( self ,  num):
         if  len (num) ==  0 :
             return  0

         if  len (num) ==  1 :
             return  num[ 0 ]

        num_i ,  num_i_1 =  max (num[ 1 ] ,  num[ 0 ]) ,  num[ 0 ]
         for  i  in  range ( 2 ,  len (num)):
            num_i_1 ,  num_i_2 = num_i ,  num_i_1
            num_i =  max (num[i] + num_i_2 ,  num_i_1);

         return  num_i

if  __name__ ==  '__main__' :
           print (example3().rob([ 8 , 4 , 8 , 5 , 9 , 6 , 5 , 4 , 4 , 10 ]))  #40