feat: add solutions to lc problem: No.1150

yanglbme · yanglbme · commit 6afa9411c782 · 2023-04-12T09:31:54.000+08:00
No.1150.Check If a Number Is Majority Element in a Sorted Array
diff --git a/solution/1100-1199/1147.Longest Chunked Palindrome Decomposition/README.md b/solution/1100-1199/1147.Longest Chunked Palindrome Decomposition/README.md
@@ -55,12 +55,12 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：贪心 + 递归或双指针**
+**方法一：贪心 + 双指针**
 
 我们可以从字符串的两端开始，寻找长度最短的、相同且不重叠的前后缀：
 
 -   如果找不到这样的前后缀，那么整个字符串作为一个段式回文，答案加 $1$；
--   如果找到了这样的前后缀，那么这个前后缀作为一个段式回文，答案加 $2$，然后继续寻找剩下的字符串的前后缀。这里我们可以使用递归或双指针来实现。
+-   如果找到了这样的前后缀，那么这个前后缀作为一个段式回文，答案加 $2$，然后继续寻找剩下的字符串的前后缀。
 
 以上贪心策略的证明如下：
 
@@ -72,7 +72,9 @@
 
 **方法二：字符串哈希**
 
-在方法一的基础上，我们可以使用字符串哈希的方法，在 $O(1)$ 时间内比较两个字符串是否相等。
+**字符串哈希**是把一个任意长度的字符串映射成一个非负整数，并且其冲突的概率几乎为 $0$。字符串哈希用于计算字符串哈希值，快速判断两个字符串是否相等。
+
+因此，在方法一的基础上，我们可以使用字符串哈希的方法，在 $O(1)$ 时间内比较两个字符串是否相等。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为字符串的长度。
 
diff --git a/solution/1100-1199/1150.Check If a Number Is Majority Element in a Sorted Array/README.md b/solution/1100-1199/1150.Check If a Number Is Majority Element in a Sorted Array/README.md
@@ -48,9 +48,15 @@
 
 **方法一：二分查找**
 
-“二分查找”求 `target` 在数组 `nums` 中的左右边界。
+我们注意到，数组 $nums$ 中的元素是非递减的，也就是说，数组 $nums$ 中的元素单调递增。因此，我们可以使用二分查找的方法，找到数组 $nums$ 中第一个大于等于 $target$ 的元素的下标 $left$，以及第一个大于 $target$ 的元素的下标 $right$。如果 $right - left > \frac{n}{2}$，则说明数组 $nums$ 中的元素 $target$ 出现的次数超过了数组长度的一半，因此返回 $true$，否则返回 $false$。
 
