diff --git a/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/README.md b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/README.md index 4beee1bfb0cca..8a0f90769365c 100644 --- a/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/README.md +++ b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/README.md @@ -70,32 +70,171 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3326.Mi -### 方法一 +### 方法一：预处理 + 贪心 + +根据题目描述， + +如果整数 $x$ 是质数，那么它的最大真因数是 $1$，那么 $x / 1 = x$，即 $x$ 不能再被除了； + +如果整数 $x$ 不是质数，我们假设 $x$ 的最大真因数为 $y$，那么 $x / y$ 一定是质数，因此，我们寻找最小质数 $\textit{lpf}[x]$，使得 $x \bmod \textit{lpf}[x] = 0$，使得 $x$ 变成 $\textit{lpf}[x]$，此时无法再被除了。 + +因此，我们可以预处理出 $1$ 到 $10^6$ 的每个整数的最小质因数，然后从右往左遍历数组，如果当前元素大于下一个元素，我们将当前元素变为它的最小质因数，如果当前元素变为它的最小质因数后，仍然大于下一个元素，说明无法将数组变成非递减的，返回 $-1$。否则，操作次数加一。继续遍历，直到遍历完整个数组。 + +预处理的时间复杂度为 $O(M \times \log \log M)$，其中 $M = 10^6$，遍历数组的时间复杂度为 $O(n)$，其中 $n$ 为数组的长度。空间复杂度为 $O(M)$。 #### Python3 ```python - +mx = 10**6 + 1 +lpf = [0] * (mx + 1) +for i in range(2, mx + 1): + if lpf[i] == 0: + for j in range(i, mx + 1, i): + if lpf[j] == 0: + lpf[j] = i + + +class Solution: + def minOperations(self, nums: List[int]) -> int: + ans = 0 + for i in range(len(nums) - 2, -1, -1): + if nums[i] > nums[i + 1]: + nums[i] = lpf[nums[i]] + if nums[i] > nums[i + 1]: + return -1 + ans += 1 + return ans ``` #### Java ```java - +class Solution { + private static final int MX = (int) 1e6 + 1; + private static final int[] LPF = new int[MX + 1]; + static { + for (int i = 2; i <= MX; ++i) { + for (int j = i; j <= MX; j += i) { + if (LPF[j] == 0) { + LPF[j] = i; + } + } + } + } + public int minOperations(int[] nums) { + int ans = 0; + for (int i = nums.length - 2; i >= 0; i--) { + if (nums[i] > nums[i + 1]) { + nums[i] = LPF[nums[i]]; + if (nums[i] > nums[i + 1]) { + return -1; + } + ans++; + } + } + return ans; + } +} ``` #### C++ ```cpp - +const int MX = 1e6; +int LPF[MX + 1]; + +auto init = [] { + for (int i = 2; i <= MX; i++) { + if (LPF[i] == 0) { + for (int j = i; j <= MX; j += i) { + if (LPF[j] == 0) { + LPF[j] = i; + } + } + } + } + return 0; +}(); + +class Solution { +public: + int minOperations(vector& nums) { + int ans = 0; + for (int i = nums.size() - 2; i >= 0; i--) { + if (nums[i] > nums[i + 1]) { + nums[i] = LPF[nums[i]]; + if (nums[i] > nums[i + 1]) { + return -1; + } + ans++; + } + } + return ans; + } +}; ``` #### Go ```go +const mx int = 1e6 + +var lpf = [mx + 1]int{} + +func init() { + for i := 2; i <= mx; i++ { + if lpf[i] == 0 { + for j := i; j <= mx; j += i { + if lpf[j] == 0 { + lpf[j] = i + } + } + } + } +} + +func minOperations(nums []int) (ans int) { + for i := len(nums) - 2; i >= 0; i-- { + if nums[i] > nums[i+1] { + nums[i] = lpf[nums[i]] + if nums[i] > nums[i+1] { + return -1 + } + ans++ + } + } + return +} +``` +#### TypeScript + +```ts +const mx = 10 ** 6; +const lpf = Array(mx + 1).fill(0); +for (let i = 2; i <= mx; ++i) { + for (let j = i; j <= mx; j += i) { + if (lpf[j] === 0) { + lpf[j] = i; + } + } +} + +function minOperations(nums: number[]): number { + let ans = 0; + for (let i = nums.length - 2; ~i; --i) { + if (nums[i] > nums[i + 1]) { + nums[i] = lpf[nums[i]]; + if (nums[i] > nums[i + 1]) { + return -1; + } + ++ans; + } + } + return ans; +} ``` diff --git a/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/README_EN.md b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/README_EN.md index 58878e2b8e546..f9e54053dd3f3 100644 --- a/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/README_EN.md +++ b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/README_EN.md @@ -67,32 +67,171 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3326.Mi -### Solution 1 +### Solution 1: Preprocessing + Greedy + +According to the problem description, + +If an integer $x$ is a prime number, then its largest proper divisor is $1$, so $x / 1 = x$, meaning $x$ cannot be divided further. + +If an integer $x$ is not a prime number, we assume the largest proper divisor of $x$ is $y$, then $x / y$ must be a prime number. Therefore, we find the smallest prime factor $\textit{lpf}[x]$ such that $x \bmod \textit{lpf}[x] = 0$, making $x$ become $\textit{lpf}[x]$, at which point it cannot be divided further. + +Thus, we can preprocess the smallest prime factor for each integer from $1$ to $10^6$. Then, we traverse the array from right to left. If the current element is greater than the next element, we change the current element to its smallest prime factor. If after changing the current element to its smallest prime factor it is still greater than the next element, it means the array cannot be made non-decreasing, and we return $-1$. Otherwise, we increment the operation count by one. Continue traversing until the entire array is processed. + +The time complexity for preprocessing is $O(M \times \log \log M)$, where $M = 10^6$. The time complexity for traversing the array is $O(n)$, where $n$ is the length of the array. The space complexity is $O(M)$. #### Python3 ```python - +mx = 10**6 + 1 +lpf = [0] * (mx + 1) +for i in range(2, mx + 1): + if lpf[i] == 0: + for j in range(i, mx + 1, i): + if lpf[j] == 0: + lpf[j] = i + + +class Solution: + def minOperations(self, nums: List[int]) -> int: + ans = 0 + for i in range(len(nums) - 2, -1, -1): + if nums[i] > nums[i + 1]: + nums[i] = lpf[nums[i]] + if nums[i] > nums[i + 1]: + return -1 + ans += 1 + return ans ``` #### Java ```java - +class Solution { + private static final int MX = (int) 1e6 + 1; + private static final int[] LPF = new int[MX + 1]; + static { + for (int i = 2; i <= MX; ++i) { + for (int j = i; j <= MX; j += i) { + if (LPF[j] == 0) { + LPF[j] = i; + } + } + } + } + public int minOperations(int[] nums) { + int ans = 0; + for (int i = nums.length - 2; i >= 0; i--) { + if (nums[i] > nums[i + 1]) { + nums[i] = LPF[nums[i]]; + if (nums[i] > nums[i + 1]) { + return -1; + } + ans++; + } + } + return ans; + } +} ``` #### C++ ```cpp - +const int MX = 1e6; +int LPF[MX + 1]; + +auto init = [] { + for (int i = 2; i <= MX; i++) { + if (LPF[i] == 0) { + for (int j = i; j <= MX; j += i) { + if (LPF[j] == 0) { + LPF[j] = i; + } + } + } + } + return 0; +}(); + +class Solution { +public: + int minOperations(vector& nums) { + int ans = 0; + for (int i = nums.size() - 2; i >= 0; i--) { + if (nums[i] > nums[i + 1]) { + nums[i] = LPF[nums[i]]; + if (nums[i] > nums[i + 1]) { + return -1; + } + ans++; + } + } + return ans; + } +}; ``` #### Go ```go +const mx int = 1e6 + +var lpf = [mx + 1]int{} + +func init() { + for i := 2; i <= mx; i++ { + if lpf[i] == 0 { + for j := i; j <= mx; j += i { + if lpf[j] == 0 { + lpf[j] = i + } + } + } + } +} + +func minOperations(nums []int) (ans int) { + for i := len(nums) - 2; i >= 0; i-- { + if nums[i] > nums[i+1] { + nums[i] = lpf[nums[i]] + if nums[i] > nums[i+1] { + return -1 + } + ans++ + } + } + return +} +``` +#### TypeScript + +```ts +const mx = 10 ** 6; +const lpf = Array(mx + 1).fill(0); +for (let i = 2; i <= mx; ++i) { + for (let j = i; j <= mx; j += i) { + if (lpf[j] === 0) { + lpf[j] = i; + } + } +} + +function minOperations(nums: number[]): number { + let ans = 0; + for (let i = nums.length - 2; ~i; --i) { + if (nums[i] > nums[i + 1]) { + nums[i] = lpf[nums[i]]; + if (nums[i] > nums[i + 1]) { + return -1; + } + ++ans; + } + } + return ans; +} ``` diff --git a/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.cpp b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.cpp new file mode 100644 index 0000000000000..95c6dbc37b71e --- /dev/null +++ b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.cpp @@ -0,0 +1,32 @@ +const int MX = 1e6; +int LPF[MX + 1]; + +auto init = [] { + for (int i = 2; i <= MX; i++) { + if (LPF[i] == 0) { + for (int j = i; j <= MX; j += i) { + if (LPF[j] == 0) { + LPF[j] = i; + } + } + } + } + return 0; +}(); + +class Solution { +public: + int minOperations(vector& nums) { + int ans = 0; + for (int i = nums.size() - 2; i >= 0; i--) { + if (nums[i] > nums[i + 1]) { + nums[i] = LPF[nums[i]]; + if (nums[i] > nums[i + 1]) { + return -1; + } + ans++; + } + } + return ans; + } +}; diff --git a/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.go b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.go new file mode 100644 index 0000000000000..ad8b10ca0ad84 --- /dev/null +++ b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.go @@ -0,0 +1,28 @@ +const mx int = 1e6 + +var lpf = [mx + 1]int{} + +func init() { + for i := 2; i <= mx; i++ { + if lpf[i] == 0 { + for j := i; j <= mx; j += i { + if lpf[j] == 0 { + lpf[j] = i + } + } + } + } +} + +func minOperations(nums []int) (ans int) { + for i := len(nums) - 2; i >= 0; i-- { + if nums[i] > nums[i+1] { + nums[i] = lpf[nums[i]] + if nums[i] > nums[i+1] { + return -1 + } + ans++ + } + } + return +} diff --git a/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.java b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.java new file mode 100644 index 0000000000000..77a46ec0cfd30 --- /dev/null +++ b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.java @@ -0,0 +1,26 @@ +class Solution { + private static final int MX = (int) 1e6 + 1; + private static final int[] LPF = new int[MX + 1]; + static { + for (int i = 2; i <= MX; ++i) { + for (int j = i; j <= MX; j += i) { + if (LPF[j] == 0) { + LPF[j] = i; + } + } + } + } + public int minOperations(int[] nums) { + int ans = 0; + for (int i = nums.length - 2; i >= 0; i--) { + if (nums[i] > nums[i + 1]) { + nums[i] = LPF[nums[i]]; + if (nums[i] > nums[i + 1]) { + return -1; + } + ans++; + } + } + return ans; + } +} diff --git a/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.py b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.py new file mode 100644 index 0000000000000..30984f505d427 --- /dev/null +++ b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.py @@ -0,0 +1,19 @@ +mx = 10**6 + 1 +lpf = [0] * (mx + 1) +for i in range(2, mx + 1): + if lpf[i] == 0: + for j in range(i, mx + 1, i): + if lpf[j] == 0: + lpf[j] = i + + +class Solution: + def minOperations(self, nums: List[int]) -> int: + ans = 0 + for i in range(len(nums) - 2, -1, -1): + if nums[i] > nums[i + 1]: + nums[i] = lpf[nums[i]] + if nums[i] > nums[i + 1]: + return -1 + ans += 1 + return ans diff --git a/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.ts b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.ts new file mode 100644 index 0000000000000..4e32b89fc8a14 --- /dev/null +++ b/solution/3300-3399/3326.Minimum Division Operations to Make Array Non Decreasing/Solution.ts @@ -0,0 +1,23 @@ +const mx = 10 ** 6; +const lpf = Array(mx + 1).fill(0); +for (let i = 2; i <= mx; ++i) { + for (let j = i; j <= mx; j += i) { + if (lpf[j] === 0) { + lpf[j] = i; + } + } +} + +function minOperations(nums: number[]): number { + let ans = 0; + for (let i = nums.length - 2; ~i; --i) { + if (nums[i] > nums[i + 1]) { + nums[i] = lpf[nums[i]]; + if (nums[i] > nums[i + 1]) { + return -1; + } + ++ans; + } + } + return ans; +}