LeetCode周赛359

LeetCode周赛359

A题

略

B题

题意

给两个整数n，k，对于一个由不同正整数组成的数组，如果不存在任意一对元素的和等于k，则认为数组是符合题意的，要求求出长度为n的符合题意的数组的最小和。

思路

我们优先选择1、2 … k/2 - 1、k/2。然后再从k开始选择即可。

代码

class Solution {
    public int minimumSum(int n, int k) {
        int p = k;
        int t = n;
        int sum = 0;
        for (int i = 1;i <= (k >> 1) ; i++) {
            sum += i;
            t--;
            if (t == 0) {
                break;
            }
        }
        while(--t >= 0) {
            sum += p++;
        }
        return sum;
    }
}

C题

题意

给定0 - n-1个房子， 然后给出offers数组，每一个元素代表一种销售方案，那么对于每一个房子而言，他能选择不卖，则dp[i] = dp[i - 1]；也可以选择卖，如果卖，就从所有以他为销售终点的方案中更新出最大利润。

代码

class Solution {
    public int maximizeTheProfit(int n, List<List<Integer>> offers) {
        //dp[i]表示在当前订单下，出售前i间房时能卖出的最多金币
        int[] dp = new int[n+1];
        Map<Integer,List<int[]>> groups = new HashMap<>();

        //选或不选 => (选的有多个)选哪个
        //按照end分组，因为该房子卖的话，可能有多种方案涉及到，要选最大价值的那套方案
        for(List<Integer> offer: offers){
            List<int[]> group = groups.getOrDefault(offer.get(1),new ArrayList<>());
            group.add(new int[]{offer.get(0),offer.get(2)});
            groups.put(offer.get(1),group);
        }

        for(int end=0;end<n;end++){//不管有没有买end号房的，直接从0遍历到n
            List<int[]> group = groups.getOrDefault(end,new ArrayList<>());
            //既有不选的作用，又能让dp保持连续
            dp[end+1] = dp[end];
            //选,买end号房的方案可能有多个
            for(int[] endOffer:group){
                dp[end+1] = Math.max(dp[end+1],dp[endOffer[0]] + endOffer[1]);
            }
        }

        return dp[n];
    }
}

D题

题意

给出一个数组arr，要求求出arr最多删除k个元素之后，连续等值的元素长度的最大值是多少。

思路

可以对所有元素进行分组，然后存每个元素的下标。此时每个元素都做一次滑动窗口即可。

代码

class Solution {
    public int longestEqualSubarray(List<Integer> nums, int k) {
        int ans = 1;
        var map = new HashMap<Integer, List<Integer>>();
        for (int i = 0; i < nums.size(); i++) {
            map.computeIfAbsent(nums.get(i), a -> new ArrayList<>()).add(i);
        }
        for (var val : map.values()) {
            int cnt = 1;
            int k1 = k;
            int start = 0, end = 0;
            while (end < val.size()) {
                while (end + 1 < val.size() && val.get(end + 1) - val.get(end) - 1 <= k1) {
                    k1 -= val.get(end + 1) - val.get(end) - 1;
                    end++;
                }
                cnt = Math.max(end - start + 1, cnt);
                if (end + 1 == val.size()) {
                    break;
                }
                end++;
                k1 -= val.get(end) - val.get(end - 1) - 1;
                while(k1 < 0) {
                    k1 += val.get(start + 1) - val.get(start) - 1;
                    start++;
                }
            }
            ans = Math.max(cnt, ans);
        }
        return ans;
    }
}

代码2

我们关注一个区间是否包含正确答案。

假设区间的最左端的元素值为x，区间长度len <= cnt(x) + k时，若区间其他元素y出现的次数比cnt(x)多，那么一定满足len < cnt(y) + k;

若其他元素y出现的次数小于等于cnt(x)，那么对于答案没有造成任何影响，所以我们可以维护左端点cnt(x) + k >= len的一个区间。并且不断地更新答案即可。

class Solution {
    public int longestEqualSubarray(List<Integer> nums, int k) {
        int n = nums.size(), ans = 0;
        int[] map = new int[n + 1];
        for (int i = 0, j = 0; j < n; j++) {
            map[nums.get(j)]++;
            if (j - i + 1 - map[nums.get(i)] > k) {
                map[nums.get(i++)]--;
            }
            ans = Math.max(ans, map[nums.get(j)]);
        }
        return ans;
    }
}