From 141e31a7a9fec5a7365f0ff435d753275e43ded2 Mon Sep 17 00:00:00 2001 From: yanglbme Date: Tue, 20 May 2025 20:28:24 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.3555 No.3555.Smallest Subarray to Sort in Every Sliding Window --- .../README.md | 159 +++++++++++++++++- .../README_EN.md | 159 +++++++++++++++++- .../Solution.cpp | 30 ++++ .../Solution.go | 32 ++++ .../Solution.java | 33 ++++ .../Solution.py | 19 +++ .../Solution.ts | 30 ++++ 7 files changed, 454 insertions(+), 8 deletions(-) create mode 100644 solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.cpp create mode 100644 solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.go create mode 100644 solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.java create mode 100644 solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.py create mode 100644 solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.ts diff --git a/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/README.md b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/README.md index 7d762c126b8fc..82e631eef37aa 100644 --- a/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/README.md +++ b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/README.md @@ -69,32 +69,183 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3500-3599/3555.Sm -### 方法一 +### 方法一：枚举 + 维护左侧最大值和右侧最小值 + +我们可以枚举每个长度为 $k$ 的子数组，对于每个子数组 $nums[i...i + k - 1]$，我们需要找到最小的连续段，使得排序后整个子数组都是非递减的。 + +对于子数组 $nums[i...i + k - 1]$，我们可以从左到右遍历数组，维护一个最大值 $mx$，如果当前值小于 $mx$，说明当前值不在正确的位置上，我们更新右边界 $r$ 为当前位置。同理，我们可以从右到左遍历数组，维护一个最小值 $mi$，如果当前值大于 $mi$，说明当前值不在正确的位置上，我们更新左边界 $l$ 为当前位置。在初始化时，我们将 $l$ 和 $r$ 都初始化为 $-1$，如果 $l$ 和 $r$ 都没有被更新，说明数组已经有序，返回 $0$，否则返回 $r - l + 1$。 + +时间复杂度 $O(n \times k)$，其中 $n$ 是数组 $\textit{nums}$ 的长度。空间复杂度 $O(1)$。 #### Python3 ```python - +class Solution: + def minSubarraySort(self, nums: List[int], k: int) -> List[int]: + def f(i: int, j: int) -> int: + mi, mx = inf, -inf + l = r = -1 + for k in range(i, j + 1): + if mx > nums[k]: + r = k + else: + mx = nums[k] + p = j - k + i + if mi < nums[p]: + l = p + else: + mi = nums[p] + return 0 if r == -1 else r - l + 1 + + n = len(nums) + return [f(i, i + k - 1) for i in range(n - k + 1)] ``` #### Java ```java - +class Solution { + private int[] nums; + private final int inf = 1 << 30; + + public int[] minSubarraySort(int[] nums, int k) { + this.nums = nums; + int n = nums.length; + int[] ans = new int[n - k + 1]; + for (int i = 0; i < n - k + 1; ++i) { + ans[i] = f(i, i + k - 1); + } + return ans; + } + + private int f(int i, int j) { + int mi = inf, mx = -inf; + int l = -1, r = -1; + for (int k = i; k <= j; ++k) { + if (nums[k] < mx) { + r = k; + } else { + mx = nums[k]; + } + int p = j - k + i; + if (nums[p] > mi) { + l = p; + } else { + mi = nums[p]; + } + } + return r == -1 ? 0 : r - l + 1; + } +} ``` #### C++ ```cpp - +class Solution { +public: + vector minSubarraySort(vector& nums, int k) { + const int inf = 1 << 30; + int n = nums.size(); + auto f = [&](int i, int j) -> int { + int mi = inf, mx = -inf; + int l = -1, r = -1; + for (int k = i; k <= j; ++k) { + if (nums[k] < mx) { + r = k; + } else { + mx = nums[k]; + } + int p = j - k + i; + if (nums[p] > mi) { + l = p; + } else { + mi = nums[p]; + } + } + return r == -1 ? 0 : r - l + 1; + }; + vector ans; + for (int i = 0; i < n - k + 1; ++i) { + ans.push_back(f(i, i + k - 1)); + } + return ans; + } +}; ``` #### Go ```go +func minSubarraySort(nums []int, k int) []int { + const inf = 1 << 30 + n := len(nums) + f := func(i, j int) int { + mi := inf + mx := -inf + l, r := -1, -1 + for p := i; p <= j; p++ { + if nums[p] < mx { + r = p + } else { + mx = nums[p] + } + q := j - p + i + if nums[q] > mi { + l = q + } else { + mi = nums[q] + } + } + if r == -1 { + return 0 + } + return r - l + 1 + } + + ans := make([]int, 0, n-k+1) + for i := 0; i <= n-k; i++ { + ans = append(ans, f(i, i+k-1)) + } + return ans +} +``` +#### TypeScript + +```ts +function minSubarraySort(nums: number[], k: number): number[] { + const inf = Infinity; + const n = nums.length; + const f = (i: number, j: number): number => { + let mi = inf; + let mx = -inf; + let l = -1, + r = -1; + for (let p = i; p <= j; ++p) { + if (nums[p] < mx) { + r = p; + } else { + mx = nums[p]; + } + const q = j - p + i; + if (nums[q] > mi) { + l = q; + } else { + mi = nums[q]; + } + } + return r === -1 ? 0 : r - l + 1; + }; + + const ans: number[] = []; + for (let i = 0; i <= n - k; ++i) { + ans.push(f(i, i + k - 1)); + } + return ans; +} ``` diff --git a/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/README_EN.md b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/README_EN.md index f8a58575d7e24..0573791ebb1e9 100644 --- a/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/README_EN.md +++ b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/README_EN.md @@ -67,32 +67,183 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3500-3599/3555.Sm -### Solution 1 +### Solution 1: Enumeration + Maintaining Left Maximum and Right Minimum + +We can enumerate every subarray of length $k$. For each subarray $nums[i...i + k - 1]$, we need to find the smallest continuous segment such that, after sorting it, the entire subarray becomes non-decreasing. + +For the subarray $nums[i...i + k - 1]$, we can traverse from left to right, maintaining a maximum value $mx$. If the current value is less than $mx$, it means the current value is not in the correct position, so we update the right boundary $r$ to the current position. Similarly, we can traverse from right to left, maintaining a minimum value $mi$. If the current value is greater than $mi$, it means the current value is not in the correct position, so we update the left boundary $l$ to the current position. Initially, both $l$ and $r$ are set to $-1$. If neither $l$ nor $r$ is updated, it means the subarray is already sorted, so we return $0$; otherwise, we return $r - l + 1$. + +The time complexity is $O(n \times k)$, where $n$ is the length of the array $\textit{nums}$. The space complexity is $O(1)$. #### Python3 ```python - +class Solution: + def minSubarraySort(self, nums: List[int], k: int) -> List[int]: + def f(i: int, j: int) -> int: + mi, mx = inf, -inf + l = r = -1 + for k in range(i, j + 1): + if mx > nums[k]: + r = k + else: + mx = nums[k] + p = j - k + i + if mi < nums[p]: + l = p + else: + mi = nums[p] + return 0 if r == -1 else r - l + 1 + + n = len(nums) + return [f(i, i + k - 1) for i in range(n - k + 1)] ``` #### Java ```java - +class Solution { + private int[] nums; + private final int inf = 1 << 30; + + public int[] minSubarraySort(int[] nums, int k) { + this.nums = nums; + int n = nums.length; + int[] ans = new int[n - k + 1]; + for (int i = 0; i < n - k + 1; ++i) { + ans[i] = f(i, i + k - 1); + } + return ans; + } + + private int f(int i, int j) { + int mi = inf, mx = -inf; + int l = -1, r = -1; + for (int k = i; k <= j; ++k) { + if (nums[k] < mx) { + r = k; + } else { + mx = nums[k]; + } + int p = j - k + i; + if (nums[p] > mi) { + l = p; + } else { + mi = nums[p]; + } + } + return r == -1 ? 0 : r - l + 1; + } +} ``` #### C++ ```cpp - +class Solution { +public: + vector minSubarraySort(vector& nums, int k) { + const int inf = 1 << 30; + int n = nums.size(); + auto f = [&](int i, int j) -> int { + int mi = inf, mx = -inf; + int l = -1, r = -1; + for (int k = i; k <= j; ++k) { + if (nums[k] < mx) { + r = k; + } else { + mx = nums[k]; + } + int p = j - k + i; + if (nums[p] > mi) { + l = p; + } else { + mi = nums[p]; + } + } + return r == -1 ? 0 : r - l + 1; + }; + vector ans; + for (int i = 0; i < n - k + 1; ++i) { + ans.push_back(f(i, i + k - 1)); + } + return ans; + } +}; ``` #### Go ```go +func minSubarraySort(nums []int, k int) []int { + const inf = 1 << 30 + n := len(nums) + f := func(i, j int) int { + mi := inf + mx := -inf + l, r := -1, -1 + for p := i; p <= j; p++ { + if nums[p] < mx { + r = p + } else { + mx = nums[p] + } + q := j - p + i + if nums[q] > mi { + l = q + } else { + mi = nums[q] + } + } + if r == -1 { + return 0 + } + return r - l + 1 + } + + ans := make([]int, 0, n-k+1) + for i := 0; i <= n-k; i++ { + ans = append(ans, f(i, i+k-1)) + } + return ans +} +``` +#### TypeScript + +```ts +function minSubarraySort(nums: number[], k: number): number[] { + const inf = Infinity; + const n = nums.length; + const f = (i: number, j: number): number => { + let mi = inf; + let mx = -inf; + let l = -1, + r = -1; + for (let p = i; p <= j; ++p) { + if (nums[p] < mx) { + r = p; + } else { + mx = nums[p]; + } + const q = j - p + i; + if (nums[q] > mi) { + l = q; + } else { + mi = nums[q]; + } + } + return r === -1 ? 0 : r - l + 1; + }; + + const ans: number[] = []; + for (let i = 0; i <= n - k; ++i) { + ans.push(f(i, i + k - 1)); + } + return ans; +} ``` diff --git a/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.cpp b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.cpp new file mode 100644 index 0000000000000..3ae0b6ab3b649 --- /dev/null +++ b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.cpp @@ -0,0 +1,30 @@ +class Solution { +public: + vector minSubarraySort(vector& nums, int k) { + const int inf = 1 << 30; + int n = nums.size(); + auto f = [&](int i, int j) -> int { + int mi = inf, mx = -inf; + int l = -1, r = -1; + for (int k = i; k <= j; ++k) { + if (nums[k] < mx) { + r = k; + } else { + mx = nums[k]; + } + int p = j - k + i; + if (nums[p] > mi) { + l = p; + } else { + mi = nums[p]; + } + } + return r == -1 ? 0 : r - l + 1; + }; + vector ans; + for (int i = 0; i < n - k + 1; ++i) { + ans.push_back(f(i, i + k - 1)); + } + return ans; + } +}; \ No newline at end of file diff --git a/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.go b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.go new file mode 100644 index 0000000000000..2e7bf6bb046ab --- /dev/null +++ b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.go @@ -0,0 +1,32 @@ +func minSubarraySort(nums []int, k int) []int { + const inf = 1 << 30 + n := len(nums) + f := func(i, j int) int { + mi := inf + mx := -inf + l, r := -1, -1 + for p := i; p <= j; p++ { + if nums[p] < mx { + r = p + } else { + mx = nums[p] + } + q := j - p + i + if nums[q] > mi { + l = q + } else { + mi = nums[q] + } + } + if r == -1 { + return 0 + } + return r - l + 1 + } + + ans := make([]int, 0, n-k+1) + for i := 0; i <= n-k; i++ { + ans = append(ans, f(i, i+k-1)) + } + return ans +} diff --git a/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.java b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.java new file mode 100644 index 0000000000000..d5ca5e9504c1d --- /dev/null +++ b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.java @@ -0,0 +1,33 @@ +class Solution { + private int[] nums; + private final int inf = 1 << 30; + + public int[] minSubarraySort(int[] nums, int k) { + this.nums = nums; + int n = nums.length; + int[] ans = new int[n - k + 1]; + for (int i = 0; i < n - k + 1; ++i) { + ans[i] = f(i, i + k - 1); + } + return ans; + } + + private int f(int i, int j) { + int mi = inf, mx = -inf; + int l = -1, r = -1; + for (int k = i; k <= j; ++k) { + if (nums[k] < mx) { + r = k; + } else { + mx = nums[k]; + } + int p = j - k + i; + if (nums[p] > mi) { + l = p; + } else { + mi = nums[p]; + } + } + return r == -1 ? 0 : r - l + 1; + } +} \ No newline at end of file diff --git a/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.py b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.py new file mode 100644 index 0000000000000..a89989c4befb3 --- /dev/null +++ b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.py @@ -0,0 +1,19 @@ +class Solution: + def minSubarraySort(self, nums: List[int], k: int) -> List[int]: + def f(i: int, j: int) -> int: + mi, mx = inf, -inf + l = r = -1 + for k in range(i, j + 1): + if mx > nums[k]: + r = k + else: + mx = nums[k] + p = j - k + i + if mi < nums[p]: + l = p + else: + mi = nums[p] + return 0 if r == -1 else r - l + 1 + + n = len(nums) + return [f(i, i + k - 1) for i in range(n - k + 1)] diff --git a/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.ts b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.ts new file mode 100644 index 0000000000000..be8ccc5a310dc --- /dev/null +++ b/solution/3500-3599/3555.Smallest Subarray to Sort in Every Sliding Window/Solution.ts @@ -0,0 +1,30 @@ +function minSubarraySort(nums: number[], k: number): number[] { + const inf = Infinity; + const n = nums.length; + const f = (i: number, j: number): number => { + let mi = inf; + let mx = -inf; + let l = -1, + r = -1; + for (let p = i; p <= j; ++p) { + if (nums[p] < mx) { + r = p; + } else { + mx = nums[p]; + } + const q = j - p + i; + if (nums[q] > mi) { + l = q; + } else { + mi = nums[q]; + } + } + return r === -1 ? 0 : r - l + 1; + }; + + const ans: number[] = []; + for (let i = 0; i <= n - k; ++i) { + ans.push(f(i, i + k - 1)); + } + return ans; +}