LeetCode 391. 完美矩形（扫描线） / 318. 最大单词长度乘积 / 563. 二叉树的坡度
391. 完美矩形
2021.11.16 每日一题
题目描述
给你一个数组 rectangles ，其中 rectangles[i] = [xi, yi, ai, bi] 表示一个坐标轴平行的矩形。这个矩形的左下顶点是 (xi, yi) ，右上顶点是 (ai, bi) 。
如果所有矩形一起精确覆盖了某个矩形区域，则返回 true ；否则，返回 false 。
示例 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：
输入：rectangles = [[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]
输出：false
解释：两个矩形之间有间隔，无法覆盖成一个矩形。
示例 3：
输入：rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[3,2,4,4]]
输出：false
解释：图形顶端留有空缺，无法覆盖成一个矩形。
示例 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：
输入：root = [1,2,3]
输出：1
解释：
节点 2 的坡度：|0-0| = 0（没有子节点）
节点 3 的坡度：|0-0| = 0（没有子节点）
节点 1 的坡度：|2-3| = 1（左子树就是左子节点，所以和是 2 ；右子树就是右子节点，所以和是 3 ）
坡度总和：0 + 0 + 1 = 1
示例 2：
输入：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：
输入：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;
}
}