-时间复杂度 $O(\log n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `nums` 的长度。
+时间复杂度 $O(\log n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 $nums$ 的长度。
+
+**方法二：二分查找（优化）**
+
+方法一中，我们使用了两次二分查找，分别找到数组 $nums$ 中第一个大于等于 $target$ 的元素的下标 $left$，以及第一个大于 $target$ 的元素的下标 $right$。但是，我们可以使用一次二分查找，找到数组 $nums$ 中第一个大于等于 $target$ 的元素的下标 $left$，然后判断 $nums[left + \frac{n}{2}]$ 是否等于 $target$，如果相等，说明数组 $nums$ 中的元素 $target$ 出现的次数超过了数组长度的一半，因此返回 $true$，否则返回 $false$。
+
+时间复杂度 $O(\log n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 $nums$ 的长度。
 
 <!-- tabs:start -->
 
@@ -66,6 +72,14 @@ class Solution:
         return right - left > len(nums) // 2
 ```
 
+```python
+class Solution:
+    def isMajorityElement(self, nums: List[int], target: int) -> bool:
+        left = bisect_left(nums, target)
+        right = left + len(nums) // 2
+        return right < len(nums) and nums[right] == target
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -93,6 +107,30 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public boolean isMajorityElement(int[] nums, int target) {
+        int n = nums.length;
+        int left = search(nums, target);
+        int right = left + n / 2;
+        return right < n && nums[right] == target;
+    }
+
+    private int search(int[] nums, int x) {
+        int left = 0, right = nums.length;
+        while (left < right) {
+            int mid = (left + right) >> 1;
+            if (nums[mid] >= x) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -106,6 +144,18 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    bool isMajorityElement(vector<int>& nums, int target) {
+        int n = nums.size();
+        int left = lower_bound(nums.begin(), nums.end(), target) - nums.begin();
+        int right = left + n / 2;
+        return right < n && nums[right] == target;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -117,6 +167,60 @@ func isMajorityElement(nums []int, target int) bool {
 }
 ```
 
+```go
+func isMajorityElement(nums []int, target int) bool {
+	n := len(nums)
+	left := sort.Search(n, func(i int) bool { return nums[i] >= target })
+	right := left + n/2
+	return right < n && nums[right] == target
+}
+```
+
+### **TypeScript**
+
+```ts
+function isMajorityElement(nums: number[], target: number): boolean {
+    const search = (x: number) => {
+        let left = 0;
+        let right = nums.length;
+        while (left < right) {
+            const mid = (left + right) >> 1;
+            if (nums[mid] >= x) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    };
+    const left = search(target);
+    const right = search(target + 1);
+    return right - left > nums.length >> 1;
+}
+```
+
+```ts
+function isMajorityElement(nums: number[], target: number): boolean {
+    const search = (x: number) => {
+        let left = 0;
+        let right = n;
+        while (left < right) {
+            const mid = (left + right) >> 1;
+            if (nums[mid] >= x) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    };
+    const n = nums.length;
+    const left = search(target);
+    const right = left + (n >> 1);
+    return right < n && nums[right] === target;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/1100-1199/1150.Check If a Number Is Majority Element in a Sorted Array/README_EN.md b/solution/1100-1199/1150.Check If a Number Is Majority Element in a Sorted Array/README_EN.md
@@ -50,6 +50,14 @@ class Solution:
         return right - left > len(nums) // 2
 ```
 
+```python
+class Solution:
+    def isMajorityElement(self, nums: List[int], target: int) -> bool:
+        left = bisect_left(nums, target)
+        right = left + len(nums) // 2
+        return right < len(nums) and nums[right] == target
+```
+
 ### **Java**
 
 ```java
@@ -75,6 +83,30 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public boolean isMajorityElement(int[] nums, int target) {
+        int n = nums.length;
+        int left = search(nums, target);
+        int right = left + n / 2;
+        return right < n && nums[right] == target;
+    }
+
+    private int search(int[] nums, int x) {
+        int left = 0, right = nums.length;
+        while (left < right) {
+            int mid = (left + right) >> 1;
+            if (nums[mid] >= x) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -88,6 +120,18 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    bool isMajorityElement(vector<int>& nums, int target) {
+        int n = nums.size();
+        int left = lower_bound(nums.begin(), nums.end(), target) - nums.begin();
+        int right = left + n / 2;
+        return right < n && nums[right] == target;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -99,6 +143,60 @@ func isMajorityElement(nums []int, target int) bool {
 }
 ```
 
+```go
+func isMajorityElement(nums []int, target int) bool {
+	n := len(nums)
+	left := sort.Search(n, func(i int) bool { return nums[i] >= target })
+	right := left + n/2
+	return right < n && nums[right] == target
+}
+```
+
+### **TypeScript**
+
+```ts
+function isMajorityElement(nums: number[], target: number): boolean {
+    const search = (x: number) => {
+        let left = 0;
+        let right = nums.length;
+        while (left < right) {
+            const mid = (left + right) >> 1;
+            if (nums[mid] >= x) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    };
+    const left = search(target);
+    const right = search(target + 1);
+    return right - left > nums.length >> 1;
+}
+```
+
+```ts
+function isMajorityElement(nums: number[], target: number): boolean {
+    const search = (x: number) => {
+        let left = 0;
+        let right = n;
+        while (left < right) {
+            const mid = (left + right) >> 1;
+            if (nums[mid] >= x) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    };
+    const n = nums.length;
+    const left = search(target);
+    const right = left + (n >> 1);
+    return right < n && nums[right] === target;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/1100-1199/1150.Check If a Number Is Majority Element in a Sorted Array/Solution.ts b/solution/1100-1199/1150.Check If a Number Is Majority Element in a Sorted Array/Solution.ts
@@ -0,0 +1,18 @@
+function isMajorityElement(nums: number[], target: number): boolean {
+    const search = (x: number) => {
+        let left = 0;
+        let right = nums.length;
+        while (left < right) {
+            const mid = (left + right) >> 1;
+            if (nums[mid] >= x) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    };
+    const left = search(target);
+    const right = search(target + 1);
+    return right - left > nums.length >> 1;
+}
