动态规划实战：打家劫舍问题解析与优化

1. 问题背景与核心挑战

最近在刷力扣Hot100时遇到了这道经典的动态规划问题——"打家劫舍"。题目描述很简单：假设你是一个专业的小偷，计划偷窃一条街上的房屋，每个房屋都存放着特定金额的现金。但是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚被闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算在不触动警报的情况下，一夜之内能够偷窃到的最高金额。

这个问题的现实意义其实远超编程竞赛。比如在投资决策中，我们经常面临类似的选择困境：某些机会之间存在互斥性，选择了一个就可能要放弃相邻的其他机会。如何在约束条件下做出最优决策，这正是动态规划最擅长的场景。

2. 暴力递归与问题分析

2.1 最直观的递归思路

我最初尝试用递归来解决这个问题。对于第i个房屋，我们有两个选择：

1. 偷窃这个房屋，那么就不能偷窃i-1房屋，最大金额就是当前房屋金额加上i-2房屋的最大金额
2. 不偷窃这个房屋，那么最大金额就是i-1房屋的最大金额

用代码表示就是：

python复制def rob(nums, i):
    if i < 0:
        return 0
    return max(nums[i] + rob(nums, i-2), rob(nums, i-1))

2.2 递归解法的问题

虽然这个解法逻辑正确，但实际运行时发现存在严重的性能问题。以[1,2,3,1]为例，递归树会指数级膨胀：

• 计算rob(3)需要rob(2)和rob(1)
• rob(2)又需要rob(1)和rob(0)
• rob(1)需要rob(0)和rob(-1)

这里存在大量重复计算，时间复杂度达到O(2^n)，对于n=100的测试用例根本无法在合理时间内完成。

3. 动态规划解法

3.1 自底向上的DP实现

动态规划正是为了解决这种重叠子问题而生的。我们可以用一个数组dp来存储中间结果，其中dp[i]表示前i个房屋能偷窃到的最大金额。

状态转移方程：

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

具体实现：

python复制def rob(nums):
    if not nums:
        return 0
    if len(nums) == 1:
        return nums[0]
    
    dp = [0] * len(nums)
    dp[0] = nums[0]
    dp[1] = max(nums[0], nums[1])
    
    for i in range(2, len(nums)):
        dp[i] = max(dp[i-1], dp[i-2] + nums[i])
    
    return dp[-1]

3.2 空间优化

观察发现，dp[i]只依赖于前两个状态dp[i-1]和dp[i-2]，因此可以进一步优化空间复杂度到O(1)：

python复制def rob(nums):
    prev_max = curr_max = 0
    for num in nums:
        temp = curr_max
        curr_max = max(prev_max + num, curr_max)
        prev_max = temp
    return curr_max

这个优化版本只用两个变量prev_max和curr_max就完成了所有计算，空间复杂度降为O(1)，而时间复杂度保持O(n)。

4. 边界条件与特殊案例

4.1 空数组和单元素数组

在实际编码中，有几个边界情况需要特别注意：

• 空数组：应该返回0
• 单元素数组：直接返回该元素值
• 双元素数组：返回两个元素中的较大值

4.2 全零数组

虽然题目说明是非负整数，但测试用例中可能出现全零的情况。我们的算法应该能正确处理这种情况，返回0。

4.3 大数测试

当房屋金额很大时（比如接近2^31-1），要注意整数溢出问题。不过在Python中这不是问题，如果是其他语言如Java/C++需要考虑使用long类型。

5. 算法正确性证明

5.1 数学归纳法

我们可以用数学归纳法证明这个DP解法的正确性：

• 基本情况：对于i=0和i=1，dp值显然正确
• 归纳假设：假设对于所有k < i，dp[k]都是正确的
• 归纳步骤：根据状态转移方程，dp[i]取两种选择中的最大值，因此也是正确的

5.2 最优子结构性质

这个问题具有最优子结构性质：一个问题的最优解包含其子问题的最优解。这正是动态规划适用的前提条件。

6. 变种与扩展问题

6.1 环形房屋排列

力扣上还有一个变种问题"打家劫舍II"，房屋排成一个环形。这时第一个和最后一个房屋也视为相邻的。

解决思路：

• 分解为两个子问题：不偷第一个房屋和不偷最后一个房屋
• 取这两个子问题的最大值

python复制def rob(nums):
    def helper(start, end):
        prev_max = curr_max = 0
        for i in range(start, end):
            temp = curr_max
            curr_max = max(prev_max + nums[i], curr_max)
            prev_max = temp
        return curr_max
    
    if not nums:
        return 0
    if len(nums) == 1:
        return nums[0]
    return max(helper(0, len(nums)-1), helper(1, len(nums)))

6.2 二叉树房屋排列

另一个变种是房屋排列成二叉树结构（打家劫舍III），不能同时偷窃直接相连的两个节点。

这需要用到树形DP的思想，对每个节点返回两个值：

• 偷窃该节点时的最大值
• 不偷窃该节点时的最大值

python复制def rob(root):
    def helper(node):
        if not node:
            return (0, 0)
        left = helper(node.left)
        right = helper(node.right)
        
        rob = node.val + left[1] + right[1]
        not_rob = max(left) + max(right)
        
        return (rob, not_rob)
    
    return max(helper(root))

7. 实际应用与思维训练

7.1 资源分配问题

这类问题在实际中有很多应用场景，比如：

• 项目选择：某些项目有时间冲突，如何选择使总收益最大
• 课程安排：某些课程时间重叠，如何选择最多课程
• 机器调度：如何安排任务使总收益最大

7.2 动态规划思维训练

解决这类问题的关键在于：

1. 定义合适的状态表示
2. 找出正确的状态转移方程
3. 确定初始条件和边界情况
4. 考虑空间优化可能性

通过这道题，我深刻体会到动态规划"将大问题分解为小问题"的核心思想。在实际工程中，很多复杂问题都可以用类似的思路来分解和解决。