LeetCode664. 奇怪的打印机 / 剑指 Offer 55 - I. 二叉树的深度 / 剑指 Offer 55 - II. 平衡二叉树

Posted 2021-06-21 Zephyr丶J

664. 奇怪的打印机

2021.5.24 每日一题，又开始新的一周了

题目描述

有台奇怪的打印机有以下两个特殊要求：

打印机每次只能打印由 同一个字符 组成的序列。
每次可以在任意起始和结束位置打印新字符，并且会覆盖掉原来已有的字符。
给你一个字符串 s ，你的任务是计算这个打印机打印它需要的最少打印次数。

 
示例 1：

输入：s = "aaabbb"
输出：2
解释：首先打印 "aaa" 然后打印 "bbb"。
示例 2：

输入：s = "aba"
输出：2
解释：首先打印 "aaa" 然后在第二个位置打印 "b" 覆盖掉原来的字符 'a'。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/strange-printer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

这个动态规划没想出来，刚开始也没往这边想，想的是有什么技巧（每次都打印整个剩余长度的字符串）

定义dp[i][j]表示打印i到j最少需要多少次
如果s[i] = s[j], dp[i][j] = min(dp[i + 1][j], dp[i][j - 1]),打印i的同时打印j，不需要额外再打印一次
如果不相同，那么两边需要分别打印，也就是将区间分成两部分[i,k][k + 1, j]，然后计算各个k的最小值
那遍历顺序呢，dp[i][j]和dp[i+][j] 和dp[i][j-]有关，因此i从大到小，j从小到大

class Solution {
    public int strangePrinter(String s) {
        //怎么看不懂这个题啊，啥意思，大概明白了，就是每次打印字符的数量是随意的
        //不过只能从开始和结尾打印，并且打印只能由同一个字符组成
        //感觉这题说的也不严谨，如果打印了与开头末尾相同的字符，那么下次打印是从下一个字符开始还是覆盖以后的地方开始
        //应该是覆盖到哪就从哪里开始
        
        //动态规划，dp表示打印i到j最少需要多少次
        int l = s.length();

        int[][] dp = new int[l][l];

        //初始化
        for(int i = 0; i < l; i++){
            dp[i][i] = 1;
        }
        char[] ss = s.toCharArray();
        //如果s[i] = s[j], dp[i][j] = min(dp[i + 1][j], dp[i][j - 1]),打印i的同时打印j
        //如果不相同，那么两边需要分别打印，也就是将区间分成两部分[i,k][k + 1, j]，然后计算各个k的最小值

        //那遍历顺序呢，dp[i][j]和dp[i+][j] 和dp[i][j-]有关，因此i从大到小，j从小到大
        for(int i = l - 2; i >= 0; i--){
            for(int j = i + 1; j < l; j++){
                if(ss[i] == ss[j]){
                    dp[i][j] = Math.min(dp[i + 1][j], dp[i][j - 1]);
                }else{
                    dp[i][j] = 100;		//字符串最长100
                    for(int k = i; k < j; k++){
                        dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k + 1][j]);
                    }
                }
            }   
        }
        return dp[0][l - 1];
    }
}

剑指 Offer 55 - I. 二叉树的深度

题目描述

输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

例如：

给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \\
  9  20
    /  \\
   15   7
返回它的最大深度 3 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

层序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        //层序遍历吧
        int k = 0;
        Queue<TreeNode> queue = new LinkedList<>();
        if(root != null)
            queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            while(size > 0){
                TreeNode node = queue.poll();
                if(node.left != null)
                    queue.offer(node.left);
                if(node.right != null)
                    queue.offer(node.right);
                size--;
            }
            k++;
        }
        return k;
    }
}

递归，当前子树的深度，就等于左子树深度与右子树深度的较大值加1

class Solution {
    public int maxDepth(TreeNode root) {
        //再写个递归的
        if(root == null)
            return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

剑指 Offer 55 - II. 平衡二叉树

题目描述

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。


示例 1:

给定二叉树 [3,9,20,null,null,15,7]

    3
   / \\
  9  20
    /  \\
   15   7
返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

       1
      / \\
     2   2
    / \\
   3   3
  / \\
 4   4
返回 false 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ping-heng-er-cha-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

做了上一题，这个题有个很容易想到的思路就是判断每个子树是否是平衡二叉树，即判断每个子树的左右子树高度之差是否小于等于1，但是这样会重复遍历遍历多次单个节点，因此想更加优化的方法
就是从底部到顶部计算高度，采用后序遍历，先从底部节点开始判断是否是一颗平衡二叉树，如果是，就返回当前子树的高度，也就是左右子树高度的较大值加1，如果不是返回-1；并且加入剪枝，即如果已经判断到一个子树不是平衡二叉树了，就直接返回-1

class Solution {
    public boolean isBalanced(TreeNode root) {
        //是一个平衡二叉树要求当前结点的左右子树高度之差，不能大于1；同时子树也要求是平衡二叉树
        return helper(root) >= 0; 
    }

    public int helper(TreeNode root){
        if(root == null)
            return 0;
        int left = helper(root.left);
        int right = helper(root.right);

        //如果左右子树有一个不是平衡二叉树，就不行
        if(left == -1 || right == -1)
            return -1;
        //如果左右子树高度相差小于等于1，那么当前高度就是左右子树高度+1
        if(Math.abs(left - right) <= 1)
            return Math.max(left, right) + 1;
        return -1;
    }
}