动态规划算法深度解析：0-1背包问题（含完整流程）

简介：

0-1背包问题是经典的组合优化问题：给定一组物品（每个物品有重量和价值），在背包容量限制下选择物品装入背包，要求总价值最大化且每个物品不可重复选取。

动态规划核心思想

通过构建二维状态表dp[i][j]，记录前i个物品在容量j时的最大价值，通过状态转移方程逐步推导最优解，避免重复计算子问题。

问题建模与参数定义

static final Integer N = 4;       // 物品数量
static final Integer W = 5;       // 背包容量
Integer[] w = {0,1,2,3,4};        // 物品重量数组（索引0占位）
Integer[] v = {0,2,4,5,6};        // 物品价值数组
private Integer[][] table = new Integer[N+1][W+1]; // DP状态表

代码执行全流程解析

1. 初始化阶段 init()

for(int i=0;i<=N;i++) {
    for(int j=0;j<=W;j++) {
        table[i][j]=0;
    }
}

🔍 执行过程：

1. 创建(N+1)行×(W+1)列的二维数组
2. 初始化边界条件：
   • table[0][j] = 0（无物品可装）
   • table[i][0] = 0（无容量可用）

┌───────────────┐
│  Start Init  │
└───────┬───────┘
        │
┌───────▼───────┐
│ i=0 to N     │
├───────┬───────┤
│ j=0 to W     │
├───────▼───────┤
│ table[i][j]=0 │
└───────┬───────┘
        │
┌───────▼───────┐
│ End Init      │
└───────────────┘

2. 动态规划核心 dynamics()

for(int i=1;i<=N;i++) {          // 物品维度
    for(int j=1;j<=W;j++) {      // 容量维度
        // 不选当前物品
        table[i][j] = table[i-1][j]; 
        // 选当前物品（需容量足够）
        if(j >= w[i]) {
            table[i][j] = max(
                table[i][j], 
                table[i-1][j-w[i]] + v[i]
            );
        }
    }
}

📊 状态转移矩阵演变：

迭代过程示例（i=2时）：
  容量 j | 0 1 2 3 4 5
i=0     | 0 0 0 0 0 0
i=1     | 0 2 2 2 2 2 
i=2     | 0 2 max(2,2+4)=6 ...

完整流程图与时序图

系统级流程图

时序图

复杂度深度分析

时间复杂度：

• 双重循环：O(N*W) = 4×5 = 20次核心计算
• 计算过程：

Σ(i=1→4) Σ(j=1→5) [1次比较 + 1次查询] = 4×5×2 = 40次操作

空间复杂度：

• 二维数组存储：O(N*W) = 5×6 = 30个存储单元
• 空间消耗分解：

基础类型Integer × 30 = 30×4 bytes = 120 bytes

完整代码

public class Knapsack {

    /*
     * 假设有背包中可以最多可以装4个产品；背包承受的最大容量为5，求该背包最大的价值为多少
     * N：为物品数量
     * W：为背包容量
     * w[]:表示每一个产品容量
     * v[]:表示每一个产品的价值
     *
     * */
    static final Integer N =4;
    static final Integer W= 5;
    Integer[] w =new Integer[]{0,1,2,3,4};
    Integer[] v= new  Integer[]{0,2,4,5,6};
    private Integer[][] table = new  Integer[N+1][W+1];

    void  init(){
        for(int i=0;i<=N;i++){
            for(int j=0;j<=W;j++){
                table[i][j]=0;
            }
        }
    }
    void print(){
        for(int i=0;i<=N;i++){
            for(int j=0;j<=W;j++){
                System.out.print(table[i][j]+"   ");
            }
            System.out.println();
        }
    }
    void dynamics(){
        for(int i=1;i<=N;i++){

            for(int j=1;j<=W;j++){

                table[i][j]=table[i-1][j]; // 不选第i个物品
                if(j>=w[i]){// 选第i个物品
                    table[i][j]=max(table[i][j],table[i-1][j-w[i]]+v[i]);
                }

            }
        }
    }
    // 判断大小的方法
    Integer max(Integer value1,Integer value2){
        return value1>value2?value1:value2;
    }


    public static void main(String[] args) {
        Knapsack k=new Knapsack();
        k.init();
        k.dynamics();
        k.print();





    }
}

结果截图：

扩展解法对比

1. 回溯法（决策树实现）

int backtrack(int i, int currentW, int currentV) {
    if(i > N) return currentV;
    if(currentW + w[i] > W) {
        return backtrack(i+1, currentW, currentV);
    }
    return max(
        backtrack(i+1, currentW, currentV),
        backtrack(i+1, currentW + w[i], currentV + v[i])
    );
}

⚠️ 问题规模达20时计算量超百万次

2. 空间优化DP（滚动数组）

int[] dp = new int[W+1];
for(int i=1; i<=N; i++){
    for(int j=W; j>=w[i]; j--){ // 逆序更新
        dp[j] = Math.max(dp[j], dp[j-w[i]] + v[i]);
    }
}

🔧 优势：空间复杂度降为O(W) = 6 units

3. 分支限界法（优先队列实现）

from queue import PriorityQueue

class Node:
    def __init__(self, level, weight, value, bound):
        self.level = level
        self.weight = weight
        self.value = value
        self.bound = bound

def bound(node):
    # 计算剩余物品的最大可能价值
    ...

算法选择策略

完整代码执行结果

0   0   0   0   0   0   
0   2   2   2   2   2   
0   2   4   6   6   6   
0   2   4   6   7   9   
0   2   4   6   7   9   

最终最大价值为 9，通过物品选择（2+3号物品：重量2+3=5，价值4+5=9）实现