[Java 算法] 动态规划(4)

练习一 : 最长递增子序列

java 复制代码

class Solution {
    public int lengthOfLIS(int[] nums) {
        int n = nums.length;
        int[] dp = new int[n];
        // 初始化：每个元素至少是长度为1的子序列
        Arrays.fill(dp, 1);
        int maxLen = 1;

        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                // 如果nums[i]可以接在nums[j]后面
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i], dp[j] + 1);
                }
            }
            maxLen = Math.max(maxLen, dp[i]);
        }
        return maxLen;
    }
}

算法原理

DP 状态定义 : dp[i]：以 nums [i] 这个数字结尾的最长递增子序列长度。
初始化 : dp[i] = 1因为每个数字自己单独就是一个长度为 1 的递增子序列。
对于每个数 nums[i]，看它前面所有的数 nums[j]只要 nums[j] < nums[i]，说明 nums[i] 可以接在以 j 结尾的序列后面长度就变成：dp[j] + 1

练习二 : 摆动序列

376. 摆动序列 - 力扣（LeetCode）

java 复制代码

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n = nums.length;
        int[] f = new int[n];
        int[] g = new int[n];
        int ret = 1;
        for(int i = 0;i<n;i++) f[i] = g[i] = 1;
        for(int i = 1;i<n;i++){
            for(int j = i-1;j>=0;j--){
                if(nums[j]<nums[i]){
                    f[i] = Math.max(f[i],g[j]+1);
                }
                if(nums[j]>nums[i]){
                    g[i] = Math.max(g[i],f[j]+1);
                }
                ret = Math.max(Math.max(f[i],g[i]),ret);
            }
        }
        return ret;
    }
}

算法原理

状态定义（你用了两个 dp 数组，非常标准）
f[i]：以 nums [i] 结尾，且最后一步是上升（nums [i] > 前一个数）的最长摆动序列长度
g[i]：以 nums [i] 结尾，且最后一步是下降（nums [i] < 前一个数）的最长摆动序列长度
初始化 f[i] = g[i] = 1
每个元素自己就是一个长度为 1 的摆动序列。
状态转移（你写得完全正确！）
（1）当 nums [j] < nums [i] → 上升说明i 可以接在 j 的下降序列后面 f[i] = max(f[i], g[j] + 1)
（2）当 nums [j] > nums [i] → 下降说明i 可以接在 j 的上升序列后面g[i] = max(g[i], f[j] + 1)
摆动序列要求：上升 ↔ 下降交替
所以：
想上升，必须接在下降结尾后面
想下降，必须接在上升结尾后面
答案
遍历过程中 f[i] 和 g[i] 的最大值

练习三 : 最长递增子序列的个数

673. 最长递增子序列的个数 - 力扣（LeetCode）

java 复制代码

class Solution {
    public int findNumberOfLIS(int[] nums) {
        int n = nums.length;
        int[] len = new int[n]; // 以i结尾的最长递增子序列长度
        int[] cnt = new int[n]; // 以i结尾的最长递增子序列的个数
        // 初始化
        for (int i = 0; i < n; i++) {
            len[i] = 1;
            cnt[i] = 1;
        }

        int maxLen = 1; // 全局最长长度
        // 填dp表
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) { // 严格递增
                    if (len[j] + 1 > len[i]) {
                        // 找到更长的序列，更新长度和计数
                        len[i] = len[j] + 1;
                        cnt[i] = cnt[j];
                    } else if (len[j] + 1 == len[i]) {
                        // 长度相同，累加计数
                        cnt[i] += cnt[j];
                    }
                }
            }
            // 更新全局最长长度
            maxLen = Math.max(maxLen, len[i]);
        }

        // 统计所有长度等于maxLen的个数之和
        int res = 0;
        for (int i = 0; i < n; i++) {
            if (len[i] == maxLen) {
                res += cnt[i];
            }
        }
        return res;
    }
}

算法原理

状态定义

len[i]：以 nums[i] 结尾的最长递增子序列的长度

cnt[i]：以 nums[i] 结尾的、长度为 len[i] 的最长递增子序列的个数

初始化

len[i] = 1：每个元素自身是长度为 1 的子序列

cnt[i] = 1：每个元素自身对应 1 个长度为 1 的子序列

状态转移

遍历每个 i，枚举所有 j < i：

若 nums[j] < nums[i]（满足严格递增）：

若 len[j] + 1 > len[i]：说明找到了更长的子序列，更新 len[i] = len[j] + 1，同时 cnt[i] = cnt[j]（个数继承自 j）

若 len[j] + 1 == len[i]：说明找到了长度相同的新子序列，累加计数 cnt[i] += cnt[j]

若 nums[j] >= nums[i]：不满足严格递增，跳过

最终结果

先遍历 len 数组，找到全局最长长度 maxLen

再遍历所有 i，累加所有 len[i] == maxLen 的 cnt[i]，即为答案