+ problem 2547

fruit-in · fruit-in · commit a6448b35988a · 2025-03-28T17:46:12.000+08:00
diff --git a/Problemset/2547-Minimum Cost to Split an Array/README.md b/Problemset/2547-Minimum Cost to Split an Array/README.md
@@ -0,0 +1,82 @@
+# 2547. Minimum Cost to Split an Array
+You are given an integer array `nums` and an integer `k`.
+
+Split the array into some number of non-empty subarrays. The **cost** of a split is the sum of the **importance value** of each subarray in the split.
+
+Let `trimmed(subarray)` be the version of the subarray where all numbers which appear only once are removed.
+
+* For example, `trimmed([3,1,2,4,3,4]) = [3,4,3,4]`.
+
+The **importance value** of a subarray is `k + trimmed(subarray).length`.
+
+* For example, if a subarray is `[1,2,3,3,3,4,4]`, then trimmed(`[1,2,3,3,3,4,4]) = [3,3,3,4,4].`The importance value of this subarray will be `k + 5`.
+
+Return *the minimum possible cost of a split of* `nums`.
+
+A **subarray** is a contiguous **non-empty** sequence of elements within an array.
+
+#### Example 1:
+<pre>
+<strong>Input:</strong> nums = [1,2,1,2,1,3,3], k = 2
+<strong>Output:</strong> 8
+<strong>Explanation:</strong> We split nums to have two subarrays: [1,2], [1,2,1,3,3].
+The importance value of [1,2] is 2 + (0) = 2.
+The importance value of [1,2,1,3,3] is 2 + (2 + 2) = 6.
+The cost of the split is 2 + 6 = 8. It can be shown that this is the minimum possible cost among all the possible splits.
+</pre>
+
+#### Example 2:
+<pre>
+<strong>Input:</strong> nums = [1,2,1,2,1], k = 2
+<strong>Output:</strong> 6
+<strong>Explanation:</strong> We split nums to have two subarrays: [1,2], [1,2,1].
+The importance value of [1,2] is 2 + (0) = 2.
+The importance value of [1,2,1] is 2 + (2) = 4.
+The cost of the split is 2 + 4 = 6. It can be shown that this is the minimum possible cost among all the possible splits.
+</pre>
+
+#### Example 3:
+<pre>
+<strong>Input:</strong> nums = [1,2,1,2,1], k = 5
+<strong>Output:</strong> 10
+<strong>Explanation:</strong> We split nums to have one subarray: [1,2,1,2,1].
+The importance value of [1,2,1,2,1] is 5 + (3 + 2) = 10.
+The cost of the split is 10. It can be shown that this is the minimum possible cost among all the possible splits.
+</pre>
+
+#### Constraints:
+* `1 <= nums.length <= 1000`
+* `0 <= nums[i] < nums.length`
+* <code>1 <= k <= 10<sup>9</sup></code>
+
+## Solutions (Rust)
+
+### 1. Solution
+```Rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn min_cost(nums: Vec<i32>, k: i32) -> i32 {
+        let k = k as i64;
+        let mut dp = vec![i64::MAX; nums.len() + 1];
+        dp[0] = 0;
+
+        for i in 1..dp.len() {
+            let mut count = HashMap::new();
+            let mut trimmed_length = 0;
+
+            for j in (0..i).rev() {
+                *count.entry(nums[j]).or_insert(0) += 1;
+                trimmed_length += match count.get(&nums[j]).unwrap() {
+                    &1 => 0,
+                    &2 => 2,
+                    _ => 1,
+                };
+                dp[i] = dp[i].min(dp[j] + k + trimmed_length);
+            }
+        }
+
+        *dp.last().unwrap() as i32
+    }
+}
+```
diff --git a/Problemset/2547-Minimum Cost to Split an Array/README_CN.md b/Problemset/2547-Minimum Cost to Split an Array/README_CN.md
@@ -0,0 +1,82 @@
+# 2547. 拆分数组的最小代价
+给你一个整数数组 `nums` 和一个整数 `k` 。
+
+将数组拆分成一些非空子数组。拆分的 **代价** 是每个子数组中的 **重要性** 之和。
+
+令 `trimmed(subarray)` 作为子数组的一个特征，其中所有仅出现一次的数字将会被移除。
+
+* 例如，`trimmed([3,1,2,4,3,4]) = [3,4,3,4]` 。
+
+子数组的 **重要性** 定义为 `k + trimmed(subarray).length` 。
+
+* 例如，如果一个子数组是 `[1,2,3,3,3,4,4]` ，`trimmed([1,2,3,3,3,4,4]) = [3,3,3,4,4]` 。这个子数组的重要性就是 `k + 5` 。
+
+找出并返回拆分 `nums` 的所有可行方案中的最小代价。
+
+**子数组** 是数组的一个连续 **非空** 元素序列。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong> nums = [1,2,1,2,1,3,3], k = 2
+<strong>输出:</strong> 8
+<strong>解释:</strong> 将 nums 拆分成两个子数组：[1,2], [1,2,1,3,3]
+[1,2] 的重要性是 2 + (0) = 2 。
+[1,2,1,3,3] 的重要性是 2 + (2 + 2) = 6 。
+拆分的代价是 2 + 6 = 8 ，可以证明这是所有可行的拆分方案中的最小代价。
+</pre>
+
+#### 示例 2:
+<pre>
+<strong>输入:</strong> nums = [1,2,1,2,1], k = 2
+<strong>输出:</strong> 6
+<strong>解释:</strong> 将 nums 拆分成两个子数组：[1,2], [1,2,1] 。
+[1,2] 的重要性是 2 + (0) = 2 。
+[1,2,1] 的重要性是 2 + (2) = 4 。
+拆分的代价是 2 + 4 = 6 ，可以证明这是所有可行的拆分方案中的最小代价。
+</pre>
+
+#### 示例 3:
+<pre>
+<strong>输入:</strong> nums = [1,2,1,2,1], k = 5
+<strong>输出:</strong> 10
+<strong>解释:</strong> 将 nums 拆分成一个子数组：[1,2,1,2,1].
+[1,2,1,2,1] 的重要性是 5 + (3 + 2) = 10 。
+拆分的代价是 10 ，可以证明这是所有可行的拆分方案中的最小代价。
+</pre>
+
+#### 提示:
+* `1 <= nums.length <= 1000`
+* `0 <= nums[i] < nums.length`
+* <code>1 <= k <= 10<sup>9</sup></code>
+
+## 题解 (Rust)
+
+### 1. 题解
+```Rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn min_cost(nums: Vec<i32>, k: i32) -> i32 {
+        let k = k as i64;
+        let mut dp = vec![i64::MAX; nums.len() + 1];
+        dp[0] = 0;
+
+        for i in 1..dp.len() {
+            let mut count = HashMap::new();
+            let mut trimmed_length = 0;
+
+            for j in (0..i).rev() {
+                *count.entry(nums[j]).or_insert(0) += 1;
+                trimmed_length += match count.get(&nums[j]).unwrap() {
+                    &1 => 0,
+                    &2 => 2,
+                    _ => 1,
+                };
+                dp[i] = dp[i].min(dp[j] + k + trimmed_length);
+            }
+        }
+
+        *dp.last().unwrap() as i32
+    }
+}
+```
diff --git a/Problemset/2547-Minimum Cost to Split an Array/Solution.rs b/Problemset/2547-Minimum Cost to Split an Array/Solution.rs
@@ -0,0 +1,26 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn min_cost(nums: Vec<i32>, k: i32) -> i32 {
+        let k = k as i64;
+        let mut dp = vec![i64::MAX; nums.len() + 1];
+        dp[0] = 0;
+
+        for i in 1..dp.len() {
+            let mut count = HashMap::new();
+            let mut trimmed_length = 0;
+
+            for j in (0..i).rev() {
+                *count.entry(nums[j]).or_insert(0) += 1;
+                trimmed_length += match count.get(&nums[j]).unwrap() {
+                    &1 => 0,
+                    &2 => 2,
+                    _ => 1,
+                };
+                dp[i] = dp[i].min(dp[j] + k + trimmed_length);
+            }
+        }
+
+        *dp.last().unwrap() as i32
+    }
+}
diff --git a/README.md b/README.md
@@ -1584,6 +1584,7 @@
 [2540][2540l]|[Minimum Common Value][2540]                                                          |![rs]
 [2541][2541l]|[Minimum Operations to Make Array Equal II][2541]                                     |![rs]
 [2544][2544l]|[Alternating Digit Sum][2544]                                                         |![rs]
