LeetCode 391. 完美矩形(扫描线) / 318. 最大单词长度乘积 / 563. 二叉树的坡度

391. 完美矩形

2021.11.16 每日一题

题目描述

给你一个数组 rectangles ,其中 rectangles[i] = [xi, yi, ai, bi] 表示一个坐标轴平行的矩形。这个矩形的左下顶点是 (xi, yi) ,右上顶点是 (ai, bi) 。

如果所有矩形一起精确覆盖了某个矩形区域,则返回 true ;否则,返回 false 。

示例 1:

LeetCode 391. 完美矩形(扫描线) / 318. 最大单词长度乘积 / 563. 二叉树的坡度_第1张图片
输入:rectangles = [[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]
输出:true
解释:5 个矩形一起可以精确地覆盖一个矩形区域。

示例 2:

LeetCode 391. 完美矩形(扫描线) / 318. 最大单词长度乘积 / 563. 二叉树的坡度_第2张图片
输入:rectangles = [[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]
输出:false
解释:两个矩形之间有间隔,无法覆盖成一个矩形。

示例 3:

LeetCode 391. 完美矩形(扫描线) / 318. 最大单词长度乘积 / 563. 二叉树的坡度_第3张图片
输入:rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[3,2,4,4]]
输出:false
解释:图形顶端留有空缺,无法覆盖成一个矩形。

示例 4:

LeetCode 391. 完美矩形(扫描线) / 318. 最大单词长度乘积 / 563. 二叉树的坡度_第4张图片
输入:rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[2,2,4,4]]
输出:false
解释:因为中间有相交区域,虽然形成了矩形,但不是精确覆盖。

提示:

1 <= rectangles.length <= 2 * 10^4
rectangles[i].length == 4
-10^5 <= xi, yi, ai, bi <= 10^5

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/perfect-rectangle
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

思路

官解给的思路,就是按照面积和每个点出现的次数来做的

class Solution {
    public boolean isRectangleCover(int[][] rectangles) {
        //看了一下提示,扫描线,但是怎么扫描呢
        //将这个数组按照左下角排序
        //然后从左到右扫描,可以确定左边的起始位置和高度
        //然后如果补全了当前位置的高度,就向右边移动扫描线,如果不行就false

        //看了题解,感觉自己硬想扫描线去了,忘了最基础的东西
        //要想成为一个精确覆盖的矩形,那么所有矩形的面积之和,应该是和总面积相等的,这是一个大前提
        //但是光面积相等是不够的,因为比如在示例2中,如果还有一个矩形,它的下标是[1,3,4,4]
        //那么面积相加也是等于总面积的,但是并不是一个完美矩形,因为有重合部分
        //那么如果检测这部分呢,官解给出的方法是统计每个点的出现次数
        //如果是四个角的顶点,那么肯定只能出现一次
        //如果是其他顶点,那么出现两次或者四次是正常的,如果出现一次或者三次,说明肯定有没有拼接上的地方,所以false
        //那么按照这个思路写一下
        Map<Point, Integer> map = new HashMap<>();
        long area = 0;      //面积
        int leftdownX = Integer.MAX_VALUE;
        int leftdownY = Integer.MAX_VALUE;
        int rightupX = Integer.MIN_VALUE;
        int rightupY = Integer.MIN_VALUE;
        for(int[] rec : rectangles){
            int ldx = rec[0], ldy = rec[1], rux = rec[2], ruy = rec[3];
            area += (rux - ldx) * (ruy - ldy);
            leftdownX = Math.min(leftdownX, ldx);
            leftdownY = Math.min(leftdownY, ldy);
            rightupX = Math.max(rightupX, rux);
            rightupY = Math.max(rightupY, ruy);

            Point p1 = new Point(ldx, ldy);
            Point p2 = new Point(ldx, ruy);
            Point p3 = new Point(rux, ldy);
            Point p4 = new Point(rux, ruy);

            map.put(p1, map.getOrDefault(p1, 0) + 1);
            map.put(p2, map.getOrDefault(p2, 0) + 1);
            map.put(p3, map.getOrDefault(p3, 0) + 1);
            map.put(p4, map.getOrDefault(p4, 0) + 1);
        }
        /*
        System.out.println(area);
        System.out.println(leftdownX);
        System.out.println(leftdownY);
        System.out.println(rightupX);
        System.out.println(rightupY);
        */
        //四个角的顶点
        Point ld = new Point(leftdownX, leftdownY);
        Point lu = new Point(leftdownX, rightupY);
        Point rd = new Point(rightupX, leftdownY);
        Point ru = new Point(rightupX, rightupY);
        //如果面积不相等,直接false
        if(area != (rightupY - leftdownY) * (rightupX - leftdownX))
            return false;
        //如果角出现了多次,那么fasle
        if(map.getOrDefault(ld, 0) != 1 || map.getOrDefault(lu, 0) != 1 || map.getOrDefault(rd, 0) != 1 || map.getOrDefault(ru, 0) != 1)
            return false;

        map.remove(ld);
        map.remove(lu);
        map.remove(rd);
        map.remove(ru);
        //判断其他点
        for(Map.Entry<Point, Integer> entry : map.entrySet()){
            int count = entry.getValue();
            //如果不是出现了两次或者四次,那么就是false
            if(count != 2 && count != 4)
                return false;
        }
        return true;
    }
}

