问题介绍：

动态规划算法：

动态规划（Dynamic Programming）是一种解决多阶段决策问题的优化算法。它通过将问题分解为一系列子问题，并利用子问题的解来构建更大规模问题的解，从而实现对整个问题的求解。

动态规划算法通常适用于满足以下两个条件的问题：

1. 重叠子问题（Overlapping Subproblems）：原问题可以被分解为一系列相互重叠的子问题，这意味着解决子问题时可能会重复计算相同的子问题。

2. 最优子结构（Optimal Substructure）：原问题的最优解可以通过子问题的最优解来构建，即全局最优解必然包含局部最优解。

动态规划算法的基本思想是利用一个表格（通常是二维数组）来存储子问题的解，通过填表的方式逐步求解更大规模的问题，直到得到最终的解。在填表的过程中，可以利用已经计算过的子问题的解来避免重复计算。

动态规划算法一般涉及以下步骤：

1. 定义状态：确定问题的状态，并设计状态表示方法。

2. 确定状态转移方程：根据子问题之间的关系，建立状态转移方程，描述问题的最优解与子问题的最优解之间的关系。

3. 初始化：初始化表格中的边界条件，即最简单的子问题的解。

4. 递推计算：按照状态转移方程，从小规模子问题开始逐步计算，填充表格中的值，直到计算出原问题的解。

5. 求解原问题：根据填充好的表格，得到原问题的最优解。

public class KnapsackProblem {
    
    public static int knapsack(int[] weights, int[] values, int capacity) {
        int n = weights.length;
        int[][] dp = new int[n + 1][capacity + 1];
        
        // 初始化第一行和第一列为0
        for (int i = 0; i <= n; i++) {
            dp[i][0] = 0;
        }
        for (int j = 0; j <= capacity; j++) {
            dp[0][j] = 0;
        }
        
        // 动态规划求解
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= capacity; j++) {
                if (weights[i - 1] <= j) {
                    // 当前物品的重量小于等于背包容量，可以选择放入背包
                    dp[i][j] = Math.max(values[i - 1] + dp[i - 1][j - weights[i - 1]], dp[i - 1][j]);
                } else {
                    // 当前物品的重量大于背包容量，无法放入背包
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        
        return dp[n][capacity];
    }
    
    public static void main(String[] args) {
        int[] weights = {2, 3, 4, 5};
        int[] values = {3, 4, 5, 6};
        int capacity = 8;
        
        int maxTotalValue = knapsack(weights, values, capacity);
        System.out.println("Maximum total value: " + maxTotalValue);
    }
}