算法Day28|贪心专题五 ​ 714. 买卖股票的最佳时机含手续费，968. 监控二叉树

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

 1.题目描述

• 给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。
• 你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
• 返回获得利润的最大值。
• 注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

2.解题思路 

• 如果使用贪心策略，就是最低值买，最高值（如果算上手续费还盈利）就卖。

  此时无非就是要找到两个点，买入日期，和卖出日期。

  • 买入日期：其实很好想，遇到更低点就记录一下。
  • 卖出日期：这个就不好算了，但也没有必要算出准确的卖出日期，只要当前价格大于（最低价格+手续费），就可以收获利润，至于准确的卖出日期，就是连续收获利润区间里的最后一天（并不需要计算是具体哪一天）。

• 所以我们在做收获利润操作的时候其实有三种情况：

  • 情况一：收获利润的这一天并不是收获利润区间里的最后一天（不是真正的卖出，相当于持有股票），所以后面要继续收获利润。
  • 情况二：前一天是收获利润区间里的最后一天（相当于真正的卖出了），今天要重新记录最小价格了。
  • 情况三：不作操作，保持原有状态（买入，卖出，不买不卖）

3.代码实现

class Solution {
 //714. 买卖股票的最佳时机含手续费
    public int maxProfit(int[] prices, int fee) {
        int minPrice = prices[0];
        int res = 0;
        for (int i = 0; i < prices.length; i++) {
            //情况二：相当于买入
            if (prices[i] < minPrice) {
                minPrice = prices[i];
            }
            //情况三：保持原有状态（因为此时买则不便宜，卖则亏本）
            if (prices[i] >= minPrice && prices[i] <= minPrice + fee) {
                continue;
            }
            // 计算利润，可能有多次计算利润，最后一次计算利润才是真正意义的卖出
            if (prices[i] > minPrice + fee) {
                res += prices[i] - minPrice - fee;
                minPrice = prices[i] - fee;// 情况一，这一步很关键
            }
        }
        return res;
    }
}

从代码中可以看出对情况一的操作，因为如果还在收获利润的区间里，表示并不是真正的卖出，而计算利润每次都要减去手续费，所以要让minPrice = prices[i] - fee;，这样在明天收获利润的时候，才不会多减一次手续费！ 

968. 监控二叉树

1.题目描述

• 给定一个二叉树，我们在树的节点上安装摄像头。
• 节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。
• 计算监控树的所有节点所需的最小摄像头数量。

2.解题思路 

• 这道题目首先要想，如何放置，才能让摄像头最小的呢？
• 从题目中示例，其实可以得到启发，我们发现题目示例中的摄像头都没有放在叶子节点上！
  • 这是很重要的一个线索，摄像头可以覆盖上中下三层，如果把摄像头放在叶子节点上，就浪费的一层的覆盖。
  • 所以把摄像头放在叶子节点的父节点位置，才能充分利用摄像头的覆盖面积。
• 那么有同学可能问了，为什么不从头结点开始看起呢，为啥要从叶子节点看呢？
  • 因为头结点放不放摄像头也就省下一个摄像头， 叶子节点放不放摄像头省下了的摄像头数量是指数阶别的。
• 所以我们要从下往上看，局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少！
• 局部最优推出全局最优，找不出反例，那么就按照贪心来！
• 此时，大体思路就是从低到上，先给叶子节点父节点放个摄像头，然后隔两个节点放一个摄像头，直至到二叉树头结点。

• 此时这道题目还有两个难点：

  • 二叉树的遍历
  • 如何隔两个节点放一个摄像头

2.1 二叉树的遍历

• 在二叉树中如何从低向上推导呢？
• 可以使用后序遍历也就是左右中的顺序，这样就可以在回溯的过程中从下到上进行推导了。
• 后序遍历代码如下：

int traversal(TreeNode cur) {

    // 空节点，该节点有覆盖
    if (终止条件) return ;

    int left = traversal(cur.left);    // 左
    int right = traversal(cur.right);  // 右

    逻辑处理                            // 中
    return ;
}

 注意在以上代码中我们取了左孩子的返回值，右孩子的返回值，即left 和 right， 以后推导中间节点的状态

2.2 如何隔两个节点放一个摄像头

有如下三种情况：

• 该节点无覆盖
• 本节点有摄像头
• 本节点有覆盖

我们分别有三个数字来表示：

• 0：该节点无覆盖
• 1：本节点有摄像头
• 2：本节点有覆盖

• 大家应该找不出第四个节点的状态了。
• 一些同学可能会想有没有第四种状态：本节点无摄像头，其实无摄像头就是 无覆盖 或者 有覆盖的状态，所以一共还是三个状态。

3.代码实现

3.1递归函数定义（参数和返回值）

            递归函数定义：传入一个节点，输出这个节点的状态（0-无覆盖，1-有摄像头，2-有覆盖）。

代码如下：  

    //递归函数定义：传入一个节点，输出这个节点的状态（0-无覆盖，1-有摄像头，2-有覆盖）
    public int traversal(TreeNode cur) {}

3.2 递归终止条件

• 因为在遍历树的过程中，就会遇到空节点，那么问题来了，空节点究竟是哪一种状态呢？ 空节点表示无覆盖？ 表示有摄像头？还是有覆盖呢？
• 回归本质，为了让摄像头数量最少，我们要尽量让叶子节点的父节点安装摄像头，这样才能摄像头的数量最少。
• 那么空节点不能是无覆盖的状态，这样叶子节点就要放摄像头了，空节点也不能是有摄像头的状态，这样叶子节点的父节点就没有必要放摄像头了，而是可以把摄像头放在叶子节点的爷爷节点上。
• 所以空节点的状态只能是有覆盖，这样就可以在叶子节点的父节点放摄像头了