class Point{
    int x;
    int y;

    public Point(int x, int y){
        this.x = x;
        this.y = y;
    }

    public int hashCode(){
        return x + y;
    }

    public boolean equals(Object obj){
        if(this == obj)
            return true;
        if(obj == null)
            return false;
        if(obj instanceof Point){
            Point point = (Point)obj;
            return this.x == point.x && this.y == point.y;
        }
        return false;
    }
}

看三叶姐扫描线的做法
但是这个也需要发现这个题的特点,才能写出来这样的答案
三叶姐是将每个矩形用两条竖直方向的边(横坐标,竖直方向的下端点,竖直方向的上端点,是左边/右边的边)来表示,那么这样的话,左右两个边界的边就只有一条,而中间的边因为每个边会在两个矩形中出现,所以会出现两次

class Solution {
    public boolean isRectangleCover(int[][] rectangles) {
        //三叶姐的扫描线做法,将矩形用竖线表示
        //然后判断非边缘竖线是否出现两次,边缘竖线是否出现一次

        int n = rectangles.length;
        //先将所有边变成竖线
        int[][] rect = new int[n * 2][4];
        int idx = 0;
        for(int i = 0; i < n; i++){
            //当前矩形左边的边,1表示是右边的边
            rect[idx++] = new int[]{rectangles[i][0], rectangles[i][1], rectangles[i][3], 1};
            rect[idx++] = new int[]{rectangles[i][2], rectangles[i][1], rectangles[i][3], 0};
        }
        Arrays.sort(rect, (a, b) ->(a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]));

        //然后对这些边进行合并
        int l = 2 * n;
        List<int[]> left = new ArrayList<>();   //左边的边,也就是flag为0的边
        List<int[]> right = new ArrayList<>();  //右边的边,也就是flag为1的边
        
        //开始扫描
        for(int i = 0; i < l; ){
            int r = i;      //用一个新的变量代表右端点
            left.clear();
            right.clear();
            //找横坐标相同的部分
            while(r < l && rect[r][0] == rect[i][0])
                r++;
            //现在从i到r就是横坐标相同的部分    
            //放到list中进行拼接
            //注意rect是按照第二个下标从小到大排序的
            for(int j = i; j < r; j++){
                int[] cur = {rect[j][1], rect[j][2]};
                //找出此时是哪个list
                List<int[]> list = rect[j][3] == 0 ? left : right;
                //然后插入到这个list中,因为之前插入是按顺序来的,所以直接取出最上面的
                if(list.isEmpty()){
                    list.add(cur);
                }else{
                    int[] last = list.get(list.size() - 1);
                    //如果这两个范围相交了,那么false
                    if(last[1] > cur[0])    
                        return false;
                    //如果是相连的,那么连接
                    else if(last[1] == cur[0])
                        last[1] = cur[1];
                    else{
                        list.add(cur);
                    }
                }
            }
            //插入完当前下标以后,判断是否是成对的
            if(i > 0 && r < l){
                if(left.size() != right.size())
                    return false;
                for(int j = 0; j < left.size(); j++){
                    if(left.get(j)[0] != right.get(j)[0] || left.get(j)[1] != right.get(j)[1])
                        return false;
                }
            //如果是边缘的边,看是否是一条完整的边
            }else{
                if(left.size() + right.size() != 1)
                    return false;
            }
            //将i置为r
            i = r;
        }   
        return true;
    }
}

318. 最大单词长度乘积

2021.11.17 每日一题

题目描述

给定一个字符串数组 words,找到 length(word[i]) * length(word[j]) 的最大值,并且这两个单词不含有公共字母。你可以认为每个单词只包含小写字母。如果不存在这样的两个单词,返回 0。

示例 1:

输入: [“abcw”,“baz”,“foo”,“bar”,“xtfn”,“abcdef”]
输出: 16
解释: 这两个单词为 “abcw”, “xtfn”。

