动态规划部分（二）

这一题的思路是分别去掉头和尾来进行上一题的打劫计算，所以相当于把原来的思路来两边。我自己写的代码如下

class Solution {
    public int rob(int[] nums) {
        //核心关键考虑是否包含首尾，这样需要考虑的元素个数就变成数组个数-1个
        if (nums.length == 1) return nums[0];
        if (nums.length == 2) return Math.max(nums[0],nums[1]);
        int[] dp = new int[nums.length-1];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0],nums[1]);
        //去掉尾部
        for (int i = 2; i < nums.length-1; ++i) {
            dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i]);
        }
        int m = dp[nums.length-2];
        //去掉头部
        Arrays.fill(dp,0);//重新更换数组的值
        dp[0] = nums[1];
        dp[1] = Math.max(nums[1],nums[2]);
        for (int i = 2; i < nums.length-1; ++i) {
            dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i+1]);
        }
        int n = dp[nums.length-2];
        return Math.max(m,n);
    }
}

 对于这种整体结构相类似的可以封装成函数，替换相关参数来进行。

参考下面c语言的思路

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        if (nums.size() == 1) return nums[0];
        int result1 = robRange(nums, 0, nums.size() - 2); // 情况二
        int result2 = robRange(nums, 1, nums.size() - 1); // 情况三
        return max(result1, result2);
    }
    // 198.打家劫舍的逻辑
    int robRange(vector<int>& nums, int start, int end) {
        if (end == start) return nums[start];
        vector<int> dp(nums.size());
        dp[start] = nums[start];
        dp[start + 1] = max(nums[start], nums[start + 1]);
        for (int i = start + 2; i <= end; i++) {
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[end];
    }
};

数的后续遍历，参考代码随想录的思路

class Solution {
    public int rob(TreeNode root) {
        int[] res = robAction1(root);
        return Math.max(res[0], res[1]);
    }
    int[] robAction1(TreeNode root) {
        int res[] = new int[2];
        if (root == null)
            return res;

        int[] left = robAction1(root.left);
        int[] right = robAction1(root.right);

        res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        res[1] = root.val + left[0] + right[0];
        return res;
    }
}

更像是按深度遍历，按照深度遍历的思路思考代码

 

注意对此类问题状态的分析，这一题的状态分为没有操作0，第一次买入1，第一次卖出2，第二次买入3，第二次卖出4.要注意没有操作的时候收益总为0。在状态明确后，就是要对初始状态进行确定。

class Solution {
    public int maxProfit(int[] prices) {
        //将每天的装填分为5个状态
        int len = prices.length;
        if (len == 1) return 0;
        int[][] dp = new int[len][5]; //设置二维数组，按照股票天数还有5个状态来分
        dp[0][1] = -prices[0];
        dp[0][3] = -prices[0];
        for (int i = 1; i < len; ++i) {
            //一个是之前就已经是此操作，还有就是今天才采取
            dp[i][1] = Math.max(dp[i-1][1], - prices[i]); // 要注意状态为0的时候默认为0
            dp[i][2] = Math.max(dp[i-1][2],dp[i-1][1] + prices[i]);
            dp[i][3] = Math.max(dp[i-1][3],dp[i-1][2] - prices[i]);
            dp[i][4] = Math.max(dp[i-1][4],dp[i-1][3] + prices[i]);
        }
        return dp[len-1][4];
    }
}

 

股票问题的总结，步骤是流程化的，dp数组怎么定义，最后要求的结果是什么，在第1天的时候如何初始化，以及第i天买入和卖出下的收益值如何获得。这一题是当状态为奇数时是买入状态，为偶数时是卖出状态，是上一题的一般情况化。

class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices.length == 0 || prices.length == 1 || k == 0) return 0;
        int[][] dp = new int[prices.length][2*k + 1];
        //初始化
        for (int i = 1; i <= k; ++i) {
            //当为奇数的时候，就进行买入
            dp[0][2*i - 1] = -prices[0];
        }
        //动态规划
        for (int i = 1; i < prices.length; ++i) {
            //2k个买入卖出状态按照奇偶进行遍历
            for (int j = 0; j < 2*k - 1; j += 2) {
                //买入状态
                dp[i][j+1] = Math.max(dp[i-1][j+1],dp[i-1][j] - prices[i]);
                //卖出状态
                dp[i][j+2] = Math.max(dp[i-1][j+2],dp[i-1][j+1] + prices[i]);
            }
        }
        return dp[prices.length-1][2*k];
    }
}

 

股票问题的划分，要注意加入了冷冻期，这里要将状态分为四个，

0：表示买入状态，可以是前一天就是买入状态，也可以之前是卖出状态，今天买入，也可以前一天是卖出状态，今天买入

1：表示持续的卖出状态，可以之前就是此状态，也可以前一天是冷冻状态

2：表示当天卖出状态，这里要注意，当天买入当天卖出是没有意义的，在以上分析过程中不高喊，所以此状态前一天是买入状态0

3：表示冷冻状态，和前一天的刚卖出状态相同

之后就是根据以上分析写出递推公式，分析初始状态，得到表达式

class Solution {
    public int maxProfit(int[] prices) {
        
        //将状态分为四种，买入状态，卖出状态，当天卖出状态，还有冷冻状态
        int[][] dp = new int[prices.length][4];
        int n = prices.length;
        if (n == 0) return 0;
        dp[0][0] = -prices[0];
        //注意第1天剩下的三个状态初始值都为0
        for (int i= 1; i < prices.length; ++i) {
            //0为买入状态，可以是之前就买入，可以是之前就是卖出状态买入，也可以是之前是冷冻状态买入
            dp[i][0] = Math.max(dp[i-1][0], Math.max(dp[i-1][1] - prices[i], dp[i-1][3] - prices[i]));
            //1为持续的卖出状态，之前就是卖出，或者之前是冷冻期
            dp[i][1] = Math.max(dp[i-1][1], dp[i-1][3]);
            //2为卖出状态，不取当天买入当天卖出，没有意义
            dp[i][2] = dp[i-1][0] + prices[i];
            //3为冷冻状态,紧接在状态2之后
            dp[i][3] = dp[i-1][2];
        }
        return Math.max(dp[n-1][3], Math.max(dp[n-1][2], dp[n-1][1]));
    }
}

class Solution {
    public int maxProfit(int[] prices, int fee) {
        int n = prices.length;
        if(n == 0) return 0;
        // 如果最后算的结果扣掉税率为负，那么最后结果应该默认为0
        int[][] dp = new int[prices.length][3];
        dp[0][1] = -prices[0];
        for (int i = 1; i < prices.length; ++i) {
            //0代表之前一直没有操作的状态,所以默认结果是0的
            //1代表买入状态，可以是之前买入的，也可以是之前就是卖出状态买入的，也可以之前操作过
            dp[i][1] = Math.max(dp[i-1][1],Math.max(dp[i-1][0]-prices[i],dp[i-1][2]-prices[i]));
            //2代表是卖出状态，可以之前就是卖出的，或者之前是买入状态
            dp[i][2] = Math.max(dp[i-1][2], dp[i-1][1] + prices[i] - fee);
        }
        return Math.max(dp[n-1][0],dp[n-1][2]);
    }
}

 以上是我自己的代码，对于状态划分为三个，取查看代码随想录，关于二个状态以及动态规划一维数组的方法