Huahua’s Tech Road

花花酱 LeetCode 2155. All Divisions With the Highest Score of a Binary Array

By zxi on February 4, 2022

You are given a 0-indexed binary array nums of length n. nums can be divided at index i (where 0 <= i <= n) into two arrays (possibly empty) nums_left and nums_right:

nums_left has all the elements of nums between index 0 and i - 1 (inclusive), while nums_right has all the elements of nums between index i and n - 1 (inclusive).
If i == 0, nums_left is empty, while nums_right has all the elements of nums.
If i == n, nums_left has all the elements of nums, while nums_right is empty.

The division score of an index i is the sum of the number of 0‘s in nums_left and the number of 1‘s in nums_right.

Return all distinct indices that have the highest possible division score. You may return the answer in any order.

Example 1:

Input: nums = [0,0,1,0]
Output: [2,4]
Explanation: Division at index
- 0: nums_left is []. nums_right is [0,0,1,0]. The score is 0 + 1 = 1.
- 1: nums_left is [0]. nums_right is [0,1,0]. The score is 1 + 1 = 2.
- 2: nums_left is [0,0]. nums_right is [1,0]. The score is 2 + 1 = 3.
- 3: nums_left is [0,0,1]. nums_right is [0]. The score is 2 + 0 = 2.
- 4: nums_left is [0,0,1,0]. nums_right is []. The score is 3 + 0 = 3.
Indices 2 and 4 both have the highest possible division score 3.
Note the answer [4,2] would also be accepted.

Example 2:

Input: nums = [0,0,0]
Output: [3]
Explanation: Division at index
- 0: nums_left is []. nums_right is [0,0,0]. The score is 0 + 0 = 0.
- 1: nums_left is [0]. nums_right is [0,0]. The score is 1 + 0 = 1.
- 2: nums_left is [0,0]. nums_right is [0]. The score is 2 + 0 = 2.
- 3: nums_left is [0,0,0]. nums_right is []. The score is 3 + 0 = 3.
Only index 3 has the highest possible division score 3.

Example 3:

Input: nums = [1,1]
Output: [0]
Explanation: Division at index
- 0: nums_left is []. nums_right is [1,1]. The score is 0 + 2 = 2.
- 1: nums_left is [1]. nums_right is [1]. The score is 0 + 1 = 1.
- 2: nums_left is [1,1]. nums_right is []. The score is 0 + 0 = 0.
Only index 0 has the highest possible division score 2.

Constraints:

n == nums.length
1 <= n <= 10⁵
nums[i] is either 0 or 1.

Solution: Precompute + Prefix Sum

Count how many ones in the array, track the prefix sum to compute score for each index in O(1).

Time complexity: O(n)
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

vector<int> maxScoreIndices(vector<int>& nums) {

const int n = nums.size();

const int t = accumulate(begin(nums), end(nums), 0);

vector<int> ans;

for (int i = 0, p = 0, b = 0; i <= n; ++i) {

const int s = (i - p) + (t - p);

if (s > b) {

b = s; ans.clear();

}

if (s == b) ans.push_back(i);

if (i != n) p += nums[i];

}

return ans;

}

};

花花酱 LeetCode 2154. Keep Multiplying Found Values by Two

By zxi on February 4, 2022

You are given an array of integers nums. You are also given an integer original which is the first number that needs to be searched for in nums.

You then do the following steps:

If original is found in nums, multiply it by two (i.e., set original = 2 * original).
Otherwise, stop the process.
Repeat this process with the new number as long as you keep finding the number.

Return the final value of original.

Example 1:

Input: nums = [5,3,6,1,12], original = 3
Output: 24
Explanation: 
- 3 is found in nums. 3 is multiplied by 2 to obtain 6.
- 6 is found in nums. 6 is multiplied by 2 to obtain 12.
- 12 is found in nums. 12 is multiplied by 2 to obtain 24.
- 24 is not found in nums. Thus, 24 is returned.

Example 2:

Input: nums = [2,7,9], original = 4
Output: 4
Explanation:
- 4 is not found in nums. Thus, 4 is returned.

Constraints:

1 <= nums.length <= 1000
1 <= nums[i], original <= 1000

Solution: Hashset

Time complexity: O(n)
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

