Welcome to Subscribe On Youtube
2708. Maximum Strength of a Group
Description
You are given a 0-indexed integer array nums representing the score of students in an exam. The teacher would like to form one non-empty group of students with maximal strength, where the strength of a group of students of indices i0, i1, i2, ... , ik is defined as nums[i0] * nums[i1] * nums[i2] * ... * nums[ik].
Return the maximum strength of a group the teacher can create.
Example 1:
Input: nums = [3,-1,-5,2,5,-9] Output: 1350 Explanation: One way to form a group of maximal strength is to group the students at indices [0,2,3,4,5]. Their strength is 3 * (-5) * 2 * 5 * (-9) = 1350, which we can show is optimal.
Example 2:
Input: nums = [-4,-5,-4] Output: 20 Explanation: Group the students at indices [0, 1] . Then, we’ll have a resulting strength of 20. We cannot achieve greater strength.
Constraints:
1 <= nums.length <= 13-9 <= nums[i] <= 9
Solutions
Solution 1: Binary Enumeration
The problem is actually to find the maximum product of all subsets. Since the length of the array does not exceed $13$, we can consider using the method of binary enumeration.
We enumerate all subsets in the range of $[1, 2^n)$, and for each subset, we calculate its product, and finally return the maximum value.
The time complexity is $O(2^n \times n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
Solution 2: Sorting + Greedy
First, we can sort the array. Based on the characteristics of the array, we can draw the following conclusions:
- If there is only one element in the array, then the maximum strength value is this element.
- If there are two or more elements in the array, and $nums[1] = nums[n - 1] = 0$, then the maximum strength value is $0$.
- Otherwise, we traverse the array from small to large. If the current element is less than $0$ and the next element is also less than $0$, then we multiply these two elements and accumulate the product into the answer. Otherwise, if the current element is less than or equal to $0$, we skip it directly. If the current element is greater than $0$, we multiply this element into the answer. Finally, we return the answer.
The time complexity is $O(n \times \log n)$, and the space complexity is $O(\log n)$. Where $n$ is the length of the array.
-
class Solution { public long maxStrength(int[] nums) { Arrays.sort(nums); int n = nums.length; if (n == 1) { return nums[0]; } if (nums[1] == 0 && nums[n - 1] == 0) { return 0; } long ans = 1; int i = 0; while (i < n) { if (nums[i] < 0 && i + 1 < n && nums[i + 1] < 0) { ans *= nums[i] * nums[i + 1]; i += 2; } else if (nums[i] <= 0) { i += 1; } else { ans *= nums[i]; i += 1; } } return ans; } } // Solution 2 class Solution { public long maxStrength(int[] nums) { Arrays.sort(nums); int n = nums.length; if (n == 1) { return nums[0]; } if (nums[1] == 0 && nums[n - 1] == 0) { return 0; } long ans = 1; int i = 0; while (i < n) { if (nums[i] < 0 && i + 1 < n && nums[i + 1] < 0) { ans *= nums[i] * nums[i + 1]; i += 2; } else if (nums[i] <= 0) { i += 1; } else { ans *= nums[i]; i += 1; } } return ans; } } -
class Solution { public: long long maxStrength(vector<int>& nums) { sort(nums.begin(), nums.end()); int n = nums.size(); if (n == 1) { return nums[0]; } if (nums[1] == 0 && nums[n - 1] == 0) { return 0; } long long ans = 1; int i = 0; while (i < n) { if (nums[i] < 0 && i + 1 < n && nums[i + 1] < 0) { ans *= nums[i] * nums[i + 1]; i += 2; } else if (nums[i] <= 0) { i += 1; } else { ans *= nums[i]; i += 1; } } return ans; } }; // Solution 2 class Solution { public: long long maxStrength(vector<int>& nums) { sort(nums.begin(), nums.end()); int n = nums.size(); if (n == 1) { return nums[0]; } if (nums[1] == 0 && nums[n - 1] == 0) { return 0; } long long ans = 1; int i = 0; while (i < n) { if (nums[i] < 0 && i + 1 < n && nums[i + 1] < 0) { ans *= nums[i] * nums[i + 1]; i += 2; } else if (nums[i] <= 0) { i += 1; } else { ans *= nums[i]; i += 1; } } return ans; } }; -
class Solution: def maxStrength(self, nums: List[int]) -> int: nums.sort() n = len(nums) if n == 1: return nums[0] if nums[1] == nums[-1] == 0: return 0 ans, i = 1, 0 while i < n: if nums[i] < 0 and i + 1 < n and nums[i + 1] < 0: ans *= nums[i] * nums[i + 1] i += 2 elif nums[i] <= 0: i += 1 else: ans *= nums[i] i += 1 return ans # Solution 2 class Solution: def maxStrength(self, nums: List[int]) -> int: n = len(nums) ans = -inf for i in range(1, 1 << n): t = 1 for j in range(n): if i & (1 << j): t *= nums[j] ans = max(ans, t) return ans -
func maxStrength(nums []int) int64 { sort.Ints(nums) n := len(nums) if n == 1 { return int64(nums[0]) } if nums[1] == 0 && nums[n-1] == 0 { return 0 } ans := int64(1) for i := 0; i < n; i++ { if nums[i] < 0 && i+1 < n && nums[i+1] < 0 { ans *= int64(nums[i] * nums[i+1]) i++ } else if nums[i] > 0 { ans *= int64(nums[i]) } } return ans } // Solution 2 func maxStrength(nums []int) int64 { sort.Ints(nums) n := len(nums) if n == 1 { return int64(nums[0]) } if nums[1] == 0 && nums[n-1] == 0 { return 0 } ans := int64(1) for i := 0; i < n; i++ { if nums[i] < 0 && i+1 < n && nums[i+1] < 0 { ans *= int64(nums[i] * nums[i+1]) i++ } else if nums[i] > 0 { ans *= int64(nums[i]) } } return ans } -
function maxStrength(nums: number[]): number { nums.sort((a, b) => a - b); const n = nums.length; if (n === 1) { return nums[0]; } if (nums[1] === 0 && nums[n - 1] === 0) { return 0; } let ans = 1; for (let i = 0; i < n; ++i) { if (nums[i] < 0 && i + 1 < n && nums[i + 1] < 0) { ans *= nums[i] * nums[i + 1]; ++i; } else if (nums[i] > 0) { ans *= nums[i]; } } return ans; } // Solution 2 function maxStrength(nums: number[]): number { nums.sort((a, b) => a - b); const n = nums.length; if (n === 1) { return nums[0]; } if (nums[1] === 0 && nums[n - 1] === 0) { return 0; } let ans = 1; for (let i = 0; i < n; ++i) { if (nums[i] < 0 && i + 1 < n && nums[i + 1] < 0) { ans *= nums[i] * nums[i + 1]; ++i; } else if (nums[i] > 0) { ans *= nums[i]; } } return ans; }