代码如下： 

        //终止条件：
        // 1.1不能为0（无覆盖），如果为无覆盖的话，叶子节点就要装摄像头了。
        // 1.2不能为1（有摄像头），假设节点为1->2->3->4,
        //    此时2位置就要放摄像头了，而叶子节点的父节点没摄像头。
        if (cur == null) {
            return 2;
        }

 3.3 单层递归逻辑

• 主要有如下四类情况：
• 情况1：左右节点都有覆盖
  • 左孩子有覆盖，右孩子有覆盖，那么此时中间节点应该就是无覆盖的状态了。

如图： 

 代码如下：

        int left = traversal(cur.left);
        int right = traversal(cur.right);
        // 情况1
        // 左右节点都有覆盖
        if (left == 2 && right == 2) {
            return 0;
        }

•  3.3 单层递归逻辑
•  情况2：左右节点至少有一个无覆盖的情况
•  如果是以下情况，则中间节点（父节点）应该放摄像头：
  • left == 0 && right == 0 左右节点无覆盖

  • left == 1 && right == 0 左节点有摄像头，右节点无覆盖

  • left == 0 && right == 1 左节点有无覆盖，右节点摄像头

  • left == 0 && right == 2 左节点无覆盖，右节点覆盖

  • left == 2 && right == 0 左节点覆盖，右节点无覆盖

• 这个不难理解，毕竟有一个孩子没有覆盖，父节点就应该放摄像头。

  此时摄像头的数量要加一，并且return 1，代表中间节点放摄像头。 

 代码如下：

        // 情况2
        // left == 0 && right == 0 左右节点无覆盖
        // left == 1 && right == 0 左节点有摄像头，右节点无覆盖
        // left == 0 && right == 1 左节点有无覆盖，右节点摄像头
        // left == 0 && right == 2 左节点无覆盖，右节点覆盖
        // left == 2 && right == 0 左节点覆盖，右节点无覆盖
        if (left == 0 || right == 0) {
            res++;
            return 1;
        }

•  3.3 单层递归逻辑
•  情况3：左右节点至少有一个有摄像头
•  如果是以下情况，其实就是 左右孩子节点有一个有摄像头了，那么其父节点就应该是2（覆盖的状态）：
  • left == 1 && right == 2 左节点有摄像头，右节点有覆盖

  • left == 2 && right == 1 左节点有覆盖，右节点有摄像头

  • left == 1 && right == 1 左右节点都有摄像头

• 这个不难理解，毕竟有一个孩子没有覆盖，父节点就应该放摄像头。

  此时摄像头的数量要加一，并且return 1，代表中间节点放摄像头。

代码如下：

        // 情况3
        // left == 1 && right == 2 左节点有摄像头，右节点有覆盖
        // left == 2 && right == 1 左节点有覆盖，右节点有摄像头
        // left == 1 && right == 1 左右节点都有摄像头
        // 其他情况前段代码均已覆盖
        if (left == 1 || right == 1) {
            return 2;
        }

 从这个代码中，可以看出，如果left == 1, right == 0 怎么办？其实这种条件在情况2中已经判断过了，如图：

•  3.3 单层递归逻辑
•  情况4：头结点没有覆盖
• 以上都处理完了，递归结束之后，可能头结点 还有一个无覆盖的情况，如图：

 所以递归结束之后，还要判断根节点，如果没有覆盖，result++，代码如下：

        // 情况4
        // root 无覆盖
        if (traversal(root) == 0) {
            res++;
        }

以上四种情况我们分析完了，代码也差不多了，整体代码如下：

（以下我的代码注释很详细，为了把情况说清楚，特别把每种情况列出来。）

class Solution {
      //968. 监控二叉树
    int res = 0;

    public int minCameraCover(TreeNode root) {
        // 情况4
        // root 无覆盖
        if (traversal(root) == 0) {
            res++;
        }
        return res;
    }

    //递归函数定义：传入一个节点，输出这个节点的状态（0-无覆盖，1-有摄像头，2-有覆盖）
    public int traversal(TreeNode cur) {
        //终止条件：
        // 1.1不能为0（无覆盖），如果为无覆盖的话，叶子节点就要装摄像头了。
        // 1.2不能为1（有摄像头），假设节点为1->2->3->4,
        //    此时2位置就要放摄像头了，而叶子节点的父节点没摄像头。
        if (cur == null) {
            return 2;
        }
        int left = traversal(cur.left);
        int right = traversal(cur.right);
        // 情况1
        // 左右节点都有覆盖
        if (left == 2 && right == 2) {
            return 0;
        }
        // 情况2
        // left == 0 && right == 0 左右节点无覆盖
        // left == 1 && right == 0 左节点有摄像头，右节点无覆盖
        // left == 0 && right == 1 左节点有无覆盖，右节点摄像头
        // left == 0 && right == 2 左节点无覆盖，右节点覆盖
        // left == 2 && right == 0 左节点覆盖，右节点无覆盖
        if (left == 0 || right == 0) {
            res++;
            return 1;
        }
        // 情况3
        // left == 1 && right == 2 左节点有摄像头，右节点有覆盖
        // left == 2 && right == 1 左节点有覆盖，右节点有摄像头
        // left == 1 && right == 1 左右节点都有摄像头
        // 其他情况前段代码均已覆盖
        if (left == 1 || right == 1) {
            return 2;
        }
        // 以上代码我没有使用else，主要是为了把各个分支条件展现出来
        // 这个 return -1 逻辑不会走到这里。
        return -1;
    }
}