LeetCode第233场周赛

最新推荐文章于 2022-02-27 14:31:20 发布

王劭阳

最新推荐文章于 2022-02-27 14:31:20 发布

阅读量126

点赞数

分类专栏： LeetCode周赛

本文链接：https://blog.csdn.net/qq_36059561/article/details/115070714

版权

LeetCode周赛专栏收录该内容

15 篇文章 0 订阅

订阅专栏

周赛地址：https://leetcode-cn.com/contest/weekly-contest-233/

第一题：最大升序子数组和

题目要求连续上升子数组的和最大，进行遍历，对比当前元素和前一个元素的大小关系。

当 $a [i - 1] < a [i]$ 的时候，此时是递增的，累加a[i]到current中，用max一直维护current的最大值。
当 $a [i - 1] \geq a [i]$ 的时候，此时递增停止，那么让current=a[i]，从而继续求和。

class Solution {
    public int maxAscendingSum(int[] nums) {
        int max = nums[0];
        int current = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[i - 1]) {
                current += nums[i];
                max = Math.max(max, current);
            } else {
                current = nums[i];
            }
        }
        return max;
    }
}

首先把题目看懂，题目描述有点长，耐心看完，会发现题目思路并不难。
如果订单是buy，先检查sell的队列里，有没有可以合并的，合并条件是：sell的最低价格≤当前buy的价格。
如果订单是sell，先检查buy的队列里，有没有可以合并的，合并条件是：buy的最高价格≥当前sell的价格。
于是sell用小顶堆，buy用大顶堆，Java里就用优先队列即可，并告知优先队列的排序规则。
订单的数量最大是 $10^{9}$ ，所以不可能能把每个订单放进去，而是放一个对象进去，所以也就有了Order类，这里用length=2的数组更节省空间。
每次合并的时候，考虑count的比较和处理。

class Solution {
    public int getNumberOfBacklogOrders(int[][] orders) {
        PriorityQueue<Order> buyPriorityQueue = new PriorityQueue<>(Comparator.comparingInt(order -> -order.price));
        PriorityQueue<Order> sellPriorityQueue = new PriorityQueue<>(Comparator.comparingInt(order -> order.price));
        for (int[] order : orders) {
            if (order[2] == 0) {// buy
                while (!sellPriorityQueue.isEmpty()) {
                    Order sell = sellPriorityQueue.poll();
                    if (sell.price <= order[0]) {
                        if (sell.count > order[1]) {
                            sell.count -= order[1];
                            order[1] = 0;
                            sellPriorityQueue.offer(sell);
                            break;
                        } else {
                            order[1] -= sell.count;
                        }
                    } else {
                        sellPriorityQueue.offer(sell);
                        break;
                    }
                }
                if (order[1] > 0) {
                    buyPriorityQueue.offer(new Order(order[0], order[1]));
                }
            } else {// sell
                while (!buyPriorityQueue.isEmpty()) {
                    Order buy = buyPriorityQueue.poll();
                    if (buy.price >= order[0]) {
                        if (buy.count > order[1]) {
                            buy.count -= order[1];
                            order[1] = 0;
                            buyPriorityQueue.offer(buy);
                            break;
                        } else {
                            order[1] -= buy.count;
                        }
                    } else {
                        buyPriorityQueue.offer(buy);
                        break;
                    }
                }
                if (order[1] > 0) {
                    sellPriorityQueue.offer(new Order(order[0], order[1]));
                }
            }
        }
        long result = 0;
        while (!buyPriorityQueue.isEmpty()) {
            result += buyPriorityQueue.poll().count;
        }
        while (!sellPriorityQueue.isEmpty()) {
            result += sellPriorityQueue.poll().count;
        }
        return (int) (result % 1000000007);
    }

    static class Order {
        int price, count;

        public Order(int price, int count) {
            this.price = price;
            this.count = count;
        }
    }
}

第三题：有界数组中指定下标处的最大值

先理解题目描述的条件：

数组长度是n。
nums[i]是正整数，最小为1。
相邻的数字差值只能是0、±1。
元素和不超过maxSum。
使nums[index]最大化。

观察题目给的例子，将数值想象成高度，那么，整个数组画出来就是一个小山的样子，index位置是小山最高点。两侧依次递减如果递减到1，不继续递减，保持1直到数组的两端，当然，也可以还没减到1就碰到数组的边界了。所以这里计算的时候，要注意边界的取值范围。
有了这个直观的视觉感受，就考虑求和判断了，求和就是等差数列前n项和公式： $S=\frac{(a_{1}+a_{n}) \times n}{2}$ ，能用公式就用公式，可别一个一个加去，太浪费时间了。
这里再次强调一下爆int的问题，两个int相乘，结果是int，结果可能会爆int，此时就出错了，在用long接收int相乘的结果时，先把int强转成long再进行乘法运算，因为这个wa了好几次。
设nums[index]的值是x，x的最小值是maxSum/n，最大值是maxSum，因为要求nums[index]的最大值，相当于二分法求满足条件的右边界。

