算法提升——LeetCode第 386 场周赛总结

最新推荐文章于 2024-07-19 22:36:19 发布

吴代庄

最新推荐文章于 2024-07-19 22:36:19 发布

阅读量1.1k

点赞数 18

分类专栏：算法文章标签：算法 leetcode java

本文链接：https://blog.csdn.net/Luck_gun/article/details/136285581

版权

算法专栏收录该内容

24 篇文章 0 订阅

订阅专栏

题目

分割数据

给你一个长度为偶数的整数数组nums。你需要将这个数组分割成nums1和nums2两部分，要求：

nums1.lengthnums2.lengthnums.length/2。
nums1应包含互不相同的元素。
nums2也应包含互不相同的元素。
如果能够分割数组就返回true，否则返回false。

解题思路

map计数，如果数字出现次数超过2次，则无法按题意分割。

class Solution {
    public boolean isPossibleToSplit(int[] nums) {
        Map<Integer,Integer>map=new HashMap<>();
        for(int num:nums){
            int count=map.getOrDefault(num,0);
            if (count>=2){
                return false;
            }
            map.put(num,count+1);
        }
        
        return true;
    }
}

求交集区域内的最大正方形面积

在二维平面上存在n个矩形。给你两个下标从0开始的二维整数数组bottomLeft和topRight，两个数组的大小都是nx2，其中bottomLeft[i]和topRight[i]分别代表第i个矩形的左下角和右上角坐标。

我们定义向右的方向为x轴正半轴（x坐标增加），向左的方向为x轴负半轴（x坐标减少）。同样地，定义向上的方向为y轴正半轴（y坐标增加），向下的方向为y轴负半轴（y坐标减少）。

你可以选择一个区域，该区域由两个矩形的交集形成。你需要找出能够放入该区域内的最大正方形面积，并选择最优解。

返回能够放入交集区域的正方形的最大可能面积，如果矩形之间不存在任何交集区域，则返回0。

解题思路

有n个矩形，需要计算由两个矩形的交集形成的区域中可以放入的最大正方形面积。可以遍历每一对矩形计算交集区域内可以放入的最大正方形边长，根据边长的平方计算最大正方形面积，遍历所有矩形对之后即可得到最大正方形面积。

class Solution {
    public long largestSquareArea(int[][] bottomLeft, int[][] topRight) {
        long maxSquareArea = 0;
        int n = bottomLeft.length;
        for (int i = 0; i < n; i++) {
            int[] bottomLeft1 = bottomLeft[i];
            int[] topRight1 = topRight[i];
            for (int j = i + 1; j < n; j++) {
                int[] bottomLeft2 = bottomLeft[j];
                int[] topRight2 = topRight[j];
                long squareArea = overlapSquareArea(bottomLeft1, topRight1, bottomLeft2, topRight2);
                maxSquareArea = Math.max(maxSquareArea, squareArea);
            }
        }
        return maxSquareArea;
    }

    public long overlapSquareArea(int[] bottomLeft1, int[] topRight1, int[] bottomLeft2, int[] topRight2) {
        int overlapWidth = Math.max(Math.min(topRight1[0], topRight2[0]) - Math.max(bottomLeft1[0], bottomLeft2[0]), 0);
        int overlapHeight = Math.max(Math.min(topRight1[1], topRight2[1]) - Math.max(bottomLeft1[1], bottomLeft2[1]), 0);
        long side = Math.min(overlapWidth, overlapHeight);
        return side * side;
    }
}

标记所有下标的最早秒数 I

给你两个下标从1开始的整数数组nums和changeIndices，数组的长度分别为n和m。

一开始，nums中所有下标都是未标记的，你的任务是标记nums中所有下标。

从第1秒到第m秒（包括第m秒），对于每一秒s，你可以执行以下操作之一：

