365天挑战LeetCode1000题——Day 008 每日一题 + 历史遗留问题

---

前言

Yeah！！！
五点钟起来看球，凯子大胜，很棒！！！

---

1. 后继者

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

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

1.1 利用树的性质

两种情况：

• 有右儿子，那么找右儿子中的最左儿子；
• 没有右儿子，找左儿子为该节点的父亲（递归）；有可能找不到，递归到根节点那一层说明没找到。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode *realRoot;

    TreeNode* rightFather(TreeNode* root, TreeNode* p) {
        if (!root || p == realRoot) return nullptr;
        if (root->left == p) return root;
        if (root->right == p) return rightFather(realRoot, root);
        TreeNode *tmp = rightFather(root->left, p);
        if (tmp) return tmp;
        else return rightFather(root->right, p);
    }

    TreeNode* leftChild(TreeNode *p) {
        if (p->left) return leftChild(p->left);
        return p;
    }

    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
        realRoot = root;
        if (p->right) return leftChild(p->right);
        return rightFather(root, p);
    }
};

---

2. 最大三角形面积

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

2.1 枚举

已知三个点的坐标，它们的三角形公式为：

• $S=1/2(x_1(y_2-y_3)+x_2(y_3-y_1)+x_3(y_1-y_2))$

所以暴力枚举吧……

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

    double largestTriangleArea(vector<vector<int>> & points) {
        int n = points.size();
        double ret = 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++) {
                    ret = max(ret, triangleArea(points[i][0], points[i][1], points[j][0], points[j][1], points[k][0], points[k][1]));
                }
            }
        }
        return ret;
    }
};

2.2 凸包算法

高级……不会……

class Solution {
private:
    int cross(const vector<int> & p, const vector<int> & q, const vector<int> & r) {
        return (q[0] - p[0]) * (r[1] - q[1]) - (q[1] - p[1]) * (r[0] - q[0]);
    }

    vector<vector<int>> getConvexHull(vector<vector<int>>& points) {
        int n = points.size();
        if (n < 4) {
            return points;
        }
        /* 按照 x 大小进行排序，如果 x 相同，则按照 y 的大小进行排序 */
        sort(points.begin(), points.end(), [](const vector<int> & a, const vector<int> & b) {
            if (a[0] == b[0]) {
                return a[1] < b[1];
            }
            return a[0] < b[0];
        });
        vector<vector<int>> hull;
        /* 求出凸包的下半部分 */
        for (int i = 0; i < n; i++) {
            while (hull.size() > 1 && cross(hull[hull.size() - 2], hull.back(), points[i]) <= 0) {
                hull.pop_back();
            }
            hull.emplace_back(points[i]);
        }
        int m = hull.size();
        /* 求出凸包的上半部分 */
        for (int i = n - 2; i >= 0; i--) {
            while (hull.size() > m && cross(hull[hull.size() - 2], hull.back(), points[i]) <= 0) {
                hull.pop_back();
            }
            hull.emplace_back(points[i]);
        }
        /* hull[0] 同时参与凸包的上半部分检测，因此需去掉重复的 hull[0] */
        hull.pop_back();
        return hull;
    }

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

public:
    double largestTriangleArea(vector<vector<int>> & points) {
        auto convexHull = getConvexHull(points);
        int n = convexHull.size();
        double ret = 0.0;
        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 = max(ret, area);
            }
        }
        return ret;
    }
};

---

3. 毯子覆盖的最多白色砖块数

给你一个二维整数数组 tiles ，其中 tiles[i] = [li, ri] ，表示所有在 li <= j <= ri 之间的每个瓷砖位置 j 都被涂成了白色。

同时给你一个整数 carpetLen ，表示可以放在 任何位置 的一块毯子。

请你返回使用这块毯子，最多 可以盖住多少块瓷砖。

3.1 滑动窗口 + 双指针

双周赛的第三题，再一次倒下了唉……当时没想到最优的情况只能是从一个块的起始位置开始才行，傻乎乎地从头滑动窗口到尾，最后只过了80%的案例……
先证明下为什么一定要从一个块的起始位置开始：如果不从起始位置开始，则从任一块的位置开始，如果向右移动，左边减一，右边不清楚，严格劣势；如果向左移动，左边加一，右边不清楚，严格优势……
那么每次从块的起始位置开始，扫描能够覆盖的位置，动态规划，每次到下一个位置时，要减去当前起始位置所在的块覆盖长度。

class Solution {
public:
    int maximumWhiteTiles(vector<vector<int>>& tiles, int carpetLen) {
        sort(tiles.begin(), tiles.end());
        int n = tiles.size();
        int ans = 0;
        int cur = 0;
        int r = 0;

        for (int i = 0; i < n; i++) {
            int l = i;
            int start = tiles[l][0];
            while (r < n && tiles[r][1] - tiles[l][0] + 1 <= carpetLen) {
                cur += tiles[r][1] - tiles[r][0] + 1;
                r++;
            }
            int end = start + carpetLen - 1;
            if (r < n && end >= tiles[r][0]) {
                ans = max(ans, cur + end - tiles[r][0] + 1);
            }
            else {
                ans = max(ans, cur);
            }
            cur -= tiles[l][1] - tiles[l][0] + 1;
        }
        return ans;
    }
};

---

总结

这个系列这段时间得稍微修改一下了，因为老师布置了算法题目……
明天开始写算法老师布置的题目，最好能在LeetCode上找到原题罢……