LeetCode 812. 最大三角形面积（再次用到凸包的Andrew算法） / 面试题 04.06. 后继者 / 953. 验证外星语词典

812. 最大三角形面积

2022.5.15 每日一题

题目描述

给定包含多个点的集合，从其中取三个点组成三角形，返回能组成的最大三角形的面积。

示例:
输入: points = [[0,0],[0,1],[1,0],[0,2],[2,0]]
输出: 2
解释: 
这五个点如下图所示。组成的橙色三角形是最大的，面积为2。

注意:

3 <= points.length <= 50.
不存在重复的点。
-50 <= points[i][j] <= 50.
结果误差值在 10^-6 以内都认为是正确答案。

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

思路

第一个方法，枚举
需要知道怎么通过三个点来计算三角形面积
可以通过如下行列式或者向量来推导
或者下面这个梯形的解释，很巧妙
https://leetcode.cn/problems/largest-triangle-area/solution/by-fuxuemingzhu-czdh/

class Solution {
    public double largestTriangleArea(int[][] points) {
        //发现一碰到这种题就懵了，即使是个简单题
        //组成三角形需要三个点，那么选哪三个点才能使组成的三角形面积最大呢
        //还有一个问题，就是给定三个点，怎么计算面积，都忘了

        //查了一下，给定三个点A(x1,y1),B(x2,y2)，C(x3,y3)
        //利用向量的运算法则，求出sinA
        //得到三角形三点式的面积计算公式 S=1/2*abs(x1y2-x1y3+x2y3-x2y1+x3y1-x3y2)

        //这样的话最简单的方法就是遍历所有点组成的所有情况了
        //或者可能和那次那个几何题一样，但是想不起来了

        int n = points.length;
        double area = 0.0;
        for(int i = 0; i < n; i++){
            for(int j = i + 1; j < n; j++){
                for(int k = j + 1; k < n; k++){
                    area = Math.max(area, cal(points[i], points[j], points[k]));
                }
            }
        }
        return area;
    }

    public double cal(int[] a, int[] b, int[] c){
        return 0.5 * Math.abs(a[0] * b[1] - a[0] * c[1] + b[0] * c[1] - b[0] * a[1] + c[0] * a[1] - c[0] * b[1]);
    }
}

不枚举有什么办法吗，和那个凸包问题一样
官解的思路，先用Andrew算法求出一个凸包，然后再在凸包上找点构成三角形

class Solution {
    public double largestTriangleArea(int[][] points) {
        //给官解加注释
        //找到构成凸包的点
        int[][] convexHull = getConvexHull(points);
        int n = convexHull.length;
        double ret = 0.0;
        //找到点以后枚举凸包上的点，因为随着k点的枚举，面积是先增大后减小，
        //有一个最大值，找到这个最大值就是当前ij边能构成的最大面积
        //枚举所有的i点和j点就可以了
        for (int i = 0; i < n; i++) {
            for (int j = i + 1, k = i + 2; j + 1 < n; j++) {
                while (k + 1 < n) {
                    double curArea = triangleArea(convexHull[i][0], convexHull[i][1], convexHull[j][0], convexHull[j][1], convexHull[k][0], convexHull[k][1]);
                    double nextArea = triangleArea(convexHull[i][0], convexHull[i][1], convexHull[j][0], convexHull[j][1], convexHull[k + 1][0], convexHull[k + 1][1]);
                    if (curArea >= nextArea) {
                        break;
                    }
                    k++;
                }
                double area = triangleArea(convexHull[i][0], convexHull[i][1], convexHull[j][0], convexHull[j][1], convexHull[k][0], convexHull[k][1]);
                ret = Math.max(ret, area);
            }
        }
        return ret;
    }

    //Andrew算法求解凸包
    public int[][] getConvexHull(int[][] points) {
        int n = points.length;
        if (n < 4) {
            return points;
        }
        /* 按照 x 大小进行排序，如果 x 相同，则按照 y 的大小进行排序 */
        Arrays.sort(points, (a, b) -> {
            if (a[0] == b[0]) {
                return a[1] - b[1];
            }
            return a[0] - b[0];
        });
        List<int[]> hull = new ArrayList<int[]>();
        /* 求出凸包的下半部分 */
        for (int i = 0; i < n; i++) {
            //利用向量的叉积来判断是否可以构成凸包，如果小于等于0，那么说明这样连线的话会凹进去，所以需要将栈顶弹出，继续判断
            while (hull.size() > 1 && cross(hull.get(hull.size() - 2), hull.get(hull.size() - 1), points[i]) <= 0) {
                hull.remove(hull.size() - 1);
            }
            hull.add(points[i]);
        }
        int m = hull.size();
        /* 求出凸包的上半部分 */
        for (int i = n - 2; i >= 0; i--) {
            while (hull.size() > m && cross(hull.get(hull.size() - 2), hull.get(hull.size() - 1), points[i]) <= 0) {
                hull.remove(hull.size() - 1);
            }
            hull.add(points[i]);
        }
        /* hull[0] 同时参与凸包的上半部分检测，因此需去掉重复的 hull[0] */
        hull.remove(hull.size() - 1);
        m = hull.size();
        int[][] hullArr = new int[m][];
        for (int i = 0; i < m; i++) {
            hullArr[i] = hull.get(i);
        }
        return hullArr;
    }

