LeetCode第236场周赛

最新推荐文章于 2022-03-27 14:33:26 发布

王劭阳

最新推荐文章于 2022-03-27 14:33:26 发布

阅读量89

点赞数

分类专栏： LeetCode周赛

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

版权

LeetCode周赛专栏收录该内容

15 篇文章 0 订阅

订阅专栏

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

第一题：数组元素积的符号

题目不难，遍历一遍，每个数过一下signFunc(x)，相乘即可，碰到0可以直接就返回了。

class Solution {
    public int arraySign(int[] nums) {
        int result = 1;
        for (int i : nums) {
            if (i == 0) {
                return 0;
            }
            if (i < 0) {
                result = -result;
            }
        }
        return result;
    }
}

第二题：找出游戏的获胜者

约瑟夫问题，学习循环链表时候一定会碰到的一个题目。
可以直接用LinkedList模拟，删除的时候需要判断是否是头结点。

class Solution {
    public int findTheWinner(int n, int k) {
        LinkedList<Integer> list = new LinkedList<>();
        for (int i = 1; i <= n; i++) {
            list.addLast(i);
        }
        Iterator<Integer> iterator = list.iterator();
        while (list.size() > 1) {
            int first = list.getFirst();
            int temp = k;
            int value = 0;
            while (temp-- > 0) {
                if (iterator.hasNext()) {
                    value = iterator.next();
                } else {
                    iterator = list.iterator();
                    value = iterator.next();
                }
            }
            if (value == first) {
                list.removeFirst();
                iterator = list.iterator();
            } else {
                iterator.remove();
            }
        }
        return list.getFirst();
    }
}

直接模拟效率会低一些，如果碰到数据量大的情况就超时了，介绍一个数学方法：参考博客。
对于示例1，把这个过程用表格表示出来。为了表述方便，报数从0开始。那么在报数的时候，报数为k-1的人将出局。

第几轮	根据第i+1轮胜利者的值求第i轮胜利者的值
第一轮	(0+2)%5=2	0	1	2	3	4
第二轮	(2+2)%4=0	3	x	0	1	2
第三轮	(0+2)%3=2	1	x	2	x	0
第四轮	(0+2)%2=0	x	x	0	x	1
第五轮	胜利者报数是0	x	x	0	x	x

第五轮的时候，只有一个人了，他就是胜利者，他的报数是0。那么，这个胜利者，在第四轮的报数是什么呢？第四轮是：(0+2)%2=0。同理，第三轮是：(0+2)%3=2，第二轮是：(2+2)%4=0，第一轮是：(0+2)%5=2。因为我们把报数改成从0开始，为了恢复题意，最后将结果加1即可。
设f(n,k)表示n个人，每次淘汰报数为k的人，最后的胜利者，f(n-1,k)表示n-1个人，每次淘汰报数为k的人，最后的胜利者。
于是有： $f(n,k)=(f(n-1,k)+k)\%n$ 。

class Solution {
    public int findTheWinner(int n, int k) {
        int index = 0;// 只有一个人的时候，胜利者下标是0
        // 从一个人递推到n个人
        for (int i = 2; i <= n; i++) {
            index = (index + k) % i;
        }
        // 编号=下标+1
        return index + 1;
    }
}

第三题：最少侧跳次数

我们给跑道定义，从上至下分别为跑道0，跑道1，跑道2。青蛙一开始在跑道2上。在它向右前进的过程中，可能会碰到障碍物，也可能不会碰到。不碰到障碍物的时候，侧跳就是0，主要考虑在当前跑道碰到障碍物后，向另外跑道跳跃的策略问题。
假设，在跑道1的index位置有障碍物，此时必须侧跳一次。分析跑道0和跑道2，从index-1位置，青蛙就要侧跳了。
假设跑道0上， index-1位置到终点一共有a个障碍物，跑道2上，index-1位置到终点也有a个障碍物，这时候，选择哪条跑道最优呢？
选择侧跳后能跑最远的一条路，可以发现策略和其余跑道的障碍物多少无关，和侧跳后能跑的距离有关，这样可以使得最终侧跳次数最少。
分析到这里，侧跳的策略就出来了。
这里巧妙的运用了BitSet数据结构，非常节省内存，使用nextSetBit()方法求下一个障碍物位置的效率也非常高效。

