算法优化：LeetCode第122场双周赛解题策略与技巧

接下来会以刷常规题为主 ，周赛的难题想要独立做出来还是有一定难度的，需要消耗大量时间

比赛地址 

3011. 判断一个数组是否可以变为有序

public class Solution {
    public int minimumCost(int[] nums) {
        if (nums.length < 3) {
            // 数组长度小于3时，无法分割成3个子数组
            return -1;
        }

        int minCost = Integer.MAX_VALUE;
        int n = nums.length;

        // 第一个分割点至少在索引1，第二个分割点至少在索引2
        for (int i = 1; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                int cost = nums[0] + nums[i] + nums[j];
                minCost = Math.min(minCost, cost);
            }
        }

        return minCost;
    }
}

100164. 通过操作使数组长度最小

冒泡排序

class Solution {
    
    public boolean canSortArray(int[] nums) {
   
        int n = nums.length;

        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (Integer.bitCount(nums[j]) == Integer.bitCount(nums[j + 1]) && nums[j]>nums[j + 1]) {
                    // 如果前一个元素的1的数量大于后一个元素的1的数量，交换它们
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }

        // 遍历完后，检查数组是否有序
        for (int i = 0; i < n - 1; i++) {
            if (nums[i] > nums[i + 1]) {
                return false;
            }
        }
        
        return true;
    }
}

100181. 将数组分成最小总代价的子数组 I

当 x

用 minNum表示数组 nums 中的最小元素

用 minCount 表示数组 nums 中的 minNum 的出现次数

分别考虑 minCount=1 和 minCount>1 的情况。

• 如果 minCount=1

则可以每次选择 minNum  和另一个元素，由于 minNum 一定小于另一个元素，因此总是可以删除另一个元素，保留 minNum，直到数组 nums  中只有一个元素 minNum，数组 nums的最小长度是 1。

• 如果 minCount>1 

1. 如果数组 nums 中存在一个元素 num 满足 num mod minNum≠0 ，记 newNum= (num  mod  minNu)
2. 则必有 0
3. 由于 newNum < minNum ，因此 newNum 成为数组 nums 中的新的最小元素且最小元素唯一，之后可以每次选择 newNum 和另一个元素，其效果是删除另一个元素，保留 newNum ，直到数组 nums 中只有一个元素 newNum ，数组 nums 的最小长度是 1
4. 如果数组 nums 中不存在元素 num 满足 num  mod  minNum ≠ 0 ，则无法通过操作得到小于 minNum 的元素，因此在将所有大于 minNu 的元素删除之后，剩余 minCount 个元素 minNum 。由于每次可以选择 2 个元素 minNum 执行操作得到元素 0 无法继续操作，因此 minCount 个元素 minNum 的最多操作次数可以根据count_min的奇偶性判断

class Solution:
    def minimumArrayLength(self, nums: List[int]) -> int:
        min_val = min(nums)
        count_min = nums.count(min_val)

        for num in nums:
            if num % min_val != 0:
                return 1  # 产生了新的更小值

        # 没有产生新的最小值，计算最小值的数量
        return (count_min ) // 2 +1 if count_min % 2 != 0 else count_min // 2

 

100178. 将数组分成最小总代价的子数组 II

一、直接用滑动窗口求解

这种方法会超时

class Solution:
    def minimumCost(self, nums: List[int], k: int, dist: int) -> int:
        
        first = nums[0]  # 初始元素的代价
        window_size = dist + 1  # 窗口大小
        minimumCost = float('inf')  # 初始化最小代价为无穷大

        # 遍历数组，寻找除第一个和最后一个元素之外的最小的 k-1 个元素
        for start in range(1, len(nums) - window_size + 1):
            window = nums[start:start + window_size]
            sorted_window = sorted(window)
            # 获取除第一个的 k-1 个最小元素的和
            window_cost = sum(sorted_window[:k-1])
            # 更新最小代价
            minimumCost = min(minimumCost, window_cost)

        # 最终的最小总代价是第一个元素的代价加上最小窗口代价
        return first + minimumCost 

二、引入堆的代码实现

效率和之前的方法相差无几

