Leetcode第187场周赛——菜鸡依旧

Posted 2021-02-20 detachmliu

传送门：第187场双周赛

旅行终点站

解题思路

第一眼过去有点害怕！这么猛的嘛？一上来就是图？？？

再仔细一看，害，原来不会成环，而且只有一个终点，像这种题都是在拼手速了??

代码

class Solution {
    public String destCity(List<List<String>> paths) {
        // 使用Map存储先后关系
        Map<String, String> map = new HashMap<>();
        
        for (int i = 0; i < paths.size(); i++) {
            map.put(paths.get(i).get(0), paths.get(i).get(1));
        }
        
        // 终点一定能通过任意一条路找到，不妨从第一条路来找
        String end = map.get(paths.get(0).get(0));
        while (map.containsKey(end)) {
            end = map.get(end);
        }
        
        return end;
    }
}

运行结果

是否所有 1 都至少相隔 k 个元素

解题思路

看起来很难的样子。。emmm，实则一道大水题，这不应该是medium难度吧？

说下思路，首先找到第一个1的index（位置），之后总是记录前一个1的位置，然后一路向后，判断遇到的1与前一个1的距离有没有大于等于k，如果没有直接返回false。

代码

class Solution {
    public boolean kLengthApart(int[] nums, int k) {
        int index = -1;
        
        for (int i = 0; i < nums.length; i++) {
            // 当前位是1
            if (nums[i] == 1) {
                // 是遇到的第一个1
                if (index == -1) {
                    index = i;
                } else {
                    // 判断距离
                    if (i - index - 1 < k) {
                        return false;
                    }
                    index = i;
                }
            }
        }
        
        return true;
    }
}

运行结果

绝对差不超过限制的最长连续子数组

解题思路

这道题想了好久，暴力解法、滑动窗口、单调队列...然而当场会写的只有暴力??（太真实了）

看看这恐怖的数据量：上限为10的9次方，暴力不炸就有鬼了！！！

然而当看到群里的大佬说暴力能过时，我毅然决然的写起了暴力...提交！TLE！！！??怎么回事啊，我就知道肯定不能过嘛！遂又去看看大佬说了些啥——适量剪枝即可通过，嗷，懂了懂了，试试看——通过?

啊，大佬，永远滴神！

当然我也知道这只是力扣的数据不够强（暴力居然还挺快！），一旦加强数据，暴力肯定还是过不了的，于是结束后翻看了写题解的大佬，借鉴了下某大佬的解题思路——使用map来维护最大最小值，并进行窗口的滑动，总之，这个方法是滑动窗口。

代码

暴力

class Solution {
    public int longestSubarray(int[] nums, int limit) {     
        int max_len = 1;

        for (int i = 0; i < nums.length; i++) {
            int max = nums[i];
            int min = nums[i];
            int j = i + 1;
            for (; j < nums.length; j++) {
                // 刷新最大最小值
                if (nums[j] > max) {
                    max = nums[j];
                }
                if (nums[j] < min) {
                    min = nums[j];
                }
                if (max - min <= limit) {
                    if (j - i + 1 > max_len) {
                        // 刷新最大区间
                        max_len = j - i + 1;
                    }
                } else {
                    // 不符合要求后面的也没有意义了，剪枝！
                    break;
                }
            }
            // 一旦遇到右边一路畅通，直接运行到了结束的位置，那么这肯定是最大的区间，直接剪枝返回答案
            if (j == nums.length) {
                return max_len;
            }
        }
        
        return max_len;
    }
}

滑动窗口

class Solution {
    public int longestSubarray(int[] nums, int limit) {
        Map<Integer, Integer> map = new TreeMap<>();

        int max = Integer.MIN_VALUE;
        int index = 0;
        for (int i = 0; i < nums.length; i++) {
            // 向map中加入当前数，并使区间内的当前数个数加1
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
            
            // TreeMap是有序的map（默认升序），所以第一个值是最小值，最后一个最大
            List<Integer> key = new ArrayList<>(map.keySet());
            int sub = key.get(key.size() - 1) - key.get(0);
            // 符合要求，刷新最大区间
            if (sub <= limit) {
                if (i - index + 1 > max) {
                    max = i - index + 1;
                }
                // 一旦符合要求，就不用去动在区间里的数了
                continue;
            }

            // 不符合要求时，去掉当前区间第一个数（因为是连续数组，所以去数肯定是从最前面开始去）
            int cnt = map.get(nums[index]);
            if (cnt == 1) {
                // 仅有一个该数，删除记录
                map.remove(nums[index]);
            } else {
                map.put(nums[index], cnt - 1);
            }

            index++;
        }

        return max;
    }
}

运行结果

暴力

滑动窗口

总结

T4呢？？？太菜了，没有动手，所以就不放出来了（大佬们说暴力能过...哎！暴力都不会的我）??。

大佬们的手速场，菜鸡们的互啄场~