class Solution {
    public int minSideJumps(int[] obstacles) {
        int length = obstacles.length;
        BitSet[] bitSets = new BitSet[]{new BitSet(length), new BitSet(length), new BitSet(length)};
        for (int i = 0; i < length; i++) {
            if (obstacles[i] != 0) {
                bitSets[obstacles[i] - 1].set(i);
            }
        }
        int result = 0, current = 1, index = 0;
        int[] nextObstaclePosition = new int[3];
        while ((index = bitSets[current].nextSetBit(index)) != -1) {
            result++;
            for (int i = 0; i < 3; i++) {
                nextObstaclePosition[i] = bitSets[i].nextSetBit(index - 1);
            }
            current = chooseTrack(nextObstaclePosition);
        }
        return result;
    }

    private int chooseTrack(int[] nextObstaclePosition) {
        // 有一条跑道已经没有障碍了，果断选择这条跑道
        for (int i = 0; i < 3; i++) {
            if (nextObstaclePosition[i] == -1) {
                return i;
            }
        }
        // 选择碰到障碍物最远的跑道侧跳
        int maxPosition = nextObstaclePosition[0], track = 0;
        for (int i = 1; i < 3; i++) {
            if (nextObstaclePosition[i] > maxPosition) {
                maxPosition = nextObstaclePosition[i];
                track = i;
            }
        }
        return track;
    }
}

第四题：求出 MK 平均值

看了题解后，发现暴力竟然也能过，好吧，LeetCode对Java的优化太强了。用数组比用集合速度快，集合可能会被卡超时。在存放数据的时候，我们只需要关注最后m个即可，所以向数组中存放元素的时候，用了一个取模操作，被淘汰的元素直接覆盖掉。
每次添加元素的复杂度是 $O (1)$ ，元素个数大于等于m个的时候，每次计算MK平均值的复杂度都是 $O(Mlog_{2}M)$ 的复杂度。
最后注意求和时，用long，否则会爆int。

class MKAverage {
    int m, k, index;
    int[] array;

    public MKAverage(int m, int k) {
        this.m = m;
        this.k = k;
        index = 0;
        array = new int[m];
    }

    public void addElement(int num) {
        array[index % m] = num;// 只保留取最后m个
        index++;
    }

    public int calculateMKAverage() {
        if (index < m) {
            return -1;
        }
        int[] temp = array.clone();
        Arrays.sort(temp);
        long sum = 0, count = m - 2 * k;
        for (int i = k; i < m - k; i++) {
            sum += temp[i];
        }
        return (int) (sum / count);
    }
}

毕竟题目是要设计一个数据结构，暴力解题肯定是不讲武德，站在出题人的角度，来看看正确的解法。出题人想让我们根据操作的性质，设计出一个合理的数据结构，尽可能使得操作高效。
分析上面的暴力解法为什么耗时，因为每次求MK平均值的时候，都需要排序，求和，要想解决这个问题，就要使用自带排序的数据结构，这里使用TreeMap，key记录值，value记录频次。
TreeMap的插入和删除的时间复杂度都是 $O(log_{2}N)$ ，在操作插入和删除的时候，维护一个 $s u m$ ，在求平均值的时候，可以用 $O (1)$ 时间返回结果。
这里用3个TreeMap，第一个TreeMap存储最小的k个数字，第二个TreeMap存储m-2k个数字，第三个TreeMap存储最大的k个数字。在不断插入元素的过程中，3个TreeMap里总元素个数需要维持不变，也就是m个，而且第一个和第三个TreeMap里元素个数也要维持k个不变，这就需要第二个TreeMap里的元素，不断的与第一个或第三个里的元素进行移动，来维持题目要求。

class MKAverage {
    int m, k, length;
    long sum;
    LinkedList<Integer> linkedList;
    TreeMap<Integer, Integer>[] treeMap;

    public MKAverage(int m, int k) {
        this.m = m;
        this.k = k;
        length = 0;
        sum = 0;
        linkedList = new LinkedList<>();
        treeMap = new TreeMap[3];
        treeMap[0] = new TreeMap<Integer, Integer>();// 存储最小的k个数
        treeMap[1] = new TreeMap<Integer, Integer>();// 存储中间的m-2k个数
        treeMap[2] = new TreeMap<Integer, Integer>();// 存储最大的k个数
    }

