动态规划法及其优化

在很多问题中，动态规划算法是我们的最优选择，比起递归算法，动态规划算法的时间复杂度和空间复杂度都更加优越，可以处理的数据规模更大。但是，动态优化算法的时间复杂度为O（N*V），也就是说，当需要处理的数据规模较大时，使用动态规划算法也存在超时的可能性，因此，我们需要在动态规划的基础上做出优化。

动态规划的优化方法包括：

1. 使用空间换时间：将中间结果缓存在数组中，避免重复计算。

2. 无后效性：假设问题可以分解为若干子问题，某些子问题的解可以不受其他子问题的解的影响，则可以去掉一些不必要的计算。

3. 剪枝：在搜索的过程中，利用一些条件限制最优解的范围，过滤掉不需要搜索的部分，提高性能。

4. 动态规划与贪心算法：当问题可以用贪心算法解决时，应优先使用贪心算法，它的时间复杂度要小于动态规划算法。

5. 构建最优解：利用最优子结构可以减少搜索的规模，进而提高搜索效率。

样例展示

下面用一个具体的样例记录以下动态优化的过程：

题目描述：

代码段：

# 解决0-1背包问题
def knapsack(N, V, w, v):
    # 初始化动态规划表
    dp_table = [[0 for j in range(V + 1)] for i in range(N + 1)]
    # 使用动态规划求解
    for i in range(1, N + 1):
        for j in range(1, V + 1):
            # 如果第i件物品的重量大于背包容量j,则不装入背包
            # 由于weight和value数组下标都是从0开始,故注意第i个物品的重量为w[i-1],价值为v[i-1]
            if w[i - 1] > j:
                dp_table[i][j] = dp_table[i - 1][j]
            else:
                dp_table[i][j] = max(dp_table[i - 1][j], dp_table[i - 1][j - w[i - 1]] + v[i - 1])
    # 返回最大价值
    return dp_table[N][V]
 
if __name__ == '__main__':
    #N：表示题目中物品的总类别
    #count:表明题目中所有物品的总数量
    N, V = map(int, input().split())
    w = []
    v = []
    count = 0
    for i in range(N):
        wi, vi, si = map(int, input().split())
        count += si
        # 物品数量可以大于1，因此循环si次将其加入物品
        for _ in range(si):
            w.append(wi)
            v.append(vi)
    print(knapsack(count, V, w, v))

这段代码在题目规定的时间内完成数据的计算，得到正确的结果。

题目升级：

显然，和上面的题目相比，题干没有任何的变化，只是处理数据的规模变大了，而在处理该规模的数据时，上面的代码显示超时，也就是说，上述动态规划算法需要优化。

优化方法：

1. 空间复杂度优化

# 解决0-1背包问题
def knapsack(N, V, w, v):
    #对原始方法进行优化
    #原始方法使用的是二维数组
    #当物品数量和背包容量较大时，空间复杂度和时间复杂度为O(N*M)，很容易就会导致运行超时
    #这意味着我们可以从动态规划表上去优化这个问题
    
    #根据背包容量声明意味数组
    db = [0 for i in range (V+1)]
    
    #for循环
    for i in range(N):
        #内层for循环为递减循环，且不会遍历到w[i]-1
        for j in range(V,w[i]-1,-1):
            db[j] = max(db[j],db[j-w[i]]+v[i])
            
    return db[V]
 
if __name__ == '__main__':
    #N：表示题目中物品的总类别
    #count:表明题目中所有物品的总数量
    N, V = map(int, input().split())
    w = []
    v = []
    count = 0
    for i in range(N):
        wi, vi, si = map(int, input().split())
        count += si
        # 物品数量可以大于1，因此循环si次将其加入物品
        for _ in range(si):
            w.append(wi)
            v.append(vi)
    print(knapsack(count, V, w, v))

