动态规划Dynamic Programming(0)——算法介绍

  动态规划(Dynamic Programming)可以用来非常有效的解决许多搜索优化问题。这类问题都有相同的地方,原问题可以分解为子问题,子问题中有重复的部分(overlapping subproblem),或者原问题的最优解与子问题的最优解具有相同的结构(optimal substructure),将规模较小的子问题的最优解扩展为规模较大的问题的最优解。
它之所以有效,是因为它采用自底向上的方式递推求值,并把中间结果存储起来以便以后用来计算所需要求的解。
  动态规划虽然比较容易理解,在应用过程中可以分为两步,先找出子问题的最优结构,然后找出子问题的最优解向规模较大子问题的最优解扩展。但在具体应用中会有各种各样的问题。下面将讨论各种动态规划问题,希望能加深对动态规划的理解。
  动态规划典型问题之一,Feibonaci数列
  f(1)=f(2)=1,f(n)=f(n-1)+f(n-2);
  直接求解,用递归方式,可以方便的写出,

def fib(n):
    if n==1: return 1
    elif n==2: return 1
    else: return fib(n-1)+fib(n-2)

  计算f(5),展开调用过程,如下,
    f(5) = f(4) + f(3)
    = f(3) + f(2) + f(2)+f(1)
    = f(2)+f(1) + f(2) + f(2)+f(1)
  可以看到,计算f(4)的时候会调用f(3),f(4)计算玩之后,又要调用f(3),里面有大量的重复计算。因为是递归调用,如果写成循环,从底向上计算,

def fib(n):
    if n==1: return 1
    elif n==2: return 1
    else:
        f = [1 for i in xrange(n)]
        for i in xrange(2,n):
            f[i]=f[i-1]+f[i-2]
        return f[n-1] 

  存储空间为n个,实际上,计算f(n)时只与前两项n-1和n-2相关,没有必要保存n项,所以代码可以简化如下,

def fib(n):
    n2, n1 = 0, 1
    for i in range(n-2): 
        n2, n1 = n1, n1 + n2
    return n2+n1

  这里定义了n=0时f(0)=0,参考http://20bits.com/article/introduction-to-dynamic-programming

  Feibonaci数列问题,子问题有很多重复,换为自底向上计算,避免很多重复,计算效率提高。对于最优子结构的问题,可以以整数序列子序列最大和的问题为例,这里与刚才的一篇参考重合,不过还是这个例子比较好说明,就它了。

  整数子序列最大和问题
  给定一个整数序列,找出子序列的最大和。例如array=[1,2,-5,4,7,-2],我们可以直接看出,子序列最大和为4+7=11,那么计算机怎么求解呢?
求出所有子序列的和?子序列个数n(n+1)/2=sum(i,i=1,..n),复杂度n^2。

  代码如下,

def msum(a):
    return max([(sum(a[j:i]), (j,i)) for i in range(1,len(a)+1) for j in range(i)])

  有没有简单一点的方法呢?
  动态规划。如果使用动态规划,要求n的解,从n-1的解扩充到n的解。如果知道n-1个数中最大子序列的和,增加一个数到n个数,最大子序列的和是什么呢?如果考虑这增加的一个数a[n],如果a[n]>=0,那么可以认为是增加和,那么最大子序列应该加上这个数。但是如果前n-1个数的最大子序列的和对应的子序列与a[n]不连续,那么怎么办呢?
换个角度考虑。如果考虑前n-1项最大子序列的和sum,如果sum<0,那么与后面的数相加,就会使最大子序列的和减小。
例如,a[j:k]是序列a[j:i]的最优子序列,s是最优子序列的和,t是a[j:i]的和,那么考虑下一个元素a[i+1],如果t+a[i+1]>=s,那么a[j:i+1]应该作为最优子序列,s=t+a[i+1],t=s;然而,如果t+a[i+1]<0,那么a[j:i+1]就不应该在最有子序列中,因为它会使子序列的和减少,所以此时,t=0,从下一个元素开始,对a[i+2:n],解新的问题。需要注意的是,s还是继续,保存最优子序列的和。
  代码如下,

def msum2(a):
    bounds, s, t, j = (0,0), -float('infinity'), 0, 0
    
    for i in range(len(a)):
        t = t + a[i]
        if t > s: bounds, s = (j, i+1), t
        if t < 0: t, j = 0, i+1
    return (s, bounds)

  参考链接里的代码又被我搬过来了,看着有写好的代码,自己就没有写的动力了。
  使用动态规划算法的时间复杂度为O(n),只要对序列扫描一遍就可以了。

  从这两个典型问题,可以看出动态规划问题的要义,把大问题化为小问题,在计算小问题的时候,避免重复计算,从小问题的解扩展到大问题的解的时候,要搞明白如何扩展,搞明白子问题的最有子结构是什么。
  动态规划的思想虽然已经理解了,但遇到具体的问题的时候,又会有各种问题,所以我想尽可能多的列举动态规划问题,并给出解答。动态规划系列从这一篇开始,之后各种例题。

 

posted @ 2012-04-27 22:47  Frandy.CH  阅读(728)  评论(0编辑  收藏  举报