    public void addElement(int num) {
        linkedList.offerLast(num);
        length++;
        // 推迟填入TreeMap的时机
        if (length == m) {
            List<Integer> temp = new ArrayList<>(linkedList);
            Collections.sort(temp);
            for (int i = 0; i < k; i++) {
                add(treeMap[0], temp.get(i), false);
            }
            for (int i = k; i < m - k; i++) {
                add(treeMap[1], temp.get(i), true);
            }
            for (int i = m - k; i < m; i++) {
                add(treeMap[2], temp.get(i), false);
            }
        } else if (length > m) {
            // 最前面的值最先过期，从linkedList里扔掉最先过期的值
            int value = linkedList.pollFirst(), index = 0;
            // 要被扔掉的值，在哪个TreeMap里，也把这个值扔掉，如果多个treeMap里都有这个值，只扔一次
            for (int i = 0; i < 3; i++) {
                if (treeMap[i].containsKey(value)) {
                    index = i;
                    delete(treeMap[i], value, i == 1);// 从treeMap[i]里移除过期的值
                    break;
                }
            }
            // 因为删除导致：treeMap[0]不足k个或者treeMap[2]不足k个，从treeMap[1]里取元素分给它们
            if (index == 0) {// 从treeMap[0]中删除了一个元素，treeMap[0]里现在只有k-1个元素了
                // 将treeMap[1]的最小值取出，移动到treeMap[0]中
                value = treeMap[1].firstKey();
                delete(treeMap[1], value, true);
                add(treeMap[0], value, false);
            }
            if (index == 2) {// 从treeMap[2]中删除了一个元素，treeMap[2]里现在只有k-1个元素了
                // 将treeMap[1]的最大值取出，移动到treeMap[2]中
                value = treeMap[1].lastKey();
                delete(treeMap[1], value, true);
                add(treeMap[2], value, false);
            }
            // 这时候，treeMap[0]和treeMap[2]里有k个数字，treeMap[1]里有m-2k-1个数字
            // 把num加到treeMap里，判断加到哪个treeMap，依旧需要维持treeMap[0]和treeMap[2]里有k个元素
            if (num <= treeMap[0].lastKey()) {// 向treeMap[0]中加
                // 加入到treeMap[0]里，treeMap[0]里有k+1个数字了，需要移动一个数字到treeMap[1]里
                add(treeMap[0], num, false);
                value = treeMap[0].lastKey();
                delete(treeMap[0], value, false);
                add(treeMap[1], value, true);
            } else if (num >= treeMap[2].firstKey()) {// 向treeMap[2]中加
                // 加入到treeMap[2]里，treeMap[2]里有k+1个数字了，需要移动一个数字到treeMap[1]里
                add(treeMap[2], num, false);
                value = treeMap[2].firstKey();
                delete(treeMap[2], value, false);
                add(treeMap[1], value, true);
            } else {// 向treeMap[1]中加
                add(treeMap[1], num, true);
            }
        }
    }

    /**
     * flag=true，把key累加到sum中
     * 给treeMap加入key元素
     */
    private int add(TreeMap<Integer, Integer> treeMap, int key, boolean flag) {
        if (flag) {
            sum += key;
        }
        return treeMap.merge(key, 1, Integer::sum);
    }

    /**
     * flag=true，把key从sum中减去
     * 从treeMap中移除key，需要考虑删除key的情况
     */
    private int delete(TreeMap<Integer, Integer> treeMap, int key, boolean flag) {
        if (flag) {
            sum -= key;
        }
        return treeMap.get(key) == 1 ? treeMap.remove(key) : treeMap.merge(key, -1, Integer::sum);
    }

    public int calculateMKAverage() {
        if (length < m) {
            return -1;
        }
        return (int) (sum / (m - 2 * k));
    }
}

要想卡掉暴力解法，可以给定一个最大值M，尽可能多的求解MK平均值操作，就可以卡掉暴力解法。

王劭阳

关注

0
点赞
踩
0

收藏

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

周赛地址：https://leetcode-cn.com/contest/weekly-contest-236第一题：数组元素积的符号题目不难，遍历一遍，每个数过一下signFunc(x)，相乘即可，碰到0可以直接就返回了。class Solution { public int arraySign(int[] nums) { int result = 1; for (int i : nums) { if (i == 0) {
复制链接

扫一扫

专栏目录