京东NLP课程之动态规划

1、找零问题
假设有多枚硬币（例如1、3、5），为达到目标值（例如23），求最少需要多少硬币数，若无论如何组合都达不到该目标值就返回-1。
解题思路：
首先思考如何得到dp(n)

代码实现如下：

def solution1(v: [int], t: int):
    dp = [0, ]  # dp[i]表示目标值为i时，硬币总数
    for n in range(1, t+1):
        tmp = -1
        for coin in v:
            if n >= coin and dp[n-coin] >= 0:
                if tmp == -1:
                    tmp = dp[n-coin] + 1
                else:
                    tmp = min(dp[n-coin]+1, tmp)
        dp.append(tmp)
    return dp[-1]

v = [1, 3, 5]
t = 23
print(solution1(v, t))

v表示硬币的类型有哪些，t为目标值。在一个for循环中，就是要获得目标值为n时，最少需要的硬币数，为dp[n]。

2、背包问题-1
假设背包的容量是m（例如9kg），已知有一堆物品的容量（例如分别是2、6、4、3kg），使用的物品数量不限，求能容纳的最大容量？
解题思路：
其实和题1差不多
代码如下：

def solution2(weight_list: [int], capacity: int):
    dp = [0, ]  # dp[i]表示容量为i的背包所能装的最大值
    for n in range(1, capacity+1):
        dp.append(dp[-1])
        for weight in weight_list:
            if n >= weight:
                dp[n] = max(dp[n], dp[n-weight]+weight)
                if dp[n] == n:
                    break
    return dp[-1]


v = [2, 2, 4, 6, 3]
t = 9
print(solution2(v, t))

在这里需要注意的是，dp[n]<=n，所以在第二个循环内可以做一个判断；还有dp[n]>=dp[n-1]。

3、背包问题-2
假设背包的容量是，已知有一堆物品的容量以及对应的价值，使用的物品数量不限，求背包能装入的最大价值？
解题思路：
其实和题2差不多，只是评价的指标从容量变成了价值，限制是容量，评价指标是价值
代码如下：

def solution3(weight_list: [int], value_list: [int], capacity: int):
    assert len(weight_list) == len(value_list)
    dp = [0, ]  # dp[i]表示容量为i的背包所能装的最大价值
    for n in range(1, capacity+1):
        dp.append(dp[-1])
        for i in range(len(weight_list)):
            if n >= weight_list[i]:
                dp[n] = max(dp[n], dp[n-weight_list[i]]+value_list[i])
    return dp[-1]

weight_list = [2, 3, 4]
value_list = [3, 4, 5]
t = 9
print(solution3(weight_list, value_list, t))

4、背包问题-3
假设背包的容量是，已知有一堆物品的容量以及对应的价值，使用的物品数量有限，求背包能装入的最大价值？
解题思路：
其实和题3差不多，只是使用的物品有限
代码如下：

def solution4(weight_list: [int], value_list: [int], capacity: int):
    assert len(weight_list) == len(value_list)
    dp = [0, ] * (capacity + 1)  # dp[i]表示容量为i的背包所能装的最大价值
    for i in range(len(weight_list)):
        for n in range(capacity, 0, -1):
            if n >= weight_list[i]:
                dp[n] = max(dp[n], dp[n-weight_list[i]] + value_list[i])
    return dp[-1]


weight_list = [3, 2, 1, 1, 4]
value_list = [5, 2, 4, 2, 10]
t = 8
print(solution4(weight_list, value_list, t))

第二个循环必须要逆序。

5、有一个二维数组，比如下图，从左上角到达右下角的最短路径是多少？
1 3 5 9
2 1 3 4
5 2 6 7
6 8 4 3
解题思路：
不考虑边界条件，状态转移方程如下，其中，dp[i][j]表示到达i,j位置的最短路径，matrix表示原始的维数组。代码如下：

def solution5(matrix: [[int]]):
    line = len(matrix)
    col = len(matrix[0])
    dp = [0, ] * col
    for i in range(0, line):
        dp[0] += matrix[i][0]
        for j in range(1, col):
            dp[j] = min(dp[j-1], dp[j]) + matrix[i][j]
    return dp[-1]

matrix = [[1, 3, 5, 9],
          [2, 1, 3, 4],
          [5, 2, 6, 7],
          [6, 8, 4, 3]]
print(solution5(matrix))

可以用一个一维dp数组来存储二维dp数组的内容。

6、编辑距离
有两个字符串，如果对其中某个字符进行修改，让这个字符变成另一个字符，修改的方式包括增、删、改，请问最少的修改次数是多少？
解题思路：
递归方程如下

其中，flag=0 if A[i]==B[j] else 1
MED(A,i,B,j)表示分析A的第i个字符、B的第j个字符是，最少的编辑距离
代码如下：

def min3(a, b, c):
    a = min(a, b)
    return min(a, c)

def minEditDistanceDP(A, len_A, B, len_B):
    # 对dp进行初始化
    dp = []
    for i in range(len_A+1):
        dp.append([])
        for j in range(len_B+1):
            dp[len(dp)-1].append(0)
    for i in range(0, len_A+1):
        dp[i][0] = i
    for j in range(0, len_B+1):
        dp[0][j] = j

    for i in range(len_A):
        for j in range(len_B):
            if A[i] == B[j]:
                flag = 0
            else:
                flag = 1
            dp[i+1][j+1] = min3(dp[i][j] + flag, dp[i+1][j]+1, dp[i][j+1]+1)
    return dp[len_A][len_B]

7、最长公共子串
有两个字符串，从字符串1中从左往右依次取出若干字符成s1，同样从字符串2中从左往右依次取出若干字符成s2，使得s1与s2一模一样，求s1的最长可能长度？
解题思路：
状态转移方程如下

代码如下：

def MAX(values):
    m = values[0]
    for value in values[1:]:
        if value > m:
            m = value
    return m

def LCS(A, B):
    dp = []
    for _ in range(len(A)):
        dp.append([])
        for _ in range(len(B)):
            dp[-1].append(0)

    for i in range(len(A)):
        for j in range(len(B)):
            flag = 0
            if A[i] == B[j]:
                flag = 1
            dp[i][j] = MAX([dp[i-1][j-1] + flag, dp[i-1][j], dp[i][j-1]])
    return dp[-1][-1]


s = "flaw"
t = "lawn"
print(LCS(s, t))

8、最大连续子序列之和
给定一个数组，寻找连续子数组是的它们的和最大？
解题思路：
假定已知数组是A，B[j]表示以A[j]结尾的最大连续子序列之和，关键是把B[j]和B[j-1]扯上关系，即状态转移方程

另外只需要把初始条件处理下就是了，因为只存在B[j]与B[j-1]的关系，所以就不需要一个数组B来保存中间量了。
代码如下：

def maxCS(arr: [int]):
    if len(arr) == 0:
        return 0
    maxV = arr[0]
    curMaxV = arr[0]
    for i in range(1, len(arr)-1):
        if curMaxV < 0:
            curMaxV = arr[i]
        else:
            curMaxV += arr[i]
        maxV = max(maxV, curMaxV)
    return maxV

l = [1, -1, -2, 3, 5, -1, 4, -2]
print(maxCS(l))