int findFinalValue(vector<int>& nums, int original) {

unordered_set<int> s(begin(nums), end(nums));

while (true) {

if (!s.count(original)) break;

original *= 2;

}

return original;

}

};

花花酱 LeetCode 2151. Maximum Good People Based on Statements

By zxi on February 4, 2022

There are two types of persons:

The good person: The person who always tells the truth.
The bad person: The person who might tell the truth and might lie.

You are given a 0-indexed 2D integer array statements of size n x n that represents the statements made by n people about each other. More specifically, statements[i][j] could be one of the following:

0 which represents a statement made by person i that person j is a bad person.
1 which represents a statement made by person i that person j is a good person.
2 represents that no statement is made by person i about person j.

Additionally, no person ever makes a statement about themselves. Formally, we have that statements[i][i] = 2 for all 0 <= i < n.

Return the maximum number of people who can be good based on the statements made by the n people.

Example 1:

Input: statements = [[2,1,2],[1,2,2],[2,0,2]]
Output: 2
Explanation: Each person makes a single statement.
- Person 0 states that person 1 is good.
- Person 1 states that person 0 is good.
- Person 2 states that person 1 is bad.
Let's take person 2 as the key.
- Assuming that person 2 is a good person:
- Based on the statement made by person 2, person 1 is a bad person.
- Now we know for sure that person 1 is bad and person 2 is good.
- Based on the statement made by person 1, and since person 1 is bad, they could be:
- telling the truth. There will be a contradiction in this case and this assumption is invalid.
- lying. In this case, person 0 is also a bad person and lied in their statement.
- Following that person 2 is a good person, there will be only one good person in the group.
- Assuming that person 2 is a bad person:
- Based on the statement made by person 2, and since person 2 is bad, they could be:
- telling the truth. Following this scenario, person 0 and 1 are both bad as explained before.
- Following that person 2 is bad but told the truth, there will be no good persons in the group.
- lying. In this case person 1 is a good person.
- Since person 1 is a good person, person 0 is also a good person.
- Following that person 2 is bad and lied, there will be two good persons in the group.
We can see that at most 2 persons are good in the best case, so we return 2.
Note that there is more than one way to arrive at this conclusion.

Example 2:

Input: statements = [[2,0],[0,2]]
Output: 1
Explanation: Each person makes a single statement.
- Person 0 states that person 1 is bad.
- Person 1 states that person 0 is bad.
Let's take person 0 as the key.
- Assuming that person 0 is a good person:
    - Based on the statement made by person 0, person 1 is a bad person and was lying.
    - Following that person 0 is a good person, there will be only one good person in the group.
- Assuming that person 0 is a bad person:
    - Based on the statement made by person 0, and since person 0 is bad, they could be:
        - telling the truth. Following this scenario, person 0 and 1 are both bad.
            - Following that person 0 is bad but told the truth, there will be no good persons in the group.
        - lying. In this case person 1 is a good person.
            - Following that person 0 is bad and lied, there will be only one good person in the group.
We can see that at most, one person is good in the best case, so we return 1.
Note that there is more than one way to arrive at this conclusion.

Constraints:

n == statements.length == statements[i].length
2 <= n <= 15
statements[i][j] is either 0, 1, or 2.
statements[i][i] == 2

Solution: Combination / Bitmask

Enumerate all subsets of n people and assume they are good people. Check whether their statements have any conflicts. We can ignore the statements from bad people since those can be either true or false and does not affect our checks.

Time complexity: O(n²2ⁿ)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int maximumGood(vector<vector<int>>& statements) {

const int n = statements.size();

auto valid = [&](int s) {

for (int i = 0; i < n; ++i) {

if (!(s >> i & 1)) continue;

for (int j = 0; j < n; ++j) {

const bool good = s >> j & 1;

if ((good && statements[i][j] == 0) || (!good && statements[i][j] == 1))

return false;

}

return true;

};

int ans = 0;

for (int s = 1; s < 1 << n; ++s)

if (valid(s)) ans = max(ans, __builtin_popcount(s));

return ans;

}

};

花花酱 LeetCode 2150. Find All Lonely Numbers in the Array

By zxi on February 4, 2022

You are given an integer array nums. A number x is lonely when it appears only once, and no adjacent numbers (i.e. x + 1 and x - 1) appear in the array.

Return all lonely numbers in nums. You may return the answer in any order.

Example 1:

