四道简单DP

　　DP类题目找到子问题（状态），然后找到转移方程，就OK

#dp

#likes matrixchain

#according to two point's distance to recurrence

class Solution:

    # @return a string

    def longestPalindrome(self, s):

        length = len(s)

        p = [[0 for col in range(length)] for row in range(length)]

        for i in range(len(s)):

            p[i][i] = 1

            if(i<(length-1) and s[i] == s[i+1]):

                maxlenth = 2

                p[i][i+1] = 1

                start = i

        for i in range(3,length+1):

            for j in range(length-i+1):

                k = j + i - 1

                if(s[j]==s[k] and p[j+1][k-1] == 1):

                    maxlenth = i

                    p[j][k] = 1

                    start = j

        return s[start:start+maxlenth]





if __name__ == '__main__':

    s = Solution()

    test_str = 'abcba'

    print s.longestPalindrome(test_str)

#dp least number coins

#one:overlapping subproblem

#two:optimal substructure

class Solution:

    # @return a string

    def least_number_coin(self, s, v):

        #first initialization

        min_number = [1000000]*(s+1)

        min_number[0] = 0

        #And then,recurrence

        #time need O(n^2),and additional time O(n) to save the subproblem's temp solution

        for i in range(1,s+1):

            for j in range(len(v)):

                print i,v[j]

                if(v[j]<=i and (min_number[i-v[j]]+1 < min_number[i])):

                    min_number[i] = min_number[i-v[j]]+1

        print min_number

        return min_number[s]

if __name__ == '__main__':

    s = Solution()

    money = 11

    v = [1,3,5]

    print s.least_number_coin(money,v)

#dp

#time O(n^2),addtional O(n) to save temp result

class Solution:

    # @return a string

    def LIS(self,v):

        print v

        d = [1]*(len(v))

        print d

        for i in range(len(v)):

            for j in range(i):

                print i,j

                if (v[j]<=v[i] and d[j]+1>d[i]):

                    d[i] = d[j]+1

        print d

        print max(d)

if __name__ == '__main__':

    s = Solution()

    v = [5,3,4,8,6,7]

    s.LIS(v)

#dp

class Solution:

    # @return a string

    def max_number_apples(self, apples, n, m):

        print apples

        s = [[0 for col in range(m)] for row in range(n)]

        for i in range(n):

            for j in range(m):

                if(i==0 and j==0):

                    s[i][j] = apples[0][0]

                elif(i==0 and j>0):

                    s[i][j] = s[i][j-1]+apples[i][j]

                elif(j==0 and i>0):

                    s[i][j] = s[i-1][j] + apples[i][j]

                else:

                    if(s[i-1][j]>s[i][j-1]):

                        s[i][j] = s[i-1][j] + apples[i][j]

                    else:

                        s[i][j] = s[i][j-1] + apples[i][j]

        print s

        return s[n-1][m-1]

if __name__ == '__main__':

    s = Solution()

    n = 3

    m = 4

    apples = [[0 for col in range(m)] for row in range(n)]

    k = 1

    for i in range(n):

        for j in range(m):

            apples[i][j] = k

        k = k + 1

    s.max_number_apples(apples,n,m)

　　one:initialization（初始化）

　　two:recurrence（递推）

　　多项式时间，需要额外的存储空间