济源做网站的好公司施工企业qc小组

一、3502. 到达每个位置的最小费用

题目链接

本题是一道脑筋急转弯，实际就是计算前缀最小值，画个图理解一下:

代码如下：

class Solution {public int[] minCosts(int[] cost) {int n = cost.length;int[] ans = new int[n];ans[0] = cost[0];for(int i = 1; i < n; i++){ans[i] = Math.min(ans[i-1], cost[i]);}return ans;}
}

二、3503. 子字符串连接后的最长回文串 I

题目链接

本题数据范围较小，直接暴力，代码如下：

class Solution {public int longestPalindrome(String s, String t) {int n = s.length();int m = t.length();int ans = 1;for(int i = 0; i < n; i++){for(int j = i; j < n; j++){if(check(s.substring(i,j+1))){ans = Math.max(ans, j-i+1);}for(int x = 0; x < m; x++){for(int y = x; y < m; y++){if(check(s.substring(i,j+1) + t.substring(x,y+1))){ans = Math.max(ans, j-i+1+y-x+1);}if(check(t.substring(x,y+1))){ans = Math.max(ans, y-x+1);}}}}}return ans;}boolean check(String s){int l = 0, r = s.length() - 1;while(l < r){if(s.charAt(l) != s.charAt(r))return false;l++;r--;}return true;}
}

三、3504. 子字符串连接后的最长回文串 II

题目链接

本题要构造一个最长的回文串，可以将它分成三个部分 —— ABA，它有两种情况：

• 情况一：s = "???AB??", t = "???A??"，A1 与 A2 互相回文，B 自身是一个回文串
• 情况二：s = "???A???", t = "??BA??"，A1 与 A2 互相回文，B 自身是一个回文串
• 注：A，B 长度都可以为 0

举一个例子 s = "???abcac??", t = "???ba??"，这里 A1 = “ab”，B = “cac”，A2 = “ba”，可以将它拆分成两个部分：

• A1 与 A2，这里换一个视角，将 A2 翻转过来，A1 就等于 A2，所以可以将 字符串t 反转一下，这部分实际上就变成了一个求 s 与 resT 的最长公共子串问题，可以使用 dp 来解决。
  • 定义 $f[i][j]$：以 $i$ 结尾的字符串$s$ 与 以 $j$ 结尾的字符串 $resT$ 的最长公共子串
  • $s[i]$ != $resT[j]$，$f[i][j]=0$
  • $s[i]$ == $resT[j]$，$f[i][j]=f[i-1][j-1]+1$
• B 这部分可以使用中心扩展法来枚举，由于回文串的长度可奇可偶，对于一个长度为 $n$ 的字符串，需要枚举的中心点就有 $n+(n-1)$ 个（奇数中心有 $n$ 个，偶数中心有 $n-1$ 个），可以从 0 枚举到 $2\ast n-2$，此时可以直接得到 $l=i/2,r=(i+1)/2$，然后向两边扩展就行。
• 此时的答案等于： $r-l+1+2\ast max(f[l-1])$

代码如下：