选择范围[1,n]中的一个下标i，并且将nums[i]减少1。
如果nums[changeIndices[s]]等于0，标记下标changeIndices[s]。
什么也不做。
请你返回范围[1,m]中的一个整数，表示最优操作下，标记nums中所有下标的最早秒数，如果无法标记所有下标，返回-1。

解题思路

二分计算

class Solution {
    public int earliestSecondToMarkIndices(int[] nums, int[] changeIndices) {
        int n = nums.length;
        int m = changeIndices.length;
        if (n > m) {
            return -1;
        }

        int[] lastT = new int[n];
        int left = n - 1, right = m + 1;
        while (left + 1 < right) {
            int mid = (left + right) / 2;
            if (check(nums, changeIndices, lastT, mid)) {
                right = mid;
            } else {
                left = mid;
            }
        }
        return right > m ? -1 : right;
    }

    private boolean check(int[] nums, int[] changeIndices, int[] lastT, int mx) {
        Arrays.fill(lastT, -1);
        for (int t = 0; t < mx; t++) {
            lastT[changeIndices[t] - 1] = t;
        }
        for (int t : lastT) {
            if (t < 0) { // 有课程没有考试时间
                return false;
            }
        }

        int cnt = 0;
        for (int i = 0; i < mx; i++) {
            int idx = changeIndices[i] - 1;
            if (i == lastT[idx]) { // 考试
                if (nums[idx] > cnt) { // 没时间复习
                    return false;
                }
                cnt -= nums[idx]; // 复习这门课程
            } else {
                cnt++; // 留着后面用
            }
        }
        return true;
    }
}

标记所有下标的最早秒数 II

给你两个下标从1开始的整数数组nums和changeIndices，数组的长度分别为n和m。

一开始，nums中所有下标都是未标记的，你的任务是标记nums中所有下标。

从第1秒到第m秒（包括第m秒），对于每一秒s，你可以执行以下操作之一：

选择范围[1,n]中的一个下标i，并且将nums[i]减少1。
将nums[changeIndices[s]]设置成任意的非负整数。
选择范围[1,n]中的一个下标i，满足nums[i]等于0,并标记下标i。
什么也不做。
请你返回范围[1,m]中的一个整数，表示最优操作下，标记nums中所有下标的最早秒数，如果无法标记所有下标，返回-1。

解题思路

二分加贪心

class Solution {
    public int earliestSecondToMarkIndices(int[] nums, int[] changeIndices) {
        int n = nums.length;
        int m = changeIndices.length;
        if (n > m) {
            return -1;
        }

        long slow = n; // 慢速复习+考试所需天数
        for (int v : nums) {
            slow += v;
        }

        int[] firstT = new int[n];
        Arrays.fill(firstT, -1);
        for (int t = m - 1; t >= 0; --t) {
            firstT[changeIndices[t] - 1] = t;
        }

        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] - b[0]);
        int left = n - 1, right = m + 1;
        while (left + 1 < right) {
            pq.clear();
            int mid = (left + right) / 2;
            if (check(nums, changeIndices, firstT, pq, slow, mid)) {
                right = mid;
            } else {
                left = mid;
            }
        }
        return right > m ? -1 : right;
    }

    private boolean check(int[] nums, int[] changeIndices, int[] firstT, PriorityQueue<int[]> pq, long slow, int mx) {
        int cnt = 0;
        for (int t = mx - 1; t >= 0; t--) {
            int i = changeIndices[t] - 1;
            int v = nums[i];
            if (v <= 1 || t != firstT[i]) {
                cnt++;
                continue;
            }
            if (cnt == 0) {
                if (pq.isEmpty() || v <= pq.peek()[0]) {
                    cnt += 1; 
                    continue;
                }
                slow += nums[pq.poll()[1]] + 1;
                cnt += 2;
            }
            slow -= nums[i] + 1;
            cnt--; 
            pq.offer(new int[]{v, i});
        }
        return cnt >= slow; 
    }
}