《剑指offer》：动态规划

目录

动态规划算法的基本思想

BM62 斐波那契数列

BM63 跳台阶

JZ42 连续子数组的最大和

JZ85 连续子数组的最大和(二)

JZ63 买卖股票的最好时机(一)

动态规划算法的基本思想

        将待求解的问题分解成若干个相互联系的子问题，先求解子问题，然后从这些子问题的解得到原问题的解；对于重复出现的子问题，只在第一次遇到的时候对它进行求解，并把答案保存起来，让以后再次遇到时直接引用答案，不必重新求解。动态规划算法将问题的解决方案视为一系列决策的结果

BM62 斐波那契数列

链接：斐波那契数列

题目描述：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。n<=39。

思路：

• 方法一：迭代相加。时间复杂度O(n)，空间复杂度 O(1)
• 方法二：递归，时间复杂度：，每个递归会调用两个递归，因此呈现2的指数增长；空间复杂度：, 递归栈的最大深度
• 方法三：动态规划，时间复杂度=空间复杂度=O(n)

public class Solution {
    //方法一
    public int Fibonacci1(int n) {
        if(n<2)
            return n;
        int res=0;
        int pre=0;
        int next=1;
        for(int i=2;i<=n;i++){
            res=pre+next;
            pre=next;
            next=res;
        }
        return res;
    }
    //方法二
    public int Fibonacci2(int n) {
        if(n<2)
            return n;
        else return Fibonacci2(n-1)+Fibonacci2(n-2);
    }
    //方法三
    public int Fibonacci3(int n) {
        if(n<2)
            return n;
        int[] fib=new int[n+1];
        fib[0]=0;
        fib[1]=1;
        for(int i=2;i<=n;i++)
            fib[i]=fib[i-2]+fib[i-1];
        return fib[n];
    }
}

BM63 跳台阶

链接：跳台阶

题目描述：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个 n 级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

解题思路：

• 方法一：递归
• 方法二：动态规划。从上往下递归的然后再从下往上回溯的，最后回溯的时候来合并子树从而求得答案。 那么动态规划不同的是，不用递归的过程，直接从子树求得答案。过程是从下往上。

public class Solution {
    //方法一
    int jumpFloor(int number) {
        if (number<=1) return 1;
        return jumpFloor(number-1)+jumpFloor(number-2);
    }
    //方法二
    public int jumpFloor2(int target) {
        if(target<2)
            return 1;
        int[] res=new int[target+1];
        res[0]=1;
        res[1]=1;
        //从上往下递归，从下往上回溯
        for(int i=2;i<=target;i++)
            res[i]=res[i-1]+res[i-2];
        return res[target];
    }
}

JZ42 连续子数组的最大和

链接：连续子数组的最大和

题目描述：输入一个长度为n的整型数组array，数组中的一个或连续多个整数组成一个子数组，子数组最小长度为1。求所有子数组的和的最大值。

解题思路：因为数组中有正有负有0，因此每次遇到一个数，要不要将其加入我们所求的连续子数组里面，是个问题，有可能加入了会更大，有可能加入了会更小，而且我们要求连续的最大值，因此这类有状态转移的问题可以考虑动态规划（关注状态转移公式）。

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        int[] dp=new int[array.length];
        dp[0]=array[0];
        int res=dp[0];
        for(int i=1;i<array.length;i++)
        {
            dp[i]=Math.max(dp[i-1]+array[i],array[i]);
            res=Math.max(res,dp[i]);
        }
        return res;
    }
}

JZ85 连续子数组的最大和(二)

链接：连续子数组的最大和(二)

相似题目：JZ42. 连续子数组的最大和 、JZ71. 跳台阶扩展问题

题目描述：输入一个长度为n的整型数组array，数组中的一个或连续多个整数组成一个子数组，找到一个具有最大和的连续子数组。

1.子数组是连续的，比如[1,3,5,7,9]的子数组有[1,3]，[3,5,7]等等，但是[1,3,7]不是子数组

2.如果存在多个最大和的连续子数组，那么返回其中长度最长的，该题数据保证这个最长的只存在一个

3.该题定义的子数组的最小长度为1，不存在为空的子数组，即不存在[]是某个数组的子数组

4.返回的数组不计入空间复杂度计算

具体做法：

• step 1：创建动态规划辅助数组，记录到下标i为止的最大连续子数组和，下标为0的时候，肯定等于原数组下标为0的元素。
• step 2：准备左右区间双指针记录每次连续子数组的首尾，再准备两个双指针记录最大和且区间最长的连续子数组的首尾。
• step 3：遍历数组，对于每个元素用上述状态转移公式记录其dp值，更新区间首尾（如果需要）。
• step 4：出现一个最大值。且区间长度更大的时候，更新记录最长区间的双指针。
• step 5：根据记录的最长子数组的位置取数组。

import java.util.*;
public class Solution {
    public int[] FindGreatestSumOfSubArray (int[] array) {
        int[] dp=new int[array.length];
        dp[0]=array[0];
        int maxsum=dp[0];
        //滑动区间
        int left=0,right=0;
        //记录最长的区间
        int resl = 0, resr = 0;
        for(int i=1;i<array.length;i++)
        {
            right++;
            dp[i]=Math.max(dp[i-1]+array[i],array[i]);
            if(dp[i-1]+array[i]<array[i])
                left=right;
            if(dp[i]>maxsum || dp[i]==maxsum && (right-left+1)>(resr-resl+1))
            {
                maxsum=dp[i];
                resl=left;
                resr=right;
            }
        }
        //取数组
        int[] res=new int[resr-resl+1];
        for(int i=resl;i<=resr;i++)
            res[i-resl]=array[i];
        return res;
    }
}

JZ63 买卖股票的最好时机(一)

链接：买卖股票的最好时机(一)

题目描述：假设你有一个数组prices，长度为n，其中prices[i]是股票在第i天的价格，请根据这个价格数组，返回买卖股票能获得的最大收益

1.你可以买入一次股票和卖出一次股票，并非每天都可以买入或卖出一次，总共只能买入和卖出一次，且买入必须在卖出的前面的某一天

2.如果不能获取到任何利润，请返回0

3.假设买入卖出均无手续费

​​​​​​​ 

解题思路：对于每天有到此为止的最大收益和是否持股两个状态，因此我们可以用动态规划。

当天状态

（1）持股

• 前面若干天中买了还没卖（收益同前一天）      dp[i-1][1]
• 当天买入的                                                      -prices[i]

（2）不持股

• 前面若干天前卖的或是还没卖的（总收益和前一天相同）  dp[i-1][0]
• 当天买入才卖掉的                                                               dp[i-1][1]+prices[i]

import java.util.*;
public class Solution {
    /**
     * 
     * @param prices int整型一维数组 
     * @return int整型
     */
    public int maxProfit (int[] prices) {
        int[][] res=new int[prices.length][2];
        //初始状态
        res[0][0]=0;
        res[0][1]=-prices[0];
        for(int i=1;i<prices.length;i++){
            //第i天未持有
            res[i][0]=Math.max(res[i-1][1]+prices[i],res[i-1][0]);
            //第i天持有
            res[i][1]=Math.max(res[i-1][1],-prices[i]);
        }
        //返回值是最后一天不持股，到该天为止的最大收益
        return res[prices.length-1][0];
    }
}