最最最牛逼的算法：动态规划

1.寻找不相邻元素的最大和

<递归版本>

def recv_opt(array, i):
    """
    这里面的递归出口是0/1
    递归关系是
    max(recv_dp(array, i - 2) + array[i],
        recv_dp(array, i - 1))
    :param array: 数组
    :param i: 里面长度
    :return: 最大值
    """
    if i == 0:
        return array[0]
    elif i == 1:
        return max(array[0], array[1])
    else:
        A = recv_opt(array, i - 2) + array[i]
        B = recv_opt(array, i - 1)
        return max(A, B)


array = [1, 2, 4, 1, 7, 8, 3]
print(recv_opt(array, len(array) - 1))

 <动态规划版本>

import numpy as np
arr = [1,2,4,1,7,8,3]
# arr = [4,1,1,9,1]
def dp(arr):
    opt = np.zeros(len(arr))
    opt[0]=arr[0]
    opt[1]=max(arr[0],arr[1])
    for i in range(2,len(arr)):
        A = opt[i-2]+arr[i]
        B = opt[i-1]
        opt[i] = max(A,B)
    return opt[len(arr)-1]
print(dp(arr))
"""
15.0
"""

 2.最大连续子序列和

思路：对于arr[i],要么为单独为max，要么前面开始的某一段到arr[i].

转移方程为：
    dp[i] = max{arr[i],dp[i-1]+A[i]}
出口为：
    dp[0] = arr[0]

# 最大连续子序列和
def max_sum(arr):
    dp = []
    dp.append(arr[0])
    for i in range(1, len(arr)):
        dp.append(max(arr[i], dp[i - 1] + arr[i]))
    return dp


arr = [-2, 11, -4, 13, -5, -2]
print(max_sum(arr))

 3.最长公共子序列

思路：。。。

import numpy as np


def LCS(str1, str2):
    dp = np.zeros((len(str1) + 1, len(str2) + 1))
    for i in range(1, len(str1) + 1):
        for j in range(1, len(str2) + 1):
            if str1[i - 1] == str2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    return dp


print(LCS("abcbdab", "bdcaba"))
"""
[[0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 1. 1. 1.]
 [0. 1. 1. 1. 1. 2. 2.]
 [0. 1. 1. 2. 2. 2. 2.]
 [0. 1. 1. 2. 2. 3. 3.]
 [0. 1. 2. 2. 2. 3. 3.]
 [0. 1. 2. 2. 3. 3. 4.]
 [0. 1. 2. 2. 3. 4. 4.]]
"""