上述代码将状态转移表由二维数组转换为一维数组，降低了代码对空间复杂度的要求，但是不难看出，虽然设置了一定的循环条件，代码的时间复杂度仍然是O(N*M），也就是，运行该题目仍然会超时。问题并没有解决。

两段代码均只能通过13组数据，因此，还需要在运行时间上进行优化。

2. 时间复杂度优化

如何能够降低时间复杂度，我首先想到的是剪纸，通过一定的条件限制，比如二分法，将时间复杂度降维O(NlogM)。

# 解决0-1背包问题
#利用二分法来减少时间复杂度
#首先的前提是输入的物品重量要有序排列，不然二分法进行剪枝没有意义

#1.读取输入数据，需要对物品重量排序，但是又要保证质量与价值之间的对应关系，用一定的数据结构存储最佳
#2.对物品依照质量进行排序
#3.采用二分法实现时间复杂度的降低，编写Knapsack函数

#这种优化时间复杂度的方法确实存在，但是在该问题中，如果需要用到每一次考察物品之后背包的状态，那么这种选择性
#更新状态的方式必然是错误的，因为没有记录每一步更新之后的所有可能状态 ，导致再下一步的状态再不完全的基础上
#获得错误的下一转移状态，最终只会得到一个错误的输出
def knapsack(N, V, w, v):
    #使用单维数组优化
    db = [0 for i in range (V+1)]
    
    #for循环
    for i in range(N):
        # 使用二分搜索算法优化
        left, right = 0, V
        while left <= right:
            mid = (left + right) // 2
            if mid < w[i]:
                left = mid + 1
            else:
                right = mid - 1
            
            db[mid] = max(db[mid],db[mid-w[i]]+v[i])
            print(db)
            
    return db[V]
 
if __name__ == '__main__':
    #N：表示题目中物品的总类别
    #count:表明题目中所有物品的总数量
    N, V = map(int, input().split())
    w = []
    v = []
    count = 0
    for i in range(N):
        wi, vi, si = map(int, input().split())
        count += si
        # 物品数量可以大于1，因此循环si次将其加入物品
        for _ in range(si):
            w.append(wi)
            v.append(vi)
    print(knapsack(count, V, w, v))

代码运行结果：

通过运行结果可以看出，这种方法错误。

---

标记+递归法代码：

def knapsack(N, V, w, v):
    #使用二进制优化的方法
    #因为是0-1背包，每个物品只能选择一次
    #所以每个物品都可以看做一个二进制数
    #声明变量maxval存储最大价值
    maxval = 0 
    #声明变量mask存储选择的物品
    mask = 0 
    #for循环
    #i为index，主要用于定位数组
    for i in range(N):
        #使用按位与运算符&
        if (mask & (1 << i)) == 0:
            #使用按位或运算符|
            if V >= w[i]:
                maxval = max(maxval, v[i] + knapsack(N, V - w[i], w, v))
            mask |= (1 << i)
    return maxval
 
if __name__ == '__main__':
    #N：表示题目中物品的总类别
    #count:表明题目中所有物品的总数量
    N, V = map(int, input().split())
    w = []
    v = []
    count = 0
    for i in range(N):
        wi, vi, si = map(int, input().split())
        count += si
        # 物品数量可以大于1，因此循环si次将其加入物品
        for _ in range(si):
            w.append(wi)
            v.append(vi)
    print(knapsack(count, V, w, v))

这段代码表面上看上去和普通的递归法极为相似，但是实际上却有很大的不同。

普通递归法代码：

#读取物品的数量以及背包的最大容量
N,V = map(int,input().split())

#建立数组存储物品的重量及价值
w=[0]
v=[0]

for i in range(N):
    w_i,v_i = map(int,input().split())
    w.append(w_i)
    v.append(v_i)
    
def knapsack(n,cap):
    #设置递归结束条件
    if n == 0:
        return 0
    #当物品的重量大于背包容量时
    if w[n] > cap:
        return knapsack(n-1,cap)
    return max(knapsack(n-1,cap),knapsack(n-1,cap-w[n])+v[n])

print(knapsack(N,V))

不同之处的分析：

普通递归法：在没有if条件语句的限制下，递归的搜索空间为。加上if语句，可以减少部分分枝，但是当背包容量较大时，if语句所起的限制作用有限，时间复杂度趋近于O()

标记+递归：二进制机制用于标记每个物品状态，放入或者未放入背包。这种情况下，递归的搜索空间被缩小为n!。时间复杂度大大减小。

实质上，这两种算法的区别就是深度优先遍历和广度优先遍历的区别。

但是，标记+递归的时间复杂度还是过高，无法通过题目要求。

---

二进制+动态规划：

#读取第一行输入，n为输入行数（不是物品总数），w为背包容量
n, m = map(int, input().split())

#v物品重量，w表示价值
v, w = [], []

#统计物品数量
cnt = 0

for i in range(1, n + 1):
    #读取输入数据
    a, b, s = map(int, input().split())
    k = 1
    #将同样的物品按照2的指数关系合并成一个更大的物品，主要用于减少物品的数量
    #关于我自己的理解为什么可以直接将多个小的物品合成一个大的物品放入存储队列
    #我开始的疑惑是假设这样一个情景，存在一个极大的物品，将其放入背包后，还剩一点空间可以放入部分小物品
    #但是由于在物品存入队列时，我们直接将小物品合成了大的物品放入，万一存在一种尴尬情况，即可以放入单个小
    #物品，但是不能放入较大的物品，那岂不是达不到价值最优
    #实际上，我假设的这种情况是不存在的，因为在合成物品时，合成的物品是由小到大合并的，所以当有n个小物品时
    #合成的顺序一定是a,2a,4a,8a...,这些合成后的小物品通过各种方式的组合，可以表示a~na之间的任何一个总质量
    while k <= s:
        cnt += 1
        v.append(a*k)
        w.append(b*k)
        s -= k
        k *= 2
        
    if s > 0:
        cnt += 1
        v.append(a * s)
        w.append(b * s)

n = cnt

#一维数组表示状态转移表
f = [0] * (m + 1)
#n经过处理之后，存储队列中总的物品数量
for i in range(1, n + 1):
    #m 背包总容量
    for j in range(m, v[i - 1] - 1, -1):
        f[j] = max(f[j], f[j - v[i - 1]] + w[i - 1])

print(f[m])

该方法通过测试。

总结：对算法进行优化时，需要综合考虑时间和空间复杂度。