    public double triangleArea(int x1, int y1, int x2, int y2, int x3, int y3) {
        return 0.5 * Math.abs(x1 * y2 + x2 * y3 + x3 * y1 - x1 * y3 - x2 * y1 - x3 * y2);
    }

    public int cross(int[] p, int[] q, int[] r) {
        return (q[0] - p[0]) * (r[1] - q[1]) - (q[1] - p[1]) * (r[0] - q[0]);
    }
}

面试题 04.06. 后继者

2022.5.16 每日一题

题目描述

设计一个算法，找出二叉搜索树中指定节点的“下一个”节点（也即中序后继）。

如果指定节点没有对应的“下一个”节点，则返回null。

示例 1:

输入: root = [2,1,3], p = 1

  2
 / \
1   3

输出: 2

示例 2:

输入: root = [5,3,6,2,4,null,null,1], p = 6

      5
     / \
    3   6
   / \
  2   4
 /   
1

输出: null

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

思路

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    TreeNode p;
    TreeNode res;
    TreeNode pre;
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        //直接中序遍历找后续就完事了呗
        this.p = p;
        pre = null;
        inOrder(root);
        return res;
    }

    public void inOrder(TreeNode root){
        if(root == null)
            return;
        //先往左遍历
        inOrder(root.left);
        //如果遍历到当前节点的时候，pre和p相同，那么返回当前结点
        if(pre == p)
            res = root;
        pre = root;
        inOrder(root.right);
    }
}

利用左小右大的性质

class Solution {
    
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        //利用大小性质
        if(root == null)
            return null;
        if(root.val <= p.val){
            return inorderSuccessor(root.right, p);
        }
        //此时后续都是大于p的值的，那么就向左遍历找到第一个大于p的值
        TreeNode res = inorderSuccessor(root.left, p);
        //对于找到的值，如果left为空的话，那么就返回当前值，如果不为空，那么返回找到的值
        return res == null ? root : res;
    }
}

先找p的右子树，因为右子树的值都是大于p的，找右子树上最左边的节点
如果没有右子树，那么从根节点找，如果根节点的值大于p，那么向左找，并且赋值；如果小于等于p，那么往右边找，直到正好找到第一个大于p的

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        TreeNode res = null;
        //在右子树上找最左边的节点
        if(p.right != null){
            res = p.right;
            while(res.left != null){
                res = res.left;
            }
            return res;
        }

        //如果它的右子树为空的话，那么后继节点就应该在她的父节点的部分
        //从根找
        while(root != null){
            //如果根节点值大于p，那么向左找
            if(root.val > p.val){
                res = root;
                root = root.left;
            //如果根节点值小于p，那么向右找
            }else{
                root = root.right;
            }
        }
        return res;
        
    }
}

直接从根找

class Solution {
    
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        TreeNode res = null;

        //从根找
        while(root != null){
            //如果根节点值大于p，那么向左找
            if(root.val > p.val){
                res = root;
                root = root.left;
            //如果根节点值小于p，那么向右找
            }else{
                root = root.right;
            }
        }
        return res;
        
    }
}

953. 验证外星语词典

2022.5.17 每日一题

题目描述

某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。

给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。

示例 1：

输入：words = [“hello”,“leetcode”], order = “hlabcdefgijkmnopqrstuvwxyz”
输出：true
解释：在该语言的字母表中，‘h’ 位于 ‘l’ 之前，所以单词序列是按字典序排列的。

示例 2：

输入：words = [“word”,“world”,“row”], order = “worldabcefghijkmnpqstuvxyz”
输出：false
解释：在该语言的字母表中，‘d’ 位于 ‘l’ 之后，那么 words[0] > words[1]，因此单词序列不是按字典序排列的。

示例 3：

输入：words = [“apple”,“app”], order = “abcdefghijklmnopqrstuvwxyz”
输出：false
解释：当前三个字符 “app” 匹配时，第二个字符串相对短一些，然后根据词典编纂规则 “apple” > “app”，因为 ‘l’ > ‘∅’，其中 ‘∅’ 是空白字符，定义为比任何其他字符都小（更多信息）。

提示：

1 <= words.length <= 100
1 <= words[i].length <= 20
order.length == 26
在 words[i] 和 order 中的所有字符都是英文小写字母。

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

思路

逐个比较就行了

class Solution {
    public boolean isAlienSorted(String[] words, String order) {
        //本来想着写比较函数的，好像很麻烦
        //逐个比较两个单词的大小
        int l = words.length;
        for(int i = 1; i < l; i++){
            String a = words[i - 1];
            String b = words[i];
            for(int j = 0; j < a.length(); j++){
                //如果长度大于b了，那么直接false
                if(j >= b.length())
                    return false;
                char x = a.charAt(j);
                char y = b.charAt(j);
                //如果前者比后者顺序靠后
                if(order.indexOf(x) > order.indexOf(y))
                    return false;
                if(order.indexOf(x) < order.indexOf(y))
                    break;
            }
        }
        return true;
    }
}