class Solution:
    def minimumCost(self, nums: List[int], k: int, dist: int) -> int:
        first = nums[0]
        n = len(nums)
        minimumCost = float('inf')

        for start in range(1, n - dist):
            # 维护一个大小为 dist + 1 的最小堆
            min_heap = nums[start:start + dist + 1]
            heapq.heapify(min_heap)

            window_cost = 0
            # 弹出最小的 k-1 个元素并计算它们的和
            for _ in range(k-1):
                if min_heap:
                    window_cost += heapq.heappop(min_heap)

            minimumCost = min(minimumCost, window_cost)

        return first + minimumCost

三、大小顶堆、延迟删除、滑动窗口

这道题目的思路是利用滑动窗口结合两个堆（优先队列）来找出序列中指定数量(`k-1`)的最小数的和，它们是从序列的某个区间（该区间长度由`dist`决定）中选择出来的。这个序列中的第一个数 (`nums[0]`) 是固定的，所以总是被包含在结果中。

下面是详细的解题步骤：

1. 初始化两个堆：一个小顶堆 small 来保存当前窗口中的最小的 k-2 个数，以及一个大顶堆 big 来保存窗口内剩余的数。

2. 使用 HashMap 进行延迟删除：为了实现有效地从堆中删除特定的非堆顶元素，创建两个 HashMap (smallMark 和 bigMark) 来标记堆中元素是否已经被 "删除"。该删除实际上是延迟执行的，即直到这个元素出现在堆顶时才真正被排除。

3. 填充初始窗口：从 nums 数组的第二个元素开始，将 dist+1 长度内的元素放入 big 堆。

4. 从 big 中取出 k-2 个最小元素：这 k-2 个元素是将要加入 small 的，记录这 k-2 个数的和作为窗口的当前总和。

5. 滑动窗口：在数组中滑动窗口，并动态维护这两个堆以保持正确的最小 k-2 个数的总和。

6. 调整堆：当窗口滑动导致元素移出窗口时，更新 small 堆以保持其有效性，并进行相应的调整。如果移出的元素当前在 small 中，则它需要被标记为已删除；如果它在 big 中，则直接标记为已删除。

7. 处理新进入窗口的元素：窗口滑动时，可能会有新的元素进入。这些新元素需要加入到 big 堆中。从 big 中取出的最小元素会放入 small 堆，并更新当前窗口总和（sum）。

8. 求解最终结果：在滑动窗口过程中，每次窗口更新后，计算此时的窗口总和加上 nums[0]（固定加入）。所有窗口中总和的最小值即为所求问题的答案。

class Solution {
    // small是小顶堆 维护前k-2小的数
    // big是大顶堆 维护窗口内剩下的数

    PriorityQueue small, big;
    // 标记当前元素是否已经被删除以及被删除的个数
    HashMap smallMark, bigMark;
    // samll和big当前未被删除的元素个数
    int smallSiz, bigSiz;
    long sum;

    public long minimumCost(int[] nums, int k, int dist) {
        // k个 除掉第一个 还要选k-1个
        // 枚举第2个 nums[i] nums[i+1]... nums[i+dist] 里选k-2个最小的数
        // nums[i+1] nums[i+k-2]
        small = new PriorityQueue<>(Collections.reverseOrder());
        smallSiz = 0;
        smallMark = new HashMap<>();
        big = new PriorityQueue<>();
        bigSiz = 0;
        bigMark = new HashMap<>();
        // 当前小顶堆的和 也就是前k-2小的和
        sum = 0;
        int n = nums.length;
        // 把nums[1+1]...nums[1+dist]里的数加入到big里
        for (int i = 2; i <= Math.min(n-1, dist+1); i++) {
            big.add(nums[i]);
            bigSiz++;
        }
        // 取出前k-2小的数放入small
        for (int i = 0; i < k-2; i++ ) {
            int tmp = big.poll();
            bigSiz--;
            sum += tmp;
            small.add(tmp);
            smallSiz++;
        }
        long res = nums[0] + nums[1] + sum;
        // 枚举第二个数的位置
        // 枚举的位置从i-1变成i时 nums[i]离开了窗口 nums[i+dist]进入了窗口
        for (int i = 2; i + k-2 < n; i++) {
            // 移除nums[i]
            // 因为要访问small.peek() 为了确保small.peek()是未被删除的元素 需要先更新small
            updateSmallPeek();
            // nums[i]在前k-2小里
            if (smallSiz > 0 && small.peek() >= nums[i]) {
                // 因为nums[i] 是可能小于small.peek()的 我们没法直接删除nums[i] 所以要标记一下
                smallMark.merge(nums[i], 1, Integer::sum);
                // 从small里删除nums[i]
                smallSiz--;
                sum -= nums[i];
            } else {
                // nums[i]不在前k-2小里 
                bigMark.merge(nums[i], 1, Integer::sum);
                bigSiz--;
                // 这里是为了使得small的数量变成k-3个 也就是还差一个才够k-2个
                // 是为了方便后面的操作
                // 从small里选一个放到big里
                int tmp = small.poll();
                smallSiz--;
                sum -= tmp;
                big.add(tmp);
                bigSiz++;
            }
            // 先放到big里 然后从big里面拿一个放到small就刚好k-2个
            if (i+dist < n) {
                big.add(nums[i+dist]);
                bigSiz++;
            }
            // 要从big里拿一个 访问big.peek()之前要先更新big
            updateBigPeek();
            int tmp = big.poll();
            bigSiz--;
            sum += tmp;
            small.add(tmp);
            smallSiz++;

            res = Math.min(res, nums[i] + nums[0] + sum);
        }
        return res;

    }