示例 2:

输入: [“a”,“ab”,“abc”,“d”,“cd”,“bcd”,“abcd”]
输出: 4
解释: 这两个单词为 “ab”, “cd”。

示例 3:

输入: [“a”,“aa”,“aaa”,“aaaa”]
输出: 0
解释: 不存在这样的两个单词。

提示:

2 <= words.length <= 1000
1 <= words[i].length <= 1000
words[i] 仅包含小写字母

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/maximum-product-of-word-lengths
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

思路

26位每一位表示对应字母是否存在
那个优化感觉作用不大

class Solution {
    public int maxProduct(String[] words) {
        //用26位表示每个单词中字母出现没有
        //然后异或来检查是否重复出现
        int n = words.length;
        int[] num = new int[n];
        for(int i = 0; i < n; i++){
            String s = words[i];
            for(char c : s.toCharArray()){
                int t = c - 'a';
                num[i] |= (1 << t);
            }
        }
        int max = 0;
        for(int i = 0; i < n; i++){
            String s1 = words[i];
            for(int j  = i + 1; j < n; j++){
                String s2 = words[j];
                boolean flag = true;
                /*
                for(int k = 0; k < 26; k++){
                    if(((num[i] >> k) & 1) == 1 && (((num[j] >> k) & 1) == 1)){
                        flag = false;
                        break;
                    }
                }
                */
                /*
                for(int t = num[i]; t > 0; t -= t & -t){
                    int temp = t & -t;
                    if((num[j] & temp) != 0){
                        flag = false;
                        break;
                    }
                }
                */
                if((num[i] & num[j]) == 0)
                    max = Math.max(max, s1.length() * s2.length());
            }
        }
        return max;
    }
}

563. 二叉树的坡度

2021.11.18 每日一题

题目描述

给定一个二叉树,计算 整个树 的坡度 。

一个树的 节点的坡度 定义即为,该节点左子树的节点之和和右子树节点之和的 差的绝对值 。如果没有左子树的话,左子树的节点之和为 0 ;没有右子树的话也是一样。空结点的坡度是 0 。

整个树 的坡度就是其所有节点的坡度之和。

示例 1:

LeetCode 391. 完美矩形(扫描线) / 318. 最大单词长度乘积 / 563. 二叉树的坡度_第5张图片
输入:root = [1,2,3]
输出:1
解释:
节点 2 的坡度:|0-0| = 0(没有子节点)
节点 3 的坡度:|0-0| = 0(没有子节点)
节点 1 的坡度:|2-3| = 1(左子树就是左子节点,所以和是 2 ;右子树就是右子节点,所以和是 3 )
坡度总和:0 + 0 + 1 = 1

示例 2:

LeetCode 391. 完美矩形(扫描线) / 318. 最大单词长度乘积 / 563. 二叉树的坡度_第6张图片
输入:root = [4,2,9,3,5,null,7]
输出:15
解释:
节点 3 的坡度:|0-0| = 0(没有子节点)
节点 5 的坡度:|0-0| = 0(没有子节点)
节点 7 的坡度:|0-0| = 0(没有子节点)
节点 2 的坡度:|3-5| = 2(左子树就是左子节点,所以和是 3 ;右子树就是右子节点,所以和是 5 )
节点 9 的坡度:|0-7| = 7(没有左子树,所以和是 0 ;右子树正好是右子节点,所以和是 7 )
节点 4 的坡度:|(3+5+2)-(9+7)| = |10-16| = 6(左子树值为 3、5 和 2 ,和是 10 ;右子树值为 9 和 7 ,和是 16 )
坡度总和:0 + 0 + 0 + 2 + 7 + 6 = 15

示例 3:

LeetCode 391. 完美矩形(扫描线) / 318. 最大单词长度乘积 / 563. 二叉树的坡度_第7张图片
输入:root = [21,7,14,1,1,2,2,3,3]
输出:9

提示:

树中节点数目的范围在 [0, 104] 内
-1000 <= Node.val <= 1000

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/binary-tree-tilt
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

思路

一个简单的二叉树后序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int sum = 0;
    public int findTilt(TreeNode root) {
        //坡度,后序遍历吧
        dfs(root);
        return sum;
    }
    
    public int dfs(TreeNode root){
        if(root == null)
            return 0;
        int left = dfs(root.left);
        int right = dfs(root.right);
        int po = Math.abs(left - right);
        sum += po;
        return left + right + root.val;
    }
}

你可能感兴趣的:(LeetCode,java,leetcode)