class Solution {int dfs(String S, String T){char[] s = S.toCharArray();char[] t = T.toCharArray();int n = s.length, m = t.length;int[][] f = new int[n+1][m+1];int[] mx = new int[n+1]; // 统计以 i-1 结尾的字符串S 与 字符串T 的最长公共子串长度int ans = 0;for(int i = 0; i < n; i++){for(int j = 0; j < m; j++){if(s[i] == t[j]){f[i+1][j+1] = f[i][j] + 1;mx[i+1] = Math.max(f[i+1][j+1], mx[i+1]);}}ans = Math.max(ans, 2 * mx[i+1]); // B 为 0 的情况}for(int i = 0; i < 2 * n - 1; i++){ // 中心扩展int l = i / 2;int r = (i + 1) / 2;while(l >= 0 && r < n && s[l] == s[r]){l--;r++;}if(l+1 <= r-1) // 判断 s[l+1, r-1] 不为空 ans = Math.max(ans, r - l - 1 + 2 * mx[l+1]);}return ans;}public int longestPalindrome(String s, String t) {String resT = new StringBuilder(t).reverse().toString();// 分别计算 AB与A，A与BA 两种情况return Math.max(dfs(s, resT), dfs(resT, s)); }
}

四、3505. 使 K 个子数组内元素相等的最少操作数

题目链接

本题是一道综合题：

• 长度为 $x$ 的子数组，说明要使用 滑动窗口
• 求子数组中所有元素相等的最小操作次数，肯定是变成中位数操作次数最小，求中位数
• 求包含 $k$ 个长度 恰好 为 x 的不重叠子数组（每个子数组中的所有元素都相等）所需要的最少操作数，这是 dp

先来解决如何计算滑窗中位数，使用对顶堆解决，准备两个堆，一个大根堆 left，一个小根堆right：

• 由特殊到一般，如果给定一个无序数组，如何求它的中位数（不排序做法）
  • 中位数只会出现在有序数组的中间位置，所以可以使用 left 来统计数组的前半段，right 来统计数组的后半段，保证 left.size() >= right.size()，此时中位数一定就是 left的堆顶元素（1/2个）。明确了大概的方向，接下来就是如何动态维护元素入堆
  • 对于元素 x，如何判断它是进入 left 还是 right，分情况讨论：
    • 如果 left.size() <= right.size()，那么一定要把x放入left，但是这里会出现一个问题，x 可能比rgiht.peek()还要大，如果直接把 x 放入left，那么有序性就被打破，所以最好的做法是先将 x 放入right，然后把 right.poll() 放入 left 中
    • 如果 left.size() > right.size()，那么一定要把x放入right，但是这里也会出现一个问题，x 可能比left.peek()还要小，如果直接把 x 放入right，那么有序性就被打破，所以最好的做法是先将x放入left，然后把 left.poll() 放入 right 中
• 上述做法已经把入堆的操作讲完了，接下来就是在滑窗过程中如何出元素，假设该元素为 out
  • 先判断 out 在那个堆当中
  • 如果 out <= left.peek()，说明它在left，需要将它从left移除。但是仅仅这样还不行，它还会出现一个问题如果移除之后 left.size() < rgiht.size()，那么就不符合我们上述的定义了，还需要将 right.poll() 放入 left
  • 如果 out > left.peek()，说明它在right，需要将它从right移除。同理这样也不行，它会出现一个问题如果移除之后 left.size() > rgiht.size() + 1，那么也不符合我们上述的定义，需要将 left.poll() 放入 right
  • 最后，left的堆顶元素(1/2个) 就是该滑窗的中位数

滑窗中位数有了，接下来就是计算——将窗口中元素全部变为中位数所需的操作次数，画个图好理解：

得到 $res$ 数组（res[i]：将 [i，i+k-1] 所有数变成中位数的操作次数）之后，剩下的就是枚举选哪 $k$ 个不重叠的子数组，直接使用 dp 来做，定义 f[i][j]:在前 j 个数中，选择 i 个长度为 x 的不重叠子数组所需的最小操作次数

• 对于f[i][j]，即以下标为 j-1 结尾的子数组有选或不选两种情况：
• 不选，它直接从 f[i][j-1] 转移过来，f[i][j] = f[i][j-1]
• 选，题目要求它不能重叠，所以选的子数组下标是[j-k，j-1]，需要从 f[i-1][j-k](这里j-k表示的是前 j-k 个数，也就是 [0,j-k-1] 选 i-1 个数的最小操作次数) 转移过来，f[i][j] = f[i-1][j-k] + res[j-k]

代码如下：

class Solution {public long minOperations(int[] nums, int x, int k) {long[] res = medianSlidingWindow(nums, x);//[i, i + x - 1]int n = nums.length;long[][] f = new long[k+1][n+1];// f[i][j] = min(f[i][j-1], f[i-1][j-x] + res[j-x])for(int i = 1; i <= k; i++){f[i][i*x-1] = Long.MAX_VALUE;for(int j = i * x; j <= n - (k - i) * x; j++){f[i][j] = Math.min(f[i][j-1], f[i-1][j-x] + res[j-x]);}}return f[k][n];}public long[] medianSlidingWindow(int[] nums, int k) {int n = nums.length;long[] ans = new long[n-k+1];LazyHeap left = new LazyHeap((x, y) -> Integer.compare(y, x));LazyHeap right = new LazyHeap((x, y) -> Integer.compare(x, y));for(int l = 0, r = 0; r < n; r++){int in = nums[r];// 入堆操作if(left.size() == right.size()){left.push(right.pushPop(in));}else{right.push(left.pushPop(in));}if(r < k - 1) continue;int x = left.top();// 计算变成中位数所需操作次数ans[l] = (long) x * (k % 2) + right.sum() - left.sum();int out = nums[l];// 出堆操作if(out <= left.peek()){left.remove(out);if(left.size() < right.size()){left.push(right.pop());}}else{right.remove(out);if(left.size() > right.size() + 1){right.push(left.pop());}}l++;}return ans;}
}
// 手写的懒删除堆（否则会超时）
class LazyHeap extends PriorityQueue<Integer> {//统计当前每个元素需要删除次数private final Map<Integer, Integer> removeCnt = new HashMap<>();//实际堆的大小private int size = 0;private long sum = 0;public LazyHeap(Comparator<Integer> comparator){super(comparator);}public int size(){return size;}public long sum(){return sum;}//懒删除操作public void remove(int x){removeCnt.merge(x, 1, Integer::sum);size--;sum -= x;}//实际执行删除操作private void applyRemove(){while(removeCnt.getOrDefault(peek(), 0) > 0){removeCnt.merge(poll(), -1, Integer::sum);}}//查看推顶元素public int top(){applyRemove();return peek();}//出堆public int pop(){applyRemove();size--;sum -= peek();return poll();}//入堆public void push(int x){int c = removeCnt.getOrDefault(x, 0);if(c > 0){removeCnt.put(x, c - 1);}else{offer(x);}sum += x;size++;}//push(x), pop()public int pushPop(int x){applyRemove();sum += x;offer(x);sum -= peek();return poll();}
}