动态规划(入门)

首先,我们先来看一个最简单的动态规划问题——爬楼梯

题目:

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢?

如果你是第一次看到这种问题,那么一脸懵是很正常的。我们不妨先进行列举:

  • 如果是爬一层楼梯,只有一种方法
  • 如果是爬两层楼梯,则可以一层一层爬,也可以一次爬两层,两种方法
  • 如果是爬三层楼梯,则可以从一层直接爬两个台阶或者从二层爬一个台阶,共有1+2=3种方法
  • 如果是爬四层楼梯,则可以从二层直接爬两个台阶或者从三层爬一个台阶,共有3+2=5种方法
  • ……

大家有没有发现什么?如此推得,爬n层楼梯的方法数不就是爬n-1层楼梯的方法数+爬n-2层楼梯的方法数吗?

求得递推公式:f(n) = f(n-1)+f(n-2)

诶?!!!这不是斐波那契数列吗?最经典的递归算法,但是我们知道,递归的逐层嵌套是存在很大弊端的,我们能否对其进行一定的改进呢?接下来,就让我们有请今天的主人公——动态规划


既然每一层的方法都受前面层数的影响,那么我们不妨将每层所需的方法数存在一个数组里,这样以来要求哪一层就直接从数组里调就好了。

接下来,我们上代码:

    public int climbStairs(int n) {
        if (n <= 1)
            return 1;
        int[] dp = new int[n + 1];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];

分析一波复杂度——时间复杂度:O(n),空间复杂度:O(n)。看到这个复杂度,仔细想想还有没有什么可优化的地方呢???

对!是空间!既然我们只需要第n层的方法,而求第n层只需要求前两层的方法,那我们把之前全部的方法数存起来干什么?直接创建两个变量每次存放前两层的方法数然后不断更新就好了呀!

优化后的代码:


    public int climbStairs(int n) {
        int q = 0;    //n-2层
        int p = 0;    //n-1层
        int r = 1;    //n层
        for(int i = 0;i < n;i++){
            q = p;
            p = r;
            r = p+q;
        }
        return r;
    }

直接空间复杂度降到常量级O(1)

这就是动态规划最基本的模型(可别小看了它,看起来容易,自己动手写起来可没那么简单hhh)


那么 (总结来啦!)我们在什么情况下应该使用动态规划呢?

摘自知乎——如果一个问题,可以把所有可能的答案穷举出来,并且穷举出来后,发现存在重叠子问题,就可以考虑使用动态规划。

动态规划的核心在于——(就本题举例)

  • 拆分子问题:第n项可由n-1项和n-2项得出
  • 记住过往:将每一层的方法数存起来
  • 减少重复计算:如用递归,f(5) = f(4) + f(3)和 f(4) = f(3) + f(2)中f(3)的计算就重复了

动态规划的典型特征——(就本题举例)

  • 边界:f(1)和f(2)是边界
  • 状态转移方程:f(n) = f(n-1) + f(n-2)
  • 最优子结构:由于f(n) = f(n-1) + f(n-2) ,则f(n-1)和f(n-2)就是f(n)的最优子结构
  • 重叠子问题:同上的减少重复计算

动态规划的解题步骤:

  1. 确定初始状态
  2. 找到转移公式
  3. 确定初始条件和边界条件
  4. 计算结果

是不是有点意思啦!趁还热乎着,让我们再来道题试试手

题目:最大子序和

给你一个整数数组 nums ,请你找出一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。

子数组 是数组中的一个连续部分。

 我们试着用动态规划来分析这道题:

第一步:确定初始状态

我们需要先建立连续子数组第n项的和与前一项的关系。(这一步很重要,只有找到dp[i]所代表的意义才能建立相应的转移公式)

假设dp[i]为以第i项结尾的连续子数组的最大和

  • 如果dp[i-1]大于0,证明以第i-1项结尾的连续子数组的最大和为正数,我们就能把第i项与之相连求最大和
  • 如果dp[i-1]不大于0,证明把第i项与之相连只会让dp[i]变得更小,那么我们直接把nums[i]的值赋给dp[i]就好,即以第i项结尾的连续子数组的最大和就是nums[i]自身

第二步:找到转移公式

由第一步的分析,我们可以求出dp[i]的公式为

 第三步:确定初始条件和边界条件

当i=0时,以第一项结尾的连续子数组的最大和就是它本身,所以dp[0] = nums[0]

好啦,既然我们的初始工作全部完毕,接下来就可以开始写代码了

public int maxSubArray(int[] num) {
    int length = num.length;
    int[] dp = new int[length];
    //边界条件
    dp[0] = num[0];
    int max = dp[0];
    for (int i = 1; i < length; i++) {
        //转移公式
        dp[i] = Math.max(dp[i - 1], 0) + num[i];
        //记录最大值
        max = Math.max(max, dp[i]);
    }
    return max;
}

同样,有没有什么地方可以简化呢?对,既然dp[i]只受dp[i-1]的影响,那岂不两个变量搞定?!!