class Solution {
    public int maxValue(int n, int index, int maxSum) {
        int left = maxSum / n, right = maxSum;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            long sum = getSum(index, n, mid);
            if (sum > maxSum) {
                right = mid - 1;
            } else if (sum < maxSum) {
                left = mid + 1;
            } else {
                left = mid + 1;
            }
        }
        // 题目没有提及无解的情况，实际这个if是不会走的
        if (right == -1 || getSum(index, n, right) > maxSum) {
            return -1;
        }
        return right;
    }

    // 计算a[index]=value的时候，整个数组的和
    private long getSum(int index, int length, int value) {
        long sum = 0;
        // a0的意思是a[0]的值，an_1的意思是a[n-1]的值，先按照-1的递减规则，减到数组的边界
        long a0 = value - index, an_1 = value - (length - index - 1);
        // 判断边界值分类计算和
        if (a0 >= 1) {
            sum += (a0 + value) * (index + 1) / 2;
        } else {
            sum += (long) (1 + value) * value / 2 + (index - value + 1);
        }
        if (an_1 >= 1) {
            sum += (an_1 + value) * (length - index) / 2;
        } else {
            sum += (long) (1 + value) * value / 2 + (length - index - value);
        }
        return sum - value;// 在计算左右侧的和时，value会被计算两次，所以需要减去一次
    }
}

第四题：统计异或值在范围内的数对有多少

题目的标签是字典树。
先说下朴素做法，分别取出 $i$ 和 $j$ ，满足 $0 \leq i < j \leq n u m s . l e n g t h$ 。对于每个 $(i, j)$ 对，去求 $\bigoplus nums[j]$ 的值，如果在 $[l o w, h i g h]$ 范围内，计数器加一。
看下数据范围， $\times 10^{4}$ ，朴素做法是 $O(n^{2})$ 的复杂度，会超时。
那么，就需要找一种方案，加快统计速度。
考虑一个数 $a = 3 ， m a x = 5$ ，试判断另一个数 $b$ 是否满足 $\bigoplus b ≤ 5$ 。将 $3$ 和 $5$ 表示成二进制的形式（这里为了方便表述，只写出来低位的3位）： $3_{10}=011_{2}，5_{10}=101_{2}$ 。根据再十进制中比较数字大小的原则：两数字位数相同的时候，从高位开始比较，如果高位就能决定出来大小，那么是没有必要比较低位的，同理，在二进制中表示也是如此。
我们考虑 $b$ 的二进制形式：

假设 $b$ 的二进制表示最高位是 $0$ ，因为最高位 $\bigoplus 0=0$ ，无论 $b$ 的次高位和最低位是什么，一定满足 $\bigoplus b ≤ max$ 。
假设 $b$ 的二进制表示最高位是 $1$ ，因为最高位 $\bigoplus 1=1$ ，结果的 $1$ 和 $m a x$ 中最高位的 $1$ 是无法比较出大小的，此时还需要继续比较次高位，如果相等，继续比较更低位，直到确定大小关系或者两者相等为止。

这个的比较过程，就是在字典树上进行查询的一个过程。考虑上面的情况1，如果某一位已经足够确定大小关系了，那么低位取什么都无所谓了，也就不用计算了，直接取这个结点的某个属性值即可，这个属性值是：该结点下有几个叶子节点的统计量。
此外，还要介绍一个思路，我们令 $q u e r y (v a l u e, m a x)$ 表示在字典树上每个元素异或 $v a l u e 的结果 a n s w e r$ ，满足 $0 \leq a n s w e r \leq m a x$ 的元素个数。题目求解的 $a n s w e r \in [l o w, h i g h]$ 的数量，我们可以求 $q u e r y (v a l u e, m a x)$ 和 $q u e r y (v a l u e, m i n - 1)$ ，最终结果就是 $q u e r y (v a l u e, m a x) - q u e r y (v a l u e, m i n - 1)$ 。
整个代码流程分为两步：对于数组中的每个数字，在字典树上查询value，插入value。先查询后插入，可以保证查询value的时候，字典树上都是value之前的数字，保证了 $i$ 和 $j$ 的位置关系。
查询就相当于拿value和字典树上已经存储过的值按位进行异或运算。
如果某一位足以确定大小关系 $\bigoplus k < max$ ，就可以累加 $v a l u e$ 在该二进制位处的叶子数量值，低位的就不用继续算了。
如果某一位足以确定大小关系 $\bigoplus k > max$ ，就不用继续进行了，此时低位无论取什么值都无法满足题意，累加值为0。
如果存在 $\bigoplus k = max$ ，这种情况的k也是符合条件的，也要算进去。

class Solution {
    public int countPairs(int[] nums, int low, int high) {
        Node root = new Node();
        int result = 0;
        for (int num : nums) {
            // 先查询，后插入
            result += root.query(root, num, high) - root.query(root, num, low - 1);
            root.insert(root, num);
        }
        return result;
    }
}

