【动态规划】简单多状态 dp 问题|打劫劫舍|打家劫舍II|删除并获取点数|粉刷房子|最佳买卖股票时机含冷冻期|最佳买卖股票时机含手续费|最佳买卖股票时机III|最佳买卖股票时机IV

一、按摩师

面试题 17.16. 按摩师

 💡细节：

1.因为每个位置都存在选和不选的情况，所以需要开辟两个dp表

2.此处的初始化简单，可以不用再多开辟一块空间

3. g[ i ]的前面一种情况：也存在选或者不选的情况

4.返回值为g[n-1]和f[n-1]的最大值

class Solution {
    public int massage(int[] nums) {
        int n = nums.length;

        //处理边界情况
        if(n==0) return 0;

        int[] f = new int[n];// 选
        int[] g = new int[n];// 不选

        // 初始化
        f[0] = nums[0];

        for (int i = 1; i < n; i++) {
            f[i] = g[i - 1] + nums[i];
            g[i] = Math.max(f[i - 1], g[i - 1]);
        }

        return Math.max(f[n - 1], g[n - 1]);
    }
}

---

二、打家劫舍II

 213. 打家劫舍 II

💡细节：

 1.本题就是在上题的基础上将首位相连，选了第一个就不能选择最后一个，那么就分类拆分为已知问题的形式：偷第一家：rob(2,n-2)+num[0] 和不偷第一家：rob(1,n-1）

2.注意因为left变化，不能写成f[0] = nums[0] ，而要写成f[left] = nums[left]

class Solution {
    //在上题的基础上增加了首尾相连
    public int rob(int[] nums) {
        //分类拆分成已知问题
        int n = nums.length;
        return Math.max(rob1(nums,2,n-2)+nums[0],rob1(nums,1,n-1));//前面不写成rob1(0,n-2)可以避免【1，2】这样的nums情况
    }
    public int rob1(int[] nums,int left,int right) {
        if(left>right) return 0;
        int n = nums.length;

        int[] f = new int[n];
        int[] g = new int[n];

        f[left] = nums[left];//注意这里不是f[0] = nums[0],因为初始位置不一样

        for(int i=left;i<=right;i++) {
            f[i] = g[i-1] + nums[i];
            g[i] = Math.max(f[i-1],g[i-1]);
        }

        return Math.max(f[right],g[right]);
    } 
    
}

---

三、删除并获取点数

740. 删除并获得点数

💡细节：

1.由于要删除两边的元素，那么就可以想到打家劫舍问题，那么怎么保证最大，就弄一个arr数字来存放nums[i]这个数字出现的总和，这样将问题进行转换

2.因为nums较小，直接开10001这么大的空间，这样就不用去遍历nums去找最大值了

class Solution {
    public int deleteAndEarn(int[] nums) {
        //arr[i]:nums[i]这个数字出现的总和
        int[] arr = new int[10001];//因为nums较小，直接开10001这么大的空间，就不用再去找nums中的最大值了

        for(int x:nums) arr[x]+= x;

        //下面对arr数字进行打家劫舍即可
        int n = arr.length;
        
        int[] f = new int[n];
        int[] g = new int[n];
        
        f[0] = arr[0];

        for (int i = 1; i < n; i++) {
            f[i] = g[i-1] + arr[i];
            g[i] = Math.max(f[i-1],g[i-1]);
        }
        return Math.max(f[n-1],g[n-1]);

    }
}

---

四、粉刷房子

 LCR 091. 粉刷房子

💡细节：

1.要理解costs[i][j]的涵义：代表粉刷到第i个房子，最后一个位置刷上某个颜色（0代表红色，1代表蓝色，2代表绿色）的最小花费

2.本来dp表就是代表粉刷到第i个房间的最小花费，但是发现还需要进一步分类讨论，所以就将dp表开为二维数组

3.初始化的时候，可以通过多开一个空间，这样初始化全为0，就相当于不用初始化

class Solution {
    public int minCost(int[][] costs) {
        int n = costs.length;
        
        int[][] dp = new int[n+1][3];

        //初始化：全部为0即可

        for(int i=1;i<=n;i++) {
            dp[i][0] = Math.min(dp[i-1][1],dp[i-1][2])+costs[i-1][0];
            dp[i][1] = Math.min(dp[i-1][0],dp[i-1][2])+costs[i-1][1];
            dp[i][2] = Math.min(dp[i-1][1],dp[i-1][0])+costs[i-1][2];
        }

        return Math.min(dp[n][0],Math.min(dp[n][1],dp[n][2]));
    }
}

---

五、最佳买卖股票时机含冷冻期

309. 买卖股票的最佳时机含冷冻期 - 力扣（LeetCode）

💡 细节：

1.状态表示这样可能更好理解一点：是否持有股票+明天是否可以购买股票

dp[i][0]: 第i天结束时，持有股票时的最大收益（即上面的”买入“）

dp[i][1]: 第i天结束时，不持有股票且明天可以购买股票时，最大收益（即上面的”可交易“）

dp[i][2]: 第i天结束时，不持有股票且明天不可以购买股票时，最大收益（即上面的”冷冻期“）

2.买入而未卖出的状态肯定无法获取最大利润，返回值直接不用考虑

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;

        int[][] dp = new int[n][3];

        dp[0][0] = -prices[0];

        for(int i=1;i<n;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][2]);
            dp[i][2] = dp[i-1][0] + prices[i];
        }

        //买入而未卖出的状态肯定无法获取最大利润，直接不用考虑
        return Math.max(dp[n-1][1],dp[n-1][2]);
    }
}

