序列类动态规划问题解析

动态规划思路总结

在处理序列类动态规划问题时，核心思路是通过定义状态并建立状态转移方程，将问题逐步拆解。这种方法的关键在于如何找到当前状态与之前所有状态的联系，尤其是在处理子序列问题时，需要考虑元素的顺序和位置关系。

以下是几个经典问题的分析示例：

问题1：最长上升子序列

问题描述

给定一个无序整数数组，找到其中最长上升子序列的长度。

示例

输入: [10,9,2,5,3,7,101,18]输出: 4解释: 最长的上升子序列是 [2,3,7,101]，长度为4。

问题解析

问题拆解

最长上升子序列问题的关键在于确定每个位置是否可以与前面某个位置形成递增的子序列。我们可以定义 dp[i] 为以 nums[i] 结尾的子序列的最大长度。

状态定义

dp[i] 表示以 nums[i] 结尾的最长上升子序列的长度。通过分析，可以发现 dp[i] 的值取决于前面所有 nums[j] < nums[i] 的 dp[j] 的最大值加1。

递推方程

对于每个位置 i，我们需要检查前面所有位置 j，并找到满足 nums[j] < nums[i] 的最大 dp[j]：

dp[i] = max(dp[j] for j in 0..i-1 if nums[j] < nums[i]) + 1

实现

直接暴力枚举所有可能的子序列会导致时间复杂度为 O(n^2)，虽然不够高效，但可以帮助理解问题结构。优化方案将在后续内容中详细介绍。

代码实现

public int lengthOfLIS(int[] nums) {    if (nums == null || nums.length == 0) {        return 0;    }    int[] dp = new int[nums.length];    Arrays.fill(dp, 1);    int max = 0;    for (int i = 0; i < nums.length; ++i) {        for (int j = 0; j < i; ++j) {            if (nums[i] > nums[j]) {                dp[i] = Math.max(dp[j] + 1, dp[i]);            }        }        max = Math.max(max, dp[i]);    }    return max;}

问题2：打家劫舍

问题描述

你是一个专业的小偷，计划偷窃沿街的房屋。相邻房屋装有防盗系统，同一晚上不能进入相邻房屋。目标是偷窃到最高金额。

问题解析

问题拆解

抢第 i 个房子可以选择抢或不抢。如果抢，则前一个房子不能抢；如果不抢，则前一个房子可以抢。

状态定义

定义 dp[i] 为抢到第 i 个房子的最大金额。抢到第 i 个房子时，只能抢第 i-2 个房子。

递推方程

dp[i] = max(dp[i-1], dp[i-2] + nums[i-1])

其中 dp[0] 表示不抢第一个房子，dp[1] 表示抢第一个房子。

代码实现

public int rob(int[] nums) {    if (nums == null || nums.length == 0) {        return 0;    }    int n = nums.length;    if (n == 1) {        return nums[0];    }    int[] dp = new int[n + 1];    dp[1] = nums[0];    for (int i = 2; i <= n; ++i) {        dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]);    }    return dp[n];}

问题3：打家劫舍plus

问题描述

房屋排列成一个圆圈，防盗系统同样有效。求偷窃到的最高金额。

问题解析

问题拆解

房屋形成一个圆圈，意味着最后一个房子与第一个房子相邻。我们可以将问题分解为两种情况：

不抢第一个房子，直接考虑房子 [1, n]

不抢最后一个房子，直接考虑房子 [0, n-1]

递推方程

使用之前的 rob 函数计算两种情况的最大值。

代码实现

public int rob(int[] nums) {    if (nums == null || nums.length == 0) {        return 0;    }    if (nums.length == 1) {        return nums[0];    }    int n = nums.length;    return Math.max(        rob(Arrays.copyOfRange(nums, 0, n - 1)),        rob(Arrays.copyOfRange(nums, 1, n))    );}public int robI(int[] nums) {    if (nums == null || nums.length == 0) {        return 0;    }    int n = nums.length;    int[] dp = new int[n + 1];    dp[1] = nums[0];    for (int i = 2; i <= n; ++i) {        dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i - 1]);    }    return dp[n];}

总结

序列类动态规划问题的核心在于如何定义状态并建立状态转移关系。通过以上案例，我们可以看到动态规划在处理子序列问题中的广泛应用。优化算法的空间和时间复杂度将在后续内容中详细探讨。

转载地址：http://ftfz.baihongyu.com/

你可能感兴趣的文章

No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-loadbalanc