class Node {
    int count;
    Node[] child;

    public Node() {
        this.count = 0;
        this.child = new Node[]{null, null};
    }

    public void insert(Node root, int value) {
        // 假设树的根节点是第0层，只有一个根节点
        // 那么，树的第i层，有2^i个结点
        // 要想知道一个值是什么，需要从根结点遍历到叶子结点
        // 所以，树中的叶子结点数代表树中存储了多少个数字
        // 2^14 < 2*10^4 < 2^15
        // 所以，用一棵高度为15（从0开始计数）的字典树，可以存储下所有的数据
        // 我们规定，左孩子代表二进制是0的分支，右孩子代表二进制是1的分支
        root.count++;// 根节点的count++
        for (int i = 15; i >= 0; i--) {
            int bit = (value >> i) & 1;// 取出value二进制的第i位
            if (root.child[bit] == null) {// bit分支还是空的，就给它创建一个
                root.child[bit] = new Node();
            }
            root = root.child[bit];// 根据bit的值，移动到不同的分支上
            root.count++;// 分支结点的count++
        }
    }

    public int query(Node root, int value, int maxValue) {
        int result = 0, i;
        for (i = 15; i >= 0; i--) {
            int valuebit = (value >> i) & 1;
            int maxValuebit = (maxValue >> i) & 1;
            int answerbit;
            // 分别求左右子树对应的位和valuebit异或的结果，对比maxValuebit
            Node node = null;// 当出现异或结果相等的时候，临时存储这个相等的结点，用在低位的比较，0和1最多只有一边出现相等的情况
            // 遍历root的所有孩子，这里只有0和1两个孩子，也写成循环的形式，更有通用性，如果孩子是a-z，可以改成遍历[a, z]即可
            for (int j = 0; j < 2; j++) {
                if (root.child[j] != null) {
                    answerbit = j ^ valuebit;
                    if (answerbit < maxValuebit) {// 在当前位已经比较出大小，就不用继续比较低位了
                        result += root.child[j].count;
                    }
                    if (answerbit == maxValuebit) {// 在当前位无法比较出大小，继续比较低位，将child[j]临时存储下来
                        node = root.child[j];
                    }
                }
            }
            if (node != null) {// 出现了异或结果相等的情况，还需继续比较更低位
                root = node;
            } else {// 无需继续比较低位了
                break;
            }
        }
        if (i == -1) {// 最低位都比较过了，还没有比较出来maxVlue和value ^ a的大小关系，也就是value ^ a == maxValue的情况
            // 这里需要注意，nums里可能有相同的值，如果有两个a都满足value ^ a == maxValule了，这里就得加2，所以不能用result++;
            result += root.count;// 这里的root一定是叶结点了
        }
        return result;
    }
}

还有另一种写法，不需要考虑等于的情况，写起来更容易一些。需要改动的是query的参数和query的方法体。

public int countPairs(int[] nums, int low, int high) {
    Node root = new Node();
    int result = 0;
    for (int num : nums) {
        // 先查询，后插入
        result += root.query(root, num, high + 1) - root.query(root, num, low);
        root.insert(root, num);
    }
    return result;
}

public int query(Node root, int value, int maxValue) {
    int result = 0, i;
    for (i = 15; i >= 0; i--) {
        int valuebit = (value >> i) & 1;
        int maxValuebit = (maxValue >> i) & 1;
        if (maxValuebit == 1) {// maxValuebit == 1，要使得value ^ a的这一位是0，也就是value和a的这一位同1或同0
            if (root.child[valuebit] != null) {// 这里的valuebit == abit，按位异或 == 0，此时可以判断小于maxValue了
                result += root.child[valuebit].count;
            }
            // value ^ a的这一位是1的情况，也就是value和a的这一位不同
            if (root.child[1 ^ valuebit] != null) {
                root = root.child[1 ^ valuebit];// 转向这一侧继续判断
            } else {
                break;
            }
        } else {// maxValuebit == 0，如果value ^ a的这一位是1，不满足；如果value ^ a的这一位是0，有可能满足，这里就只需要考虑异或结果是0的情况，异或结果是0，那么value和a的这一位同1或同0
            if (root.child[valuebit] != null) {// 这里的valuebit == abit，按位异或 == 0，继续判断
                root = root.child[valuebit];
            } else {
                break;
            }
        }
    }
    return result;
}

王劭阳

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
LeetCode第233场周赛

周赛地址：https://leetcode-cn.com/contest/weekly-contest-233/第一题：最大升序子数组和题目要求连续上升子数组的和最大，进行遍历，对比当前元素和前一个元素的大小关系。当a[i−1]<a[i]a[i-1] < a[i]a[i−1]<a[i]的时候，此时是递增的，累加a[i]到sum中，用max一直维护sum的最大值。当a[i−1]≥a[i]a[i-1] ≥ a[i]a[i−1]≥a[i]的时候，此时递增停止，那么让sum=a[i]，从
复制链接

扫一扫