+[2547][2547l]|[Minimum Cost to Split an Array][2547]                                                |![rs]
 [2549][2549l]|[Count Distinct Numbers on Board][2549]                                               |![rs]
 [2550][2550l]|[Count Collisions of Monkeys on a Polygon][2550]                                      |![rs]
 [2553][2553l]|[Separate the Digits in an Array][2553]                                               |![rs]
@@ -3208,6 +3209,7 @@
 [2540]:Problemset/2540-Minimum%20Common%20Value/README.md#2540-minimum-common-value
 [2541]:Problemset/2541-Minimum%20Operations%20to%20Make%20Array%20Equal%20II/README.md#2541-minimum-operations-to-make-array-equal-ii
 [2544]:Problemset/2544-Alternating%20Digit%20Sum/README.md#2544-alternating-digit-sum
+[2547]:Problemset/2547-Minimum%20Cost%20to%20Split%20an%20Array/README.md#2547-minimum-cost-to-split-an-array
 [2549]:Problemset/2549-Count%20Distinct%20Numbers%20on%20Board/README.md#2549-count-distinct-numbers-on-board
 [2550]:Problemset/2550-Count%20Collisions%20of%20Monkeys%20on%20a%20Polygon/README.md#2550-count-collisions-of-monkeys-on-a-polygon
 [2553]:Problemset/2553-Separate%20the%20Digits%20in%20an%20Array/README.md#2553-separate-the-digits-in-an-array