    // 每次访问small.peek()之前都要先更新small
    public void updateSmallPeek() {
        // 如果small.peek()已经被删除了 那么就把它从small里移除 直到small.peek()是未被删除的元素
        while (smallSiz > 0 && smallMark.getOrDefault(small.peek(), 0) > 0) {
            int tmp = small.poll();
            smallMark.merge(tmp, -1, Integer::sum);
        }
    }

    public void updateBigPeek() {
        while (bigSiz > 0 && bigMark.getOrDefault(big.peek(), 0) > 0) {
            int tmp = big.poll();
            bigMark.merge(tmp, -1, Integer::sum);
        }
    }
}

这个方法高效地使用了堆结构来保持每次窗口移动后，都能快速地选择出当前窗口中的k-2个最小数，而HashMap的标记删除机制则可以绕过优先队列不支持直接删除的限制。通过这个算法，你可以在移动窗口的过程中，不断更新当前窗口的最小值和，最终得到包含`nums[0]`在内的最小成本和。

思考1：为什么要用大顶堆只用小顶堆会怎么样?

因为小顶堆只能让您迅速访问堆中的最小值，而不是最大值。因此，如果窗口中有一个更小的数字需要加入到已满的小顶堆中（这时候我们需要替换掉小顶堆中最大的数字），您需要一种方式来找到小顶堆中的最大值，而大顶堆允许我们做到这一点。 

思考2：bigMark.merge(tmp, -1, Integer::sum)这个是干什么

在Java中的 PriorityQueue 并没有提供直接删除特定元素的操作，而是只提供了删除堆顶元素的操作。为了解决这个问题，bigMark 的用途是实现“延迟删除”，这个技巧通常在优先队列中删除非顶部元素时使用。

• bigMark 是一个 HashMap，它的键是元素值，值是该元素被标记删除的次数。
• 当我们要从优先队列 big 中删除一个元素时，我们不能直接删除它，因为它可能不在堆顶。
• 所以我们在 bigMark 中对这个元素的删除次数加一。这个标记表示元素已经被逻辑上删除，尽管它仍在优先队列中。
• merge 方法是一个合并函数，它会检查 HashMap 中是否存在键 tmp：
  • 如果存在，它会使用提供的合并函数 Integer::sum 将当前值与给定值相加。
  • 如果没有找到键 tmp，它会插入键值对 tmp -> -1。
• 在这个场景中，merge 方法用 -1 更新 tmp 的删除次数。每次 tmp 出现在堆顶时，这个标记都会被检查。如果标记表示该元素被删除（即删除计数大于零），这个元素将会从堆中弹出，同时更新它在 bigMark 中的标记。

// 假设堆中有一个元素值为 5，现在我们要删除它：
int tmp = 5;
bigMark.merge(tmp, 1, Integer::sum); // 标记 tmp 为已删除

// 当我们后续从堆中得到堆顶元素时：
updateBigPeek(); // 在访问堆顶前更新堆

// updateBigPeek 的实现会检查堆顶元素是否被标记为已删除，如果是，就将其从堆中移除，
// 并在 bigMark 中更新其计数：
public void updateBigPeek() {
    while (bigSiz > 0 && bigMark.getOrDefault(big.peek(), 0) > 0) {
        int tmp = big.poll(); // 弹出堆顶元素
        bigMark.merge(tmp, -1, Integer::sum); // 更新 bigMark，减少删除计数
    }
}