力扣打卡day22

309.最佳买卖股票时机含冷冻期

1.确定dp数组以及下标的含义
dp[i][j]，第i天状态为j，所剩的最多现金为dp[i][j]。

四个状态：

状态一：买入股票状态（今天买入股票，或者是之前就买入了股票然后没有操作）
卖出股票状态，这里就有两种卖出股票状态
状态二：两天前就卖出了股票，度过了冷冻期，一直没操作，今天保持卖出股票状态
状态三：今天卖出了股票
状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！

j的状态为：

0：状态一
1：状态二
2：状态三
3：状态四
2.确定递推公式
达到买入股票状态（状态一）即：dp[i][0]，有两个具体操作：

操作一：前一天就是持有股票状态（状态一），dp[i][0] = dp[i - 1][0]
操作二：今天买入了，有两种情况
前一天是冷冻期（状态四），dp[i - 1][3] - prices[i]
前一天是保持卖出股票状态（状态二），dp[i - 1][1] - prices[i]
dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3], dp[i - 1][1]) - prices[i]);

保持卖出股票状态（状态二）即：dp[i][1]，有两个具体操作：

操作一：前一天就是状态二
操作二：前一天是冷冻期（状态四
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
今天就卖出股票状态（状态三），即：dp[i][2] ，只有一个操作：昨天一定是买入股票状态（状态一），今天卖出

dp[i][2] = dp[i - 1][0] + prices[i];

达到冷冻期状态（状态四），即：dp[i][3]，只有一个操作：昨天卖出了股票（状态三）

dp[i][3] = dp[i - 1][2];

3.初始化
如果是持有股票状态（状态一）那么：dp[0][0] = -prices[0]

其余dp[0][1]、dp[0][2]、dp[0][3]都初始化为0
最后结果是取 状态二，状态三，和状态四的最大值

class Solution {
    public int maxProfit(int[] prices) {
        int[][] dp=new int[prices.length][4];
        if(prices.length==0){
            return 0;
        }
        int n=prices.length;
        dp[0][0]=-prices[0];
        for(int i=1;i<n;i++){
            dp[i][0] = Math.max(dp[i - 1][0], Math.max(dp[i - 1][3], dp[i - 1][1]) - prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][3]);
            dp[i][2] = dp[i - 1][0] + prices[i];
            dp[i][3] = dp[i - 1][2];
        }
        return Math.max(dp[n - 1][3],Math.max(dp[n - 1][1], dp[n - 1][2]));
    }
}

714. 买卖股票的最佳时机含手续费

相对于动态规划：122.买卖股票的最佳时机II (opens new window)，本题只需要在计算卖出操作的时候减去手续费就可以了，代码几乎是一样的。
dp[i][0] 表示第i天持有股票所省最多现金。 dp[i][1] 表示第i天不持有股票所得最多现金

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) return 0;
        int[][] dp=new int[prices.length][2];
        dp[0][0]=-prices[0];
        dp[0][1]=0;
        for(int i=1;i<prices.length;i++){
            //与上一题只有这行代码不同
            dp[i][0]=Math.max(dp[i-1][0],dp[i-1][1]-prices[i]);
            dp[i][1]=Math.max(dp[i-1][1],dp[i-1][0]+prices[i]-fee);//只有这有区别，卖出股票后还要减去手续费，才是现有的现金
        }
        return dp[prices.length-1][1];
    }
}

300.最长递增子序列

dp[i]的定义
dp[i]表示i之前包括i的以nums[i]结尾最长上升子序列的长度

2.状态转移方程

位置i的最长升序子序列等于j从0到i-1各个位置的最长升序子序列 + 1 的最大值。

当 nums[i] > nums[j 时： nums[i 可以接在 nums[j] 之后（此题要求严格递增），此情况下最长上升子序列长度为 dp[j] + 1

当 nums[i] <= nums[j] 时： nums[i] 无法接在 nums[j]之后，此情况上升子序列不成立，跳过。

上述所有 1. 情况 下计算出的 dp[j] + 1的最大值，为直到 ii 的最长上升子序列长度（即 dp[i]）。实现方式为遍历 jj时，每轮执行 dp[i] = max(dp[i], dp[j] + 1)

所以状态转移方程为： if(nums[i]>nums[j]){dp[i]=Math.max(dp[i],dp[j]+1); }

3.dp[i]的初始化

每一个i，对应的dp[i]（即最长上升子序列）起始大小至少都是1.

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp=new int[nums.length];
        Arrays.fill(dp,1);
        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[i],dp[j]+1);
                }
            }
        }
        int res=0;
        for(int i=0;i<dp.length;i++){
            res=Math.max(res,dp[i]);
        }
        return res;
    }
}

补充一个方法：

Java Util 类的 Arrays.fill(arrayname,value) 方法和Arrays.fill(arrayname ,starting index ,ending index ,value) 方法向数组中填充元素

import java.util.*;
 
public class FillTest {
    public static void main(String args[]) {
        int array[] = new int[6];
        Arrays.fill(array, 100);
        for (int i=0, n=array.length; i < n; i++) {
            System.out.println(array[i]);
        }
        System.out.println();
        Arrays.fill(array, 3, 6, 50);
        for (int i=0, n=array.length; i< n; i++) {
            System.out.println(array[i]);
        }
    }
}