Input: nums = [10,6,5,8]
Output: [10,8]
Explanation: 
- 10 is a lonely number since it appears exactly once and 9 and 11 does not appear in nums.
- 8 is a lonely number since it appears exactly once and 7 and 9 does not appear in nums.
- 5 is not a lonely number since 6 appears in nums and vice versa.
Hence, the lonely numbers in nums are [10, 8].
Note that [8, 10] may also be returned.

Example 2:

Input: nums = [1,3,5,3]
Output: [1,5]
Explanation: 
- 1 is a lonely number since it appears exactly once and 0 and 2 does not appear in nums.
- 5 is a lonely number since it appears exactly once and 4 and 6 does not appear in nums.
- 3 is not a lonely number since it appears twice.
Hence, the lonely numbers in nums are [1, 5].
Note that [5, 1] may also be returned.

Constraints:

1 <= nums.length <= 10⁵
0 <= nums[i] <= 10⁶

Solution: Counter

Computer the frequency of each number in the array, for a given number x with freq = 1, check freq of (x – 1) and (x + 1), if both of them are zero then x is lonely.

Time complexity: O(n)
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

vector<int> findLonely(vector<int>& nums) {

unordered_map<int, int> m;

for (int x : nums)

++m[x];

vector<int> ans;

for (const auto [x, c] : m)

if (c == 1 && !m.count(x + 1) && !m.count(x - 1))

ans.push_back(x);

return ans;

}

};

花花酱 LeetCode 2149. Rearrange Array Elements by Sign

By zxi on February 4, 2022

You are given a 0-indexed integer array nums of even length consisting of an equal number of positive and negative integers.

You should rearrange the elements of nums such that the modified array follows the given conditions:

Every consecutive pair of integers have opposite signs.
For all integers with the same sign, the order in which they were present in nums is preserved.
The rearranged array begins with a positive integer.

Return the modified array after rearranging the elements to satisfy the aforementioned conditions.

Example 1:

Input: nums = [3,1,-2,-5,2,-4]
Output: [3,-2,1,-5,2,-4]
Explanation:
The positive integers in nums are [3,1,2]. The negative integers are [-2,-5,-4].
The only possible way to rearrange them such that they satisfy all conditions is [3,-2,1,-5,2,-4].
Other ways such as [1,-2,2,-5,3,-4], [3,1,2,-2,-5,-4], [-2,3,-5,1,-4,2] are incorrect because they do not satisfy one or more conditions.

Example 2:

Input: nums = [-1,1]
Output: [1,-1]
Explanation:
1 is the only positive integer and -1 the only negative integer in nums.
So nums is rearranged to [1,-1].

Constraints:

2 <= nums.length <= 2 * 10⁵
nums.length is even
1 <= |nums[i]| <= 10⁵
nums consists of equal number of positive and negative integers.

Solution 1: Split and merge

Create two arrays to store positive and negative numbers.

Time complexity: O(n)
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

vector<int> rearrangeArray(vector<int>& nums) {

vector<int> pos;

vector<int> neg;

for (int x : nums)

(x > 0 ? pos : neg).push_back(x);

vector<int> ans;

for (int i = 0; i < pos.size(); ++i) {

ans.push_back(pos[i]);

ans.push_back(neg[i]);

}

return ans;

}

};

Solution 2: Two Pointers

Use two pointers to store the next pos / neg.

Time complexity: O(n)
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

vector<int> rearrangeArray(vector<int>& nums) {

vector<int> ans(nums.size());

int pos = 0;

int neg = 1;

for (int x : nums) {

int& index = x > 0 ? pos : neg;

ans[index] = x;

index += 2;

}

return ans;

}

};

Huahua's Tech Road

花花酱 LeetCode 2155. All Divisions With the Highest Score of a Binary Array

Solution: Precompute + Prefix Sum

C++

花花酱 LeetCode 2154. Keep Multiplying Found Values by Two

Solution: Hashset

C++

花花酱 LeetCode 2151. Maximum Good People Based on Statements

Solution: Combination / Bitmask

C++

花花酱 LeetCode 2150. Find All Lonely Numbers in the Array

Solution: Counter

C++

花花酱 LeetCode 2149. Rearrange Array Elements by Sign

Solution 1: Split and merge

C++

Solution 2: Two Pointers

C++