---

六、最佳买卖股票时机含手续费

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

💡细节：

1.状态表示还是根据是否持有股票来定义

2.返回值同上不用考虑还持有股票的情况

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int n = prices.length;

        int[] f = new int[n];//持有股票
        int[] g = new int[n];//不持有股票

        f[0] = -prices[0];

        for(int i=1;i<n;i++) {
            f[i] = Math.max(f[i-1],g[i-1]-prices[i]);
            g[i] = Math.max(g[i-1],f[i-1]+prices[i]-fee);//注意买入和卖出属于一次交易，只需要付一次手续费
        }

        return g[n-1];
    }
}

---

七、最佳买卖股票时机III

123. 买卖股票的最佳时机 III

💡 细节：

1.状态表示：是否持有股票+交易次数j次

2.初始化：f和g表的第一行都设置为负无穷，但是防止进行相加的时候会溢出，设置为0x3f3f3f3f

，除了f [0][0]为-p[0]，g[0][0]为0

3.细节处理：为了防止j-1为-1的情况出现，加入一个if判断

4.返回值为g表最后一行的最大值

class Solution {
    public int maxProfit(int[] prices) {
        int INF = 0x3f3f3f3f;
        int n = prices.length;

        int[][] f = new int[n][3];//i和j分别表示：持有股票+交易次数j次
        int[][] g = new int[n][3];

        for(int i=1;i<3;i++) {
            f[0][i] = g[0][i] = -INF;
        }
        f[0][0] = -prices[0];

        for(int i=1;i<n;i++) {
            for(int j=0;j<3;j++) {
                f[i][j]=Math.max(f[i-1][j],g[i-1][j]-prices[i]);
                //g[i][j]=Math.max(g[i-1][j],f[i-1][j-1]+prices[i]);
                g[i][j]=g[i-1][j];
                if(j-1>=0) g[i][j]=Math.max(g[i][j],f[i-1][j-1]+prices[i]);//防止j为-1
            }
        }
        
        //返回值：g表最后一行的最大值
        int ret = g[n-1][0];
        for(int i=1;i< 3;i++) ret = Math.max(ret,g[n-1][i]);
        return ret;

    }
}

---

八、最佳买卖股票时机IV

188. 买卖股票的最佳时机 IV

💡 细节：i天最多交易i/2次，那么可以进一步对k进行优化

class Solution {
    public int maxProfit(int k, int[] prices) {
        int INF = 0x3f3f3f3f;
        int n = prices.length;
        //细节优化
        k = Math.min(k,n/2);

        int[][] f = new int[n][k+1];
        int[][] g = new int[n][k+1];

        for(int i=1;i<k+1;i++) f[0][i] = g[0][i] = -INF;
        f[0][0] = -prices[0];

        for(int i=1;i<n;i++) {
            for(int j=0;j<k+1;j++) {
                f[i][j] = Math.max(f[i-1][j],g[i-1][j]-prices[i]);
                g[i][j] = g[i-1][j];
                if(j-1>=0) g[i][j]=Math.max(g[i][j],f[i-1][j-1]+prices[i]);
            }
        }

        int ret = g[n-1][0];
        for(int i=1;i<k+1;i++) ret = Math.max(ret,g[n-1][i]);
        return ret;
    }
}