优化后的代码:


    public int maxSubArray(int[] nums) {
        int dp1,dp2;
        dp1 = dp2 = nums[0];
        int max = nums[0];
        for(int i = 1;i < nums.length;i++){
            dp2 = dp1>0?dp1+nums[i]:nums[i];
            max = dp2>max?dp2:max;
            dp1 = dp2;
        }
        return max;
    }

以上是两道最为基础的动态规划问题,如果你已经学会了,那就快去找几道经典的动态规划问题去试试手吧!!!

<think>好的,用户想学习动态规划的基础知识,需要我提供一个入门教程。首先,我得回忆一下动态规划的核心概念,确保自己理解正确。动态规划的关键在于拆分问题、记录子问题的结果,避免重复计算,这应该作为教程的核心点。 接下来,我需要按照用户的要求来组织内容。他们提到回答要结构清晰,帮助用户逐步解决问题,所以分步骤讲解比较合适。可能需要先定义动态规划,再讲基本思想,然后通过一个经典例子,比如斐波那契数列或者金矿问题来演示。 用户提供的引用中有提到金矿的故事和动态规划的基本步骤,应该把这些整合进去。比如引用[1]中的金矿问题,可以作为一个例子详细说明。另外,引用[2]强调了拆分问题和记录结果,这需要在步骤中重点强调。 还要注意格式问题,比如行内数学表达式用$...$,独立公式用$$...$$。例如,在讲解斐波那契数列的时候,递归和动态规划的对比需要数学公式。代码块需要用Python示例,像用户给的快速排序的例子那样,确保语法正确。 然后,生成相关问题部分,要考虑用户可能进一步想知道的内容,比如动态规划与分治法的区别,优化方法,或者更多经典问题。这些问题应该覆盖基本概念、应用场景和常见问题,帮助用户深入学习。 最后,检查是否符合所有系统级指令:正确使用LaTeX格式,中文回答,引用标识自然添加。确保没有使用任何markdown,代码块正确,没有错误信息。可能需要多次检查示例是否准确,步骤是否清晰,有没有遗漏关键点。 总结一下,教程的结构大概是:定义、基本思想、步骤、示例(金矿或斐波那契)、代码实现、常见问题,然后相关问题。这样用户能逐步理解动态规划的基础,并通过例子和代码加深印象。同时,引用文献要自然地融入讲解中,比如在讲步骤时提到引用[2]的内容,在例子中提到引用[1]的金矿问题。</think>### 动态规划入门教程 #### 1. **动态规划的定义** 动态规划(Dynamic Programming, DP)是一种通过将复杂问题分解为重叠子问题,并记录子问题的解来避免重复计算的算法设计方法。其核心思想是“空间换时间”,适用于有重叠子问题和最优子结构性质的问题[^2]。 --- #### 2. **动态规划的基本思想** - **拆分问题**:将原问题分解为规模更小的子问题。 - **记录结果**:保存子问题的解(通常用数组或哈希表),避免重复计算。 - **递推求解**:通过子问题的解推导出原问题的解。 例如,计算斐波那契数列时: - 递归法:$F(n) = F(n-1) + F(n-2)$ 会重复计算子问题。 - 动态规划:用数组存储已计算的$F(i)$,时间复杂度从$O(2^n)$降至$O(n)$。 --- #### 3. **动态规划的步骤** 1. **定义状态**:明确问题中的状态变量(例如金矿问题中的“剩余矿工数”和“剩余金矿数”[^1])。 2. **状态转移方程**:找到子问题之间的递推关系。例如斐波那契数列: $$ dp[i] = dp[i-1] + dp[i-2] $$ 3. **初始化边界条件**:例如$dp[0] = 0, dp[1] = 1$。 4. **计算顺序**:通常从最小子问题开始迭代求解。 --- #### 4. **经典示例:金矿问题[^1]** **问题描述**:有$n$座金矿和$k$名矿工,每座金矿需要$w_i$人开采,能获得$g_i$黄金。求最大收益。 **动态规划解法**: 1. **状态定义**:$dp[i][j]$表示用前$i$座金矿和$j$名矿工的最大收益。 2. **状态转移**: - 不挖第$i$座矿:$dp[i][j] = dp[i-1][j]$ - 挖第$i$座矿(需满足$j \ge w_i$):$dp[i][j] = dp[i-1][j-w_i] + g_i$ - 最终方程:$dp[i][j] = \max(dp[i-1][j], dp[i-1][j-w_i] + g_i)$ 3. **初始化**:$dp[0][j] = 0$(无金矿时收益为0)。 ```python def max_gold(n, k, w, g): dp = [[0] * (k+1) for _ in range(n+1)] for i in range(1, n+1): for j in range(1, k+1): if j >= w[i-1]: dp[i][j] = max(dp[i-1][j], dp[i-1][j - w[i-1]] + g[i-1]) else: dp[i][j] = dp[i-1][j] return dp[n][k] ``` --- #### 5. **常见问题** - **何时用动态规划**:问题有重叠子问题(如斐波那契数列)或最优子结构(如最短路径)。 - **与分治法的区别**:分治法子问题独立,动态规划问题重叠。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值