LeetCode 2178. Maximum Split of Positive Even Integers Solution in Java, C++, Python & More | Explanation + Code

Description

You are given an integer finalSum. Split it into a sum of a maximum number of unique positive even integers.

• For example, given finalSum = 12, the following splits are valid (unique positive even integers summing up to finalSum): (12), (2 + 10), (2 + 4 + 6), and (4 + 8). Among them, (2 + 4 + 6) contains the maximum number of integers. Note that finalSum cannot be split into (2 + 2 + 4 + 4) as all the numbers should be unique.

Return a list of integers that represent a valid split containing a maximum number of integers. If no valid split exists for finalSum, return an empty list. You may return the integers in any order.

 

Example 1:

Input: finalSum = 12
Output: [2,4,6]
Explanation: The following are valid splits: (12), (2 + 10), (2 + 4 + 6), and (4 + 8).
(2 + 4 + 6) has the maximum number of integers, which is 3. Thus, we return [2,4,6].
Note that [2,6,4], [6,2,4], etc. are also accepted.

Example 2:

Input: finalSum = 7
Output: []
Explanation: There are no valid splits for the given finalSum.
Thus, we return an empty array.

Example 3:

Input: finalSum = 28
Output: [6,8,2,12]
Explanation: The following are valid splits: (2 + 26), (6 + 8 + 2 + 12), and (4 + 24). 
(6 + 8 + 2 + 12) has the maximum number of integers, which is 4. Thus, we return [6,8,2,12].
Note that [10,2,4,12], [6,2,4,16], etc. are also accepted.

 

Constraints:

• 1 <= finalSum <= 1010

Solutions

Solution 1: Greedy

If finalSum is odd, it cannot be split into the sum of several distinct positive even integers, so we directly return an empty array.

Otherwise, we can greedily split finalSum in the order of 2, 4, 6, …, until finalSum can no longer be split into a different positive even integer. At this point, we add the remaining finalSum to the last positive even integer.

The time complexity is O(√finalSum), and ignoring the space consumption of the answer array, the space complexity is O(1).

PythonJavaC++GoTypeScriptRustC#

class Solution: def maximumEvenSplit(self, finalSum: int) -> List[int]: if finalSum & 1: return [] ans = [] i = 2 while i <= finalSum: finalSum -= i ans.append(i) i += 2 ans[-1] += finalSum return ans(code-box)

class Solution { public List<Long> maximumEvenSplit(long finalSum) { List<Long> ans = new ArrayList<>(); if (finalSum % 2 == 1) { return ans; } for (long i = 2; i <= finalSum; i += 2) { ans.add(i); finalSum -= i; } ans.add(ans.remove(ans.size() - 1) + finalSum); return ans; } }(code-box)

class Solution { public: vector<long long> maximumEvenSplit(long long finalSum) { vector<long long> ans; if (finalSum % 2) { return ans; } for (long long i = 2; i <= finalSum; i += 2) { ans.push_back(i); finalSum -= i; } ans.back() += finalSum; return ans; } };(code-box)

func maximumEvenSplit(finalSum int64) (ans []int64) { if finalSum%2 == 1 { return } for i := int64(2); i <= finalSum; i += 2 { ans = append(ans, i) finalSum -= i } ans[len(ans)-1] += finalSum return }(code-box)

function maximumEvenSplit(finalSum: number): number[] { const ans: number[] = []; if (finalSum % 2 === 1) { return ans; } for (let i = 2; i <= finalSum; i += 2) { ans.push(i); finalSum -= i; } ans[ans.length - 1] += finalSum; return ans; }(code-box)

impl Solution { pub fn maximum_even_split(mut final_sum: i64) -> Vec<i64> { let mut ans = Vec::new(); if final_sum % 2 != 0 { return ans; } let mut i = 2; while i <= final_sum { ans.push(i); final_sum -= i; i += 2; } if let Some(last) = ans.last_mut() { *last += final_sum; } ans } }(code-box)

public class Solution { public IList<long> MaximumEvenSplit(long finalSum) { IList<long> ans = new List<long>(); if (finalSum % 2 == 1) { return ans; } for (long i = 2; i <= finalSum; i += 2) { ans.Add(i); finalSum -= i; } ans[ans.Count - 1] += finalSum; return ans; } }(code-box)