2022-11-07 第 318 场周赛

2022-11-07 第 318 场周赛

6229. 对数组执行操作

class Solution {
    public int[] applyOperations(int[] nums) {
        int n = nums.length;
        int[] ans = new int[n];
        int idx = 0;
        for (int i = 0; i < n - 1; i++) {
            if (nums[i] == nums[i+1]) {
                nums[i] = 2 * nums[i];
                nums[i+1] = 0;
            }
        }
        for (int i = 0; i < n; i++) {
            if (nums[i] != 0) {
                ans[idx++] = nums[i];
            }
        }
        return ans;
    }
}

6230. 长度为 K 子数组中的最大和

用map保存长度为k的窗口的种类，当map的size为k时，说明子数组是k个不同的元素。

class Solution {
    public long maximumSubarraySum(int[] nums, int k) {
        Map<Integer,Integer> map = new HashMap<>();
        long max = 0;
        long sum = 0;
        for (int i = 0; i < k; i++) {
            if (map.containsKey(nums[i])) {
                map.put(nums[i],map.get(nums[i])+1);
            } else {
                map.put(nums[i],1);
                sum += nums[i];
            }
        }
        if (map.size() == k) {
            max = sum;
        }
        for (int i = k; i < nums.length; i++) {
            if (map.get(nums[i-k]) == 1) {
                map.remove(nums[i-k]);
                sum -= nums[i-k];
            } else {
                map.put(nums[i-k],map.get(nums[i-k])-1);
            }
            int c = map.getOrDefault(nums[i],0);
            if (c == 0) {
                sum += nums[i];
            }
            map.put(nums[i],c+1);
            if (map.size() == k) {
                max = Math.max(max,sum);
            }
        }
        return max;
    }
}

6231. 雇佣 K 位工人的总代价

用两个小顶堆存储左右两端的candidates,不断地向中心逼近。

class Solution {
    public long totalCost(int[] costs, int k, int candidates) {
        long ans = 0l;
        PriorityQueue<Integer> lheap = new PriorityQueue<>();
        PriorityQueue<Integer> rheap = new PriorityQueue<>();
        int n = costs.length;
        if (n == 1) {
            return (long)costs[0];
        }
        candidates = Math.min(candidates,n/2);
        int left = candidates - 1, right = n - candidates;
        for (int i = 0; i <= left; i++) {
            lheap.offer(costs[i]);
        }
        for (int i = n - 1; i >= right; i--) {
            rheap.offer(costs[i]);
        }
        int j = 0;
        for (; j < k && left + 1 < right; j++) {
            if (rheap.peek() < lheap.peek()) {
                ans += rheap.poll();
                right--;
                rheap.offer(costs[right]);
            } else {
                ans += lheap.poll();
                left++;
                lheap.offer(costs[left]);
            }
        }
        for (;j < k && lheap.size() > 0 && rheap.size() > 0; j++) {
            if (lheap.peek() <= rheap.peek()) {
                ans += lheap.poll();
            } else {
                ans += rheap.poll();
            }
        }
        for (; j < k; j++) {
            if (lheap.size() > 0) {
                ans += lheap.poll();
            } else {
                ans += rheap.poll();
            }
        }
        return ans;
    }
}

6232. 最小移动总距离

记忆化搜索
int n = robot.size(),m = factory.length;
dp[i][j]表示机器人i到n之间，工厂j到m之间的最小移动距离。
想要计算dp[i][j]可以以当前工厂为视角来计算，
1.dp[i][j]不包含当前工厂，即当前工厂不维修机器人。
2.当前工厂维修i号机器人
3.当前工厂维修i，i+1机器人
…
x. 当前工厂维修i,i+1,…,i+factory[j][1]-1机器人。
根据不同的情况做递归。
递归结束条件是：机器人遍历完了或遍历到了最后一个工厂且剩余的机器人数量超过工厂的limit或
遍历到了最后一个工厂且剩余的机器人数量没有超过工厂的limit。

class Solution {
    long[][] dp;
    long inf = Long.MAX_VALUE;
    public long minimumTotalDistance(List<Integer> robot, int[][] factory) {
        Collections.sort(robot);
        Arrays.sort(factory,(a,b)->(a[0]-b[0]));
        int m = factory.length, n = robot.size();
        dp = new long[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                dp[i][j] = -1;
            }
        }
        return dfs(0,0,robot,factory);
    }

    public long dfs(int i, int j, List<Integer> robot, int[][] factory) {
        if (j == factory.length) {
            return Long.MAX_VALUE;
        }
        if (j == factory.length - 1 && (robot.size()-i> factory[j][1])) {
            return Long.MAX_VALUE;
        }
        if (i == robot.size()) {
            return 0;
        }
        if (j == factory.length - 1) {
            long ans = 0;
            for (int p = i; p < robot.size(); p++) {
                ans += Math.abs(robot.get(p)-factory[j][0]);
            }
            dp[i][j] = ans;
            return ans;
        }
        if (dp[i][j] != -1) {
            return dp[i][j];
        }
        long ans = dfs(i,j+1,robot,factory);
        long sum = 0;
        int k = i;
        for (; k < robot.size() && k < factory[j][1] + i; k++) {
            sum += Math.abs(robot.get(k)-factory[j][0]);
            long resp = dfs(k+1,j+1,robot,factory);
            if (resp == inf) {
                continue;
            }
            ans = Math.min(ans,sum+resp);
        }
        if (ans == inf) {
            return inf;
        }
        dp[i][j] = ans;
        return ans;
    }
}