@@ -4826,6 +4828,7 @@
 [2540l]:https://leetcode.com/problems/minimum-common-value/
 [2541l]:https://leetcode.com/problems/minimum-operations-to-make-array-equal-ii/
 [2544l]:https://leetcode.com/problems/alternating-digit-sum/
+[2547l]:https://leetcode.com/problems/minimum-cost-to-split-an-array/
 [2549l]:https://leetcode.com/problems/count-distinct-numbers-on-board/
 [2550l]:https://leetcode.com/problems/count-collisions-of-monkeys-on-a-polygon/
 [2553l]:https://leetcode.com/problems/separate-the-digits-in-an-array/
diff --git a/README_CN.md b/README_CN.md
@@ -1584,6 +1584,7 @@
 [2540][2540l]|[最小公共值][2540]                                        |![rs]
 [2541][2541l]|[使数组中所有元素相等的最小操作数 II][2541]               |![rs]
 [2544][2544l]|[交替数字和][2544]                                        |![rs]
+[2547][2547l]|[拆分数组的最小代价][2547]                                |![rs]
 [2549][2549l]|[统计桌面上的不同数字][2549]                              |![rs]
 [2550][2550l]|[猴子碰撞的方法数][2550]                                  |![rs]
 [2553][2553l]|[分割数组中数字的数位][2553]                              |![rs]
@@ -3208,6 +3209,7 @@
 [2540]:Problemset/2540-Minimum%20Common%20Value/README_CN.md#2540-最小公共值
 [2541]:Problemset/2541-Minimum%20Operations%20to%20Make%20Array%20Equal%20II/README_CN.md#2541-使数组中所有元素相等的最小操作数-ii
 [2544]:Problemset/2544-Alternating%20Digit%20Sum/README_CN.md#2544-交替数字和
+[2547]:Problemset/2547-Minimum%20Cost%20to%20Split%20an%20Array/README_CN.md#2547-拆分数组的最小代价
 [2549]:Problemset/2549-Count%20Distinct%20Numbers%20on%20Board/README_CN.md#2549-统计桌面上的不同数字
 [2550]:Problemset/2550-Count%20Collisions%20of%20Monkeys%20on%20a%20Polygon/README_CN.md#2550-猴子碰撞的方法数
 [2553]:Problemset/2553-Separate%20the%20Digits%20in%20an%20Array/README_CN.md#2553-分割数组中数字的数位
@@ -4826,6 +4828,7 @@
 [2540l]:https://leetcode.cn/problems/minimum-common-value/
 [2541l]:https://leetcode.cn/problems/minimum-operations-to-make-array-equal-ii/
 [2544l]:https://leetcode.cn/problems/alternating-digit-sum/
+[2547l]:https://leetcode.cn/problems/minimum-cost-to-split-an-array/
 [2549l]:https://leetcode.cn/problems/count-distinct-numbers-on-board/
 [2550l]:https://leetcode.cn/problems/count-collisions-of-monkeys-on-a-polygon/
 [2553l]:https://leetcode.cn/problems/separate-the-digits-in-an-array/
