动态规划学习（一）

动态规划学习（一）

学习来源：《算法零基础入门》动态规划 (一)-哔哩哔哩

几个重要的思维

• 状态转移，要以方程的思想去想动态规划
  • 所谓状态转移方程指的就是 用能等效代替的各种状态（方程式）来代替当前的数组元素

例如： dp[i] = dp[i-1]+ dp[i+1];  //用前两个状态来代替现在的状态
            又比如：
           dp[i]=Math.max(dp[i-1],dp[i+1]);//有多个可以替代状态的时候，可能会根据题目取符合我们最优解的那种

• 想要求 n 个数的时间复杂度，不如从一个数开始想起

//例如
求大小为 n 的数组有多少连续子数组？
我们可以从一个数开始想 ：1 种
               两个数开始想：2 种
              三个数开始想：6 种

答案就是：n（n-1）种

求解动态规划的题目，大体分为四步：

• 设置初始值
• 设计状态转换方程
• 根据状态转换方程为数组赋值
• 返回结果

我们来用几道典型题来理解一下：

1. 斐波那契数列–属于是我们的老朋友了

class Solution {
    public int fib(int n) {
     //设置初始值 初始数组
     int[] fn=new int[31];
     fn[0]=0;
     fn[1]=1;
     //根据状态方程来为数组各项赋值
     for(int i=2;i<31;i++){
         fn[i]=fn[i-1]+fn[i-2];
     }
     //返回结果
      return fn[n];
    }
}

有了状态方程后，这题就十分容易。
我们来看下一题。
2. 爬楼梯-经典中的经典

class Solution {
    //状态方程为 fn[i]=fn[i-1]+fn[i-2]
    public int climbStairs(int n) {
     //设置初始值，初始数组
    int[] fn=new int[46];
    fn[1]=1;
    fn[2]=2;
     //根据状态方程求解
    for(int i=3;i<46;i++){
        fn[i]=fn[i-1]+fn[i-2];
    }
     //返回结果
     return fn[n];
    }
}

根据那几步走，依旧十分的简单。
我们再来一道：
3. 利用最小花费爬楼梯（爬楼梯 plus）

题目链接：https://leetcode-cn.com/problems/min-cost-climbing-stairs/
依旧如常：

class Solution {
    //状态方程 fn[i]=min{fn[i-1]+cost[i-1],fn[i-2]+cost[i-2]}
    public int minCostClimbingStairs(int[] cost) {
    //创建初始值，初始数组
     int[] fn=new int[cost.length+1];
    //fn[0]=0 f[1]=0 可以省略不写
    //利用状态方程来求出数组各项
    for(int i=2;i<=cost.length;i++){
        fn[i]=Math.min(fn[i-1]+cost[i-1],fn[i-2]+cost[i-2]);
    }
    //返回结果
     return fn[cost.length];
    }
}

我们再来一道：

4. 最大子数组和–稍有锋芒
   
   题目链接：https://leetcode-cn.com/problems/maximum-subarray/

class Solution {

    //状态方程为 fn[i]=max{fn[n-1]+nums[i],nums[i]}
    public int maxSubArray(int[] nums) {
     //设置结果（因为可能某个阶段有最大值，所以最后一个不一定是最大值）
     //同时要注意 maxnum要设置成第一个值，以防只有nums里只有一个数，此时不管这个数多大，他都是最大值
     int maxnum=nums[0];
    //设置初始值
    int[] fn=new int[nums.length];
    fn[0]=Math.max(0,nums[0]);
    
    //根据状态方程为数组赋值
    for(int i=1;i<nums.length;i++){
    
    fn[i]=Math.max(fn[i-1]+nums[i],nums[i]);
    maxnum=Math.max(maxnum,fn[i]);
    }
    //返回值
    return maxnum;
    }
}

5. 打家劫舍–爬楼梯+给点赏金
   
   题目链接：https://leetcode-cn.com/problems/house-robber/

class Solution {
    //状态方程 fn[i]=max{fn[i-1],fn[i-2]+nums[i]}
    public int rob(int[] nums) {
     //设置初始值
     int[] fn=new int[100];
     fn[0]=nums[0];
     //注意 num的长度为1的情况
     if(nums.length>1)fn[1]=Math.max(fn[0],nums[1]);
     //利用状态方程求动态规划数组各项的值
     for(int i=2;i<nums.length;i++){
         fn[i]=Math.max(fn[i-1],fn[i-2]+nums[i]);
     }
     //返回解
     return fn[nums.length-1];
    }
}

动态规划入门学习就到这了，感觉已经触及了动态规划的冰山一角。今后应该还会有更多分享，愿我们一同努力！追逐梦想！