接下来会以刷常规题为主 ，周赛的难题想要独立做出来还是有一定难度的，需要消耗大量时间
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<y 时，x mod y=x 因此如果选择数组中的两个不相等的元素，则可以删除较大元素，保留较小元素。
- 如果 minCount=1
- 如果 minCount>1
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]`) 是固定的，所以总是被包含在结果中。
下面是详细的解题步骤：
-
初始化两个堆：一个小顶堆
small来保存当前窗口中的最小的k-2个数，以及一个大顶堆big来保存窗口内剩余的数。 -
使用 HashMap 进行延迟删除：为了实现有效地从堆中删除特定的非堆顶元素，创建两个
HashMap(smallMark和bigMark) 来标记堆中元素是否已经被 "删除"。该删除实际上是延迟执行的，即直到这个元素出现在堆顶时才真正被排除。 -
填充初始窗口：从
nums数组的第二个元素开始，将dist+1长度内的元素放入big堆。 -
从
big中取出k-2个最小元素：这k-2个元素是将要加入small的，记录这k-2个数的和作为窗口的当前总和。 -
滑动窗口：在数组中滑动窗口，并动态维护这两个堆以保持正确的最小
k-2个数的总和。 -
调整堆：当窗口滑动导致元素移出窗口时，更新
small堆以保持其有效性，并进行相应的调整。如果移出的元素当前在small中，则它需要被标记为已删除；如果它在big中，则直接标记为已删除。 -
处理新进入窗口的元素：窗口滑动时，可能会有新的元素进入。这些新元素需要加入到
big堆中。从big中取出的最小元素会放入small堆，并更新当前窗口总和（sum）。 -
求解最终结果：在滑动窗口过程中，每次窗口更新后，计算此时的窗口总和加上
nums[0]（固定加入）。所有窗口中总和的最小值即为所求问题的答案。
class Solution {
// small是小顶堆 维护前k-2小的数
// big是大顶堆 维护窗口内剩下的数
PriorityQueue<Integer> small, big;
// 标记当前元素是否已经被删除以及被删除的个数
HashMap<Integer, Integer> 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]`在内的最小成本和。
// 假设堆中有一个元素值为 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，减少删除计数
}
}