【用JAVA实现动态规划算法】1.背包问题2.最长公共子序列 3.最长上升子序列

1.背包问题（Knapsack Problem）

背包问题（Knapsack Problem）是一个经典的优化问题，通常描述为：给定一组物品，每种物品都有自己的重量和价值，在限定的总重量内，如何选择物品使得总价值最高。以下是一个0-1背包问题的Java实现，即每种物品只能选择0个或1个。

public class KnapsackProblem {

    // 物品类
    static class Item {
        int weight; // 重量
        int value;  // 价值

        public Item(int weight, int value) {
            this.weight = weight;
            this.value = value;
        }
    }

    // 0-1背包问题的动态规划解法
    public static int knapsack(Item[] items, int capacity) {
        int n = items.length; // 物品数量
        int[][] dp = new int[n + 1][capacity + 1]; // dp[i][j]表示前i个物品在容量为j的背包下能取得的最大价值

        // 初始化dp数组
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= capacity; j++) {
                if (i == 0 || j == 0) {
                    dp[i][j] = 0; // 没有物品可选或者背包容量为0时，价值为0
                }
            }
        }

        // 填充dp数组
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= capacity; j++) {
                // 如果第i个物品的重量大于背包容量j，则不选择该物品
                if (items[i - 1].weight > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    // 否则，比较选择第i个物品与不选择第i个物品两种情况下的最大价值
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - items[i - 1].weight] + items[i - 1].value);
                }
            }
        }

        // 返回最终的最大价值
        return dp[n][capacity];
    }

    public static void main(String[] args) {
        // 示例物品和背包容量
        Item[] items = {new Item(10, 60), new Item(20, 100), new Item(30, 120)};
        int capacity = 50;

        // 计算最大价值
        int maxValue = knapsack(items, capacity);
        System.out.println("背包容量为 " + capacity + " 时的最大价值为: " + maxValue);
    }
}

在上面的代码中，我们定义了一个Item类来表示物品，其中包含了weight（重量）和value（价值）两个属性。然后，我们使用动态规划的方法解决了0-1背包问题。在knapsack方法中，我们创建了一个二维数组dp来保存中间结果，其中dp[i][j]表示前i个物品在容量为j的背包下能取得的最大价值。最后，我们返回dp[n][capacity]作为最终的最大价值，其中n是物品数量，capacity是背包容量。

在main方法中，我们给出了一个示例物品数组和背包容量，并调用了knapsack方法来计算最大价值，并打印结果。

2.最长公共子序列（Longest Common Subsequence）

最长公共子序列（Longest Common Subsequence, LCS）是一个经典的计算机科学问题，用于找出两个或多个序列中的最长公共子序列。下面是一个使用Java实现的LCS算法，包括中文注释：

public class LongestCommonSubsequence {

    // 动态规划求解最长公共子序列
    public static int longestCommonSubsequence(String text1, String text2) {
        int m = text1.length();
        int n = text2.length();

        // 创建一个二维数组dp，用于存储最长公共子序列的长度
        int[][] dp = new int[m + 1][n + 1];

        // 初始化dp数组的第一行和第一列，都为0
        for (int i = 0; i <= m; i++) {
            dp[i][0] = 0;
        }
        for (int j = 0; j <= n; j++) {
            dp[0][j] = 0;
        }

        // 填充dp数组
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
                    // 如果当前字符相等，则最长公共子序列长度加1
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    // 如果当前字符不相等，则取上方和左方两个位置的最大值
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }

        // 返回最长公共子序列的长度
        return dp[m][n];
    }

    // 用于测试的方法
    public static void main(String[] args) {
        String text1 = "ABCDEF";
        String text2 = "ACEF";
        System.out.println("最长公共子序列的长度为: " + longestCommonSubsequence(text1, text2));
    }
}

在这个代码中，我们使用了动态规划的思想。首先，我们创建了一个二维数组dp，其中dp[i][j]表示text1的前i个字符和text2的前j个字符的最长公共子序列的长度。然后，我们遍历两个字符串，如果当前字符相等，则最长公共子序列长度加1；如果当前字符不相等，则取上方和左方两个位置的最大值。最后，返回dp[m][n]，其中m和n分别是两个字符串的长度，即为最长公共子序列的长度。

3.最长上升子序列（Longest Increasing Subsequence）

最长上升子序列（Longest Increasing Subsequence，LIS）是算法问题中非常经典的一类问题。以下是使用Java实现最长上升子序列算法的代码，并附带了中文注释：

public class LongestIncreasingSubsequence {

    // 动态规划求解最长上升子序列
    public static int lengthOfLIS(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        // dp[i] 表示以 nums[i] 结尾的最长上升子序列的长度
        int[] dp = new int[nums.length];
        
        // 初始化dp数组，每个元素的最长上升子序列至少包含自己
        for (int i = 0; i < nums.length; i++) {
            dp[i] = 1;
        }
        
        int maxLength = 1; // 最长上升子序列的长度
        
        // 遍历数组
        for (int i = 1; i < nums.length; i++) {
            // 遍历当前元素之前的所有元素
            for (int j = 0; j < i; j++) {
                // 如果当前元素大于前面的元素，则尝试更新dp[i]
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            // 更新最长上升子序列的长度
            maxLength = Math.max(maxLength, dp[i]);
        }
        
        return maxLength;
    }

    // 用于测试的方法
    public static void main(String[] args) {
        int[] nums = {10, 9, 2, 5, 3, 7, 101, 18};
        System.out.println("最长上升子序列的长度为: " + lengthOfLIS(nums));
    }
}

代码解释：

• 我们使用一个数组 dp 来记录以每个元素为结尾的最长上升子序列的长度。
• 初始化时，假设每个元素都是长度为1的子序列（因为它自己就是一个子序列）。
• 遍历数组 nums，对于每个元素 nums[i]，再遍历它之前的所有元素 nums[j]（其中 j < i）。
• 如果 nums[i] 大于 nums[j]，则尝试更新 dp[i] 的值，因为 nums[i] 可以接在以 nums[j] 结尾的上升子序列后面，从而形成一个更长的上升子序列。
• 更新 dp[i] 为 dp[j] + 1 和 dp[i] 之间的较大值。
• 同时，我们用一个变量 maxLength 来记录遍历过程中遇到的最长上升子序列的长度。
• 最后返回 maxLength 即可。

在 main 方法中，我们定义了一个示例数组 nums，并调用 lengthOfLIS 方法来计算最长上升子序列的长度，并将结果打印到控制台。