diff --git a/solution/3500-3599/3576.Transform Array to All Equal Elements/README.md b/solution/3500-3599/3576.Transform Array to All Equal Elements/README.md index 414335c0a3574..4d5e223b9424c 100644 --- a/solution/3500-3599/3576.Transform Array to All Equal Elements/README.md +++ b/solution/3500-3599/3576.Transform Array to All Equal Elements/README.md @@ -75,32 +75,129 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3500-3599/3576.Tr -### 方法一 +### 方法一：遍历计数 + +根据题目描述，要使得数组的所有元素相等，要么所有元素为 $\textit{nums}[0]$，要么所有元素为 $-\textit{nums}[0]$。因此，我们设计一个函数 $\textit{check}$，用于判断在最多 $k$ 次操作后，数组能否变成所有元素为 $\textit{target}$ 的形式。 + +该函数的思路是遍历数组，记录需要进行操作的次数。一个元素要么修改一次，要么不修改。如果当前元素与目标值相等，则不需要修改，继续遍历下一个元素；如果当前元素与目标值不相等，则需要修改，计数器加一，并将符号切换为负数，表示后续元素需要进行相反的操作。 + +如果遍历结束后，计数器小于等于 $k$ 且最后一个元素的符号与目标值相同，则返回 $\textit{true}$，否则返回 $\textit{false}$。 + +最终答案是 $\textit{check}(\textit{nums}[0], k)$ 或 $\textit{check}(-\textit{nums}[0], k)$ 的结果。 + +时间复杂度 $O(n)$，其中 $n$ 是数组的长度。空间复杂度 $O(1)$。 #### Python3 ```python - +class Solution: + def canMakeEqual(self, nums: List[int], k: int) -> bool: + def check(target: int, k: int) -> bool: + cnt, sign = 0, 1 + for i in range(len(nums) - 1): + x = nums[i] * sign + if x == target: + sign = 1 + else: + sign = -1 + cnt += 1 + return cnt <= k and nums[-1] * sign == target + + return check(nums[0], k) or check(-nums[0], k) ``` #### Java ```java - +class Solution { + public boolean canMakeEqual(int[] nums, int k) { + return check(nums, nums[0], k) || check(nums, -nums[0], k); + } + + private boolean check(int[] nums, int target, int k) { + int cnt = 0, sign = 1; + for (int i = 0; i < nums.length - 1; ++i) { + int x = nums[i] * sign; + if (x == target) { + sign = 1; + } else { + sign = -1; + ++cnt; + } + } + return cnt <= k && nums[nums.length - 1] * sign == target; + } +} ``` #### C++ ```cpp - +class Solution { +public: + bool canMakeEqual(vector& nums, int k) { + auto check = [&](int target, int k) -> bool { + int n = nums.size(); + int cnt = 0, sign = 1; + for (int i = 0; i < n - 1; ++i) { + int x = nums[i] * sign; + if (x == target) { + sign = 1; + } else { + sign = -1; + ++cnt; + } + } + return cnt <= k && nums[n - 1] * sign == target; + }; + return check(nums[0], k) || check(-nums[0], k); + } +}; ``` #### Go ```go +func canMakeEqual(nums []int, k int) bool { + check := func(target, k int) bool { + cnt, sign := 0, 1 + for i := 0; i < len(nums)-1; i++ { + x := nums[i] * sign + if x == target { + sign = 1 + } else { + sign = -1 + cnt++ + } + } + return cnt <= k && nums[len(nums)-1]*sign == target + } + return check(nums[0], k) || check(-nums[0], k) +} +``` +#### TypeScript + +```ts +function canMakeEqual(nums: number[], k: number): boolean { + function check(target: number, k: number): boolean { + let [cnt, sign] = [0, 1]; + for (let i = 0; i < nums.length - 1; i++) { + const x = nums[i] * sign; + if (x === target) { + sign = 1; + } else { + sign = -1; + cnt++; + } + } + return cnt <= k && nums[nums.length - 1] * sign === target; + } + + return check(nums[0], k) || check(-nums[0], k); +} ``` diff --git a/solution/3500-3599/3576.Transform Array to All Equal Elements/README_EN.md b/solution/3500-3599/3576.Transform Array to All Equal Elements/README_EN.md index cb7b22ea8c9a6..b6485bc574d1a 100644 --- a/solution/3500-3599/3576.Transform Array to All Equal Elements/README_EN.md +++ b/solution/3500-3599/3576.Transform Array to All Equal Elements/README_EN.md @@ -73,32 +73,129 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3500-3599/3576.Tr -### Solution 1 +### Solution 1: Traversal and Counting + +According to the problem description, to make all elements in the array equal, all elements must be either $\textit{nums}[0]$ or $-\textit{nums}[0]$. Therefore, we design a function $\textit{check}$ to determine whether the array can be transformed into all elements equal to $\textit{target}$ with at most $k$ operations. + +The idea of this function is to traverse the array and count the number of operations needed. Each element is either modified once or not at all. If the current element is equal to the target value, no modification is needed and we continue to the next element. If the current element is not equal to the target value, an operation is needed, increment the counter, and flip the sign, indicating that subsequent elements need the opposite operation. + +After the traversal, if the counter is less than or equal to $k$ and the sign of the last element matches the target value, return $\textit{true}$; otherwise, return $\textit{false}$. + +The final answer is the result of $\textit{check}(\textit{nums}[0], k)$ or $\textit{check}(-\textit{nums}[0], k)$. + +The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$. #### Python3 ```python - +class Solution: + def canMakeEqual(self, nums: List[int], k: int) -> bool: + def check(target: int, k: int) -> bool: + cnt, sign = 0, 1 + for i in range(len(nums) - 1): + x = nums[i] * sign + if x == target: + sign = 1 + else: + sign = -1 + cnt += 1 + return cnt <= k and nums[-1] * sign == target + + return check(nums[0], k) or check(-nums[0], k) ``` #### Java ```java - +class Solution { + public boolean canMakeEqual(int[] nums, int k) { + return check(nums, nums[0], k) || check(nums, -nums[0], k); + } + + private boolean check(int[] nums, int target, int k) { + int cnt = 0, sign = 1; + for (int i = 0; i < nums.length - 1; ++i) { + int x = nums[i] * sign; + if (x == target) { + sign = 1; + } else { + sign = -1; + ++cnt; + } + } + return cnt <= k && nums[nums.length - 1] * sign == target; + } +} ``` #### C++ ```cpp - +class Solution { +public: + bool canMakeEqual(vector& nums, int k) { + auto check = [&](int target, int k) -> bool { + int n = nums.size(); + int cnt = 0, sign = 1; + for (int i = 0; i < n - 1; ++i) { + int x = nums[i] * sign; + if (x == target) { + sign = 1; + } else { + sign = -1; + ++cnt; + } + } + return cnt <= k && nums[n - 1] * sign == target; + }; + return check(nums[0], k) || check(-nums[0], k); + } +}; ``` #### Go ```go +func canMakeEqual(nums []int, k int) bool { + check := func(target, k int) bool { + cnt, sign := 0, 1 + for i := 0; i < len(nums)-1; i++ { + x := nums[i] * sign + if x == target { + sign = 1 + } else { + sign = -1 + cnt++ + } + } + return cnt <= k && nums[len(nums)-1]*sign == target + } + return check(nums[0], k) || check(-nums[0], k) +} +``` +#### TypeScript + +```ts +function canMakeEqual(nums: number[], k: number): boolean { + function check(target: number, k: number): boolean { + let [cnt, sign] = [0, 1]; + for (let i = 0; i < nums.length - 1; i++) { + const x = nums[i] * sign; + if (x === target) { + sign = 1; + } else { + sign = -1; + cnt++; + } + } + return cnt <= k && nums[nums.length - 1] * sign === target; + } + + return check(nums[0], k) || check(-nums[0], k); +} ``` diff --git a/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.cpp b/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.cpp new file mode 100644 index 0000000000000..9ee7c6f02e7c2 --- /dev/null +++ b/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.cpp @@ -0,0 +1,20 @@ +class Solution { +public: + bool canMakeEqual(vector& nums, int k) { + auto check = [&](int target, int k) -> bool { + int n = nums.size(); + int cnt = 0, sign = 1; + for (int i = 0; i < n - 1; ++i) { + int x = nums[i] * sign; + if (x == target) { + sign = 1; + } else { + sign = -1; + ++cnt; + } + } + return cnt <= k && nums[n - 1] * sign == target; + }; + return check(nums[0], k) || check(-nums[0], k); + } +}; \ No newline at end of file diff --git a/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.go b/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.go new file mode 100644 index 0000000000000..5994537249c21 --- /dev/null +++ b/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.go @@ -0,0 +1,16 @@ +func canMakeEqual(nums []int, k int) bool { + check := func(target, k int) bool { + cnt, sign := 0, 1 + for i := 0; i < len(nums)-1; i++ { + x := nums[i] * sign + if x == target { + sign = 1 + } else { + sign = -1 + cnt++ + } + } + return cnt <= k && nums[len(nums)-1]*sign == target + } + return check(nums[0], k) || check(-nums[0], k) +} \ No newline at end of file diff --git a/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.java b/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.java new file mode 100644 index 0000000000000..578fe268664af --- /dev/null +++ b/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.java @@ -0,0 +1,19 @@ +class Solution { + public boolean canMakeEqual(int[] nums, int k) { + return check(nums, nums[0], k) || check(nums, -nums[0], k); + } + + private boolean check(int[] nums, int target, int k) { + int cnt = 0, sign = 1; + for (int i = 0; i < nums.length - 1; ++i) { + int x = nums[i] * sign; + if (x == target) { + sign = 1; + } else { + sign = -1; + ++cnt; + } + } + return cnt <= k && nums[nums.length - 1] * sign == target; + } +} \ No newline at end of file diff --git a/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.py b/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.py new file mode 100644 index 0000000000000..b8dc325406ed6 --- /dev/null +++ b/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.py @@ -0,0 +1,14 @@ +class Solution: + def canMakeEqual(self, nums: List[int], k: int) -> bool: + def check(target: int, k: int) -> bool: + cnt, sign = 0, 1 + for i in range(len(nums) - 1): + x = nums[i] * sign + if x == target: + sign = 1 + else: + sign = -1 + cnt += 1 + return cnt <= k and nums[-1] * sign == target + + return check(nums[0], k) or check(-nums[0], k) diff --git a/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.ts b/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.ts new file mode 100644 index 0000000000000..31ca52aba0e12 --- /dev/null +++ b/solution/3500-3599/3576.Transform Array to All Equal Elements/Solution.ts @@ -0,0 +1,17 @@ +function canMakeEqual(nums: number[], k: number): boolean { + function check(target: number, k: number): boolean { + let [cnt, sign] = [0, 1]; + for (let i = 0; i < nums.length - 1; i++) { + const x = nums[i] * sign; + if (x === target) { + sign = 1; + } else { + sign = -1; + cnt++; + } + } + return cnt <= k && nums[nums.length - 1] * sign === target; + } + + return check(nums[0], k) || check(-nums[0], k); +}