• 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)

// 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;
  }
};

The post 花花酱 LeetCode 2151. Maximum Good People Based on Statements appeared first on Huahua's Tech Road.

One room divider has already been installed to the left of index 0, and another to the right of index n - 1. Additional room dividers can be installed. For each position between indices i - 1 and i (1 <= i <= n - 1), at most one divider can be installed.

Divide the corridor into non-overlapping sections, where each section has exactly two seats with any number of plants. There may be multiple ways to perform the division. Two ways are different if there is a position with a room divider installed in the first way but not in the second way.

Return the number of ways to divide the corridor. Since the answer may be very large, return it modulo 109 + 7. If there is no way, return 0.

Example 1:

Input: corridor = "SSPPSPS"
Output: 3
Explanation: There are 3 different ways to divide the corridor.
The black bars in the above image indicate the two room dividers already installed.
Note that in each of the ways, each section has exactly two seats.

Example 2:

Input: corridor = "PPSPSP"
Output: 1
Explanation: There is only 1 way to divide the corridor, by not installing any additional dividers.
Installing any would create some section that does not have exactly two seats.

Example 3:

Input: corridor = "S"
Output: 0
Explanation: There is no way to divide the corridor because there will always be a section that does not have exactly two seats.

Constraints:

• n == corridor.length
• 1 <= n <= 105
• corridor[i] is either 'S' or 'P'.

Solution: Combination

If the 2k-th seat is positioned at j, and the 2k+1-th seat is at i. There are (i – j) ways to split between these two groups.

ans = prod{i_k – j_k}

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

// Author: Huahua
class Solution {
public:
  int numberOfWays(string corridor) {
    constexpr int kMod = 1e9 + 7;
    long ans = 1;
    long k = 0;
    for (long i = 0, j = 0; i < corridor.size(); ++i) {
      if (corridor[i] != 'S') continue;
      if (++k > 2 && k & 1)
        ans = ans * (i - j) % kMod;
      j = i;
    }
    return (k >= 2 && k % 2 == 0) ? ans : 0;
  }
};

The post 花花酱 LeetCode 2147. Number of Ways to Divide a Long Corridor appeared first on Huahua's Tech Road.

An array a is a subset of an array b if a can be obtained from b by deleting some (possibly zero) elements of b. Two subsets are considered different if the indices of the elements chosen are different.

The bitwise OR of an array a is equal to a[0] OR a[1] OR ... OR a[a.length - 1] (0-indexed).

Example 1:

Input: nums = [3,1]
Output: 2
Explanation: The maximum possible bitwise OR of a subset is 3. There are 2 subsets with a bitwise OR of 3:
- [3]
- [3,1]

Example 2:

Input: nums = [2,2,2]
Output: 7
Explanation: All non-empty subsets of [2,2,2] have a bitwise OR of 2. There are 23 - 1 = 7 total subsets.

Example 3:

Input: nums = [3,2,1,5]
Output: 6
Explanation: The maximum possible bitwise OR of a subset is 7. There are 6 subsets with a bitwise OR of 7:
- [3,5]
- [3,1,5]
- [3,2,5]
- [3,2,1,5]
- [2,5]
- [2,1,5]

Constraints:

• 1 <= nums.length <= 16
• 1 <= nums[i] <= 105

Solution: Brute Force

Try all possible subsets

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

// Author: Huahua
class Solution {
public:
  int countMaxOrSubsets(vector<int>& nums) {
    const int n = nums.size();
    int max_or = 0;
    int count = 0;
    for (int s = 0; s < 1 << n; ++s) {
      int cur_or = 0;
      for (int i = 0; i < n; ++i)
        if (s >> i & 1) cur_or |= nums[i];
      if (cur_or > max_or) {
        max_or = cur_or;
        count = 1;
      } else if (cur_or == max_or) {
        ++count;
      }
    }
    return count;
  }
};

The post 花花酱 LeetCode 2044. Count Number of Maximum Bitwise-OR Subsets appeared first on Huahua's Tech Road.

The XOR sum of the two integer arrays is (nums1[0] XOR nums2[0]) + (nums1[1] XOR nums2[1]) + ... + (nums1[n - 1] XOR nums2[n - 1]) (0-indexed).

• For example, the XOR sum of [1,2,3] and [3,2,1] is equal to (1 XOR 3) + (2 XOR 2) + (3 XOR 1) = 2 + 0 + 2 = 4.

Rearrange the elements of nums2 such that the resulting XOR sum is minimized.

Return the XOR sum after the rearrangement.

Example 1:

Input: nums1 = [1,2], nums2 = [2,3]
Output: 2
Explanation: Rearrange nums2 so that it becomes [3,2].
The XOR sum is (1 XOR 3) + (2 XOR 2) = 2 + 0 = 2.

Example 2:

Input: nums1 = [1,0,3], nums2 = [5,3,4]
Output: 8
Explanation: Rearrange nums2 so that it becomes [5,4,3]. 
The XOR sum is (1 XOR 5) + (0 XOR 4) + (3 XOR 3) = 4 + 4 + 0 = 8.

Constraints:

• n == nums1.length
• n == nums2.length
• 1 <= n <= 14
• 0 <= nums1[i], nums2[i] <= 107

Solution: DP / Permutation to combination

dp[s] := min xor sum by using a subset of nums2 (presented by a binary string s) xor with nums1[0:|s|].

Time complexity: O(n*2ⁿ)
Space complexity: O(2ⁿ)

// Author: Huahua
class Solution {
public:
  int minimumXORSum(vector<int>& nums1, vector<int>& nums2) {
    const int n = nums1.size();
    vector<int> dp(1 << n, INT_MAX);
    dp[0] = 0;
    for (int s = 0; s < 1 << n; ++s) {
      int index = __builtin_popcount(s);
      for (int i = 0; i < n; ++i) {
        if (s & (1 << i)) continue;
        dp[s | (1 << i)] = min(dp[s | (1 << i)],
                               dp[s] + (nums1[index] ^ nums2[i]));
      }
    }    
    return dp.back();
  }
};

The post 花花酱 LeetCode 1879. Minimum XOR Sum of Two Arrays appeared first on Huahua's Tech Road.

• For example, if the sticks are arranged [1,3,2,5,4], then the sticks with lengths 1, 3, and 5 are visible from the left.

Given n and k, return the number of such arrangements. Since the answer may be large, return it modulo 109 + 7.

Example 1:

Input: n = 3, k = 2
Output: 3
Explanation: [1,3,2], [2,3,1], and [2,1,3] are the only arrangements such that exactly 2 sticks are visible.
The visible sticks are underlined.

Example 2:

Input: n = 5, k = 5
Output: 1
Explanation: [1,2,3,4,5] is the only arrangement such that all 5 sticks are visible.
The visible sticks are underlined.

Example 3:

Input: n = 20, k = 11
Output: 647427950
Explanation: There are 647427950 (mod 109 + 7) ways to rearrange the sticks such that exactly 11 sticks are visible.

Constraints:

• 1 <= n <= 1000
• 1 <= k <= n

Solution: DP

dp(n, k) = dp(n – 1, k – 1) + (n-1) * dp(n-1, k)

Time complexity: O(n*k)
Space complexity: O(n*k) -> O(k)

// Author: Huahua
class Solution {
public:
  int rearrangeSticks(int n, int k) {
    constexpr int kMod = 1e9 + 7;
    vector<vector<long>> dp(n + 1, vector<long>(k + 1));        
    for (int j = 1; j <= k; ++j) {
      dp[j][j] = 1;
      for (int i = j + 1; i <= n; ++i)
        dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j] * (i - 1)) % kMod;
    }
    return dp[n][k];
  }
};

# Author: Huahua
class Solution:
  @lru_cache(maxsize=None)
  def rearrangeSticks(self, n: int, k: int) -> int:
    if k == 0: return 0
    if k == n or n <= 2: return 1
    return (self.rearrangeSticks(n - 1, k - 1) + 
            (n - 1) * self.rearrangeSticks(n - 1, k)) % (10**9 + 7)

The post 花花酱 LeetCode 1866. Number of Ways to Rearrange Sticks With K Sticks Visible appeared first on Huahua's Tech Road.

There is a donuts shop that bakes donuts in batches of batchSize. They have a rule where they must serve all of the donuts of a batch before serving any donuts of the next batch. You are given an integer batchSize and an integer array groups, where groups[i] denotes that there is a group of groups[i] customers that will visit the shop. Each customer will get exactly one donut.

When a group visits the shop, all customers of the group must be served before serving any of the following groups. A group will be happy if they all get fresh donuts. That is, the first customer of the group does not receive a donut that was left over from the previous group.

You can freely rearrange the ordering of the groups. Return the maximum possible number of happy groups after rearranging the groups.

Example 1:

Input: batchSize = 3, groups = [1,2,3,4,5,6]
Output: 4
Explanation: You can arrange the groups as [6,2,4,5,1,3]. Then the 1st, 2nd, 4th, and 6th groups will be happy.

Example 2:

Input: batchSize = 4, groups = [1,3,2,5,2,2,1,6]
Output: 4

Constraints:

• 1 <= batchSize <= 9
• 1 <= groups.length <= 30
• 1 <= groups[i] <= 109

Solution 0: Binary Mask DP

Time complexity: O(n*2ⁿ) TLE
Space complexity: O(2ⁿ)

// Author: Huahua, TLE, 42/67 Passed
class Solution {
public:
  int maxHappyGroups(int b, vector<int>& groups) {
    const int n = groups.size();
    vector<int> dp(1 << n);
    for (int mask = 0; mask < 1 << n; ++mask) {
      int s = 0;
      for (int i = 0; i < n; ++i)
        if (mask & (1 << i)) s = (s + groups[i]) % b;
      for (int i = 0; i < n; ++i)
        if (!(mask & (1 << i)))
          dp[mask | (1 << i)] = max(dp[mask | (1 << i)],
                                    dp[mask] + (s == 0));
    }
    return dp[(1 << n) - 1];
  }
};

Solution 1: Recursion w/ Memoization

State: count of group size % batchSize

// Author: Huahua, 888 ms, 61.9 MB
class Solution {
public:
  int maxHappyGroups(int b, vector<int>& groups) {
    int ans = 0;
    vector<int> count(b);
    for (int g : groups) ++count[g % b];      
    map<vector<int>, int> cache;
    function<int(int)> dp = [&](int s) {
      auto it = cache.find(count);
      if (it != cache.end()) return it->second;
      int ans = 0;
      for (int i = 1; i < b; ++i) {
        if (!count[i]) continue;
        --count[i];
        ans = max(ans, (s == 0) + dp((s + i) % b));
        ++count[i];
      }
      return cache[count] = ans;
    };    
    return count[0] + dp(0);
  }
};

// Author: Huahua 380 ms, 59.2 MB
struct VectorHasher {
  size_t operator()(const vector<int>& V) const {
    size_t hash = V.size();
    for (auto i : V)
      hash ^= i + 0x9e3779b9 + (hash << 6) + (hash >> 2);
    return hash;
  }
};
class Solution {
public:
  int maxHappyGroups(int b, vector<int>& groups) {
    int ans = 0;
    vector<int> count(b);
    for (int g : groups) ++count[g % b];      
    unordered_map<vector<int>, int, VectorHasher> cache;
    function<int(int)> dp = [&](int s) {
      auto it = cache.find(count);
      if (it != cache.end()) return it->second;
      int ans = 0;
      for (int i = 1; i < b; ++i) {
        if (!count[i]) continue;
        --count[i];
        ans = max(ans, (s == 0) + dp((s + b - i) % b));
        ++count[i];
      }
      return cache[count] = ans;
    };    
    return count[0] + dp(0);
  }
};

// Author: Huahua, 0 ms, 8.1 MB
class Solution {
public:
  int maxHappyGroups(int b, vector<int>& groups) {
    int ans = 0;
    vector<int> count(b);
    for (int g : groups) {
      const int r = g % b;
      if (r == 0) { ++ans; continue; }      
      if (count[b - r]) {
        --count[b - r];
        ++ans;
      } else {
        ++count[r];
      }
    }    
    map<vector<int>, int> cache;
    function<int(int, int)> dp = [&](int r, int n) {
      if (n == 0) return 0;
      auto it = cache.find(count);
      if (it != cache.end()) return it->second;
      int ans = 0;
      for (int i = 1; i < b; ++i) {
        if (!count[i]) continue;
        --count[i];
        ans = max(ans, (r == 0) + dp((r + b - i) % b, n - 1));
        ++count[i];
      }
      return cache[count] = ans;
    };
    const int n = accumulate(begin(count), end(count), 0);
    return ans + (n ? dp(0, n) : 0);
  }
};

The post 花花酱 LeetCode 1815. Maximum Number of Groups Getting Fresh Donuts appeared first on Huahua's Tech Road.

• A constructor that takes a string characters of sorted distinct lowercase English letters and a number combinationLength as arguments.
• A function next() that returns the next combination of length combinationLength in lexicographical order.
• A function hasNext() that returns True if and only if there exists a next combination.

Example:

CombinationIterator iterator = new CombinationIterator("abc", 2); // creates the iterator.

iterator.next(); // returns "ab"
iterator.hasNext(); // returns true
iterator.next(); // returns "ac"
iterator.hasNext(); // returns true
iterator.next(); // returns "bc"
iterator.hasNext(); // returns false

Constraints:

• 1 <= combinationLength <= characters.length <= 15
• There will be at most 10^4 function calls per test.
• It’s guaranteed that all calls of the function next are valid.

Solution: Bitmask

Use a bitmask to represent the chars selected.
start with (2^n – 1), decrease the mask until there are c bit set.
stop when mask reach to 0.

mask: 111 => abc
mask: 110 => ab
mask: 101 => ac
mask: 011 => bc
mask: 000 => “” Done

Time complexity: O(2^n)
Space complexity: O(1)

class CombinationIterator {
public:
  CombinationIterator(string characters, int combinationLength): 
    chars_(rbegin(characters), rend(characters)),
    length_(combinationLength),
    mask_((1 << characters.size()) - 1) {}

  string next() {
    hasNext();    
    string ans;
    for (int i = chars_.size() - 1; i >= 0 ; --i)
      if ((mask_ >> i) & 1)
        ans.push_back(chars_[i]);
    --mask_;
    return ans;
  }

  bool hasNext() {
    while (mask_ >= 0 && __builtin_popcount(mask_) != length_) --mask_;
    return mask_ > 0;
  }
private:
  int mask_ = 0;  
  const int length_;
  const string chars_;
};

The post 花花酱 LeetCode 1286. Iterator for Combination appeared first on Huahua's Tech Road.

Given n points on a 1-D plane, where the ith point (from 0 to n-1) is at x = i, find the number of ways we can draw exactly k non-overlapping line segments such that each segment covers two or more points. The endpoints of each segment must have integral coordinates. The k line segments do not have to cover all n points, and they are allowed to share endpoints.

Return the number of ways we can draw k non-overlapping line segments. Since this number can be huge, return it modulo 109 + 7.

Example 1:

Input: n = 4, k = 2
Output: 5
Explanation: 
The two line segments are shown in red and blue.
The image above shows the 5 different ways {(0,2),(2,3)}, {(0,1),(1,3)}, {(0,1),(2,3)}, {(1,2),(2,3)}, {(0,1),(1,2)}.

Example 2:

Input: n = 3, k = 1
Output: 3
Explanation: The 3 ways are {(0,1)}, {(0,2)}, {(1,2)}.

Example 3:

Input: n = 30, k = 7
Output: 796297179
Explanation: The total number of possible ways to draw 7 line segments is 3796297200. Taking this number modulo 109 + 7 gives us 796297179.

Example 4:

Input: n = 5, k = 3
Output: 7

Example 5:

Input: n = 3, k = 2
Output: 1

Constraints:

• 2 <= n <= 1000
• 1 <= k <= n-1

Solution 1: Naive DP (TLE)

dp[n][k] := ans of problem(n, k)
dp[n][1] = n * (n – 1) / 2 # C(n,2)
dp[n][k] = 1 if k == n – 1
dp[n][k] = 0 if k >= n
dp[n][k] = sum((i – 1) * dp(n – i + 1, k – 1) 2 <= i < n

Time complexity: O(n^2*k)
Space complexity: O(n*k)

class Solution {
public:
  int numberOfSets(int n, int k) {
    constexpr int kMod = 1e9 + 7;
    vector<vector<int>> cache(n + 1, vector<int>(k + 1));
    function<int(int, int)> dp = [&](int n, int k) {
      if (k >= n) return 0;
      if (k == 1) return n * (n - 1) / 2;
      if (k == n - 1) return 1;      
      int& ans = cache[n][k];
      if (ans) return ans;
      for (long i = 2; i < n; ++i) {
        const int t = ((i - 1) * dp(n - i + 1, k - 1)) % kMod;
        ans = (ans + t) % kMod;
      }     
      return ans;
    };
    return dp(n, k);
  }
};

Solution 2: DP w/ Prefix Sum

Time complexity: O(nk)
Space complexity: O(nk)

# Author: Huahua 940 ms
class Solution:
  def numberOfSets(self, n: int, k: int) -> int:
    kMod = 10**9 + 7
    dp = [[0] * (k + 1) for _ in range(n + 1)]
    
    for i in range(n + 1):
      dp[i][0] = 1
      
    for j in range(1, k + 1):
      s = 0
      for i in range(1, n + 1):        
        dp[i][j] = (s + dp[i - 1][j])
        s += dp[i][j - 1]
    return dp[n][k] % kMod

Solution 3: DP / 3D State

Time complexity: O(nk)
Space complexity: O(nk)

# Author: Huahua 940 ms
class Solution:
  def numberOfSets(self, n: int, k: int) -> int:    
    kMod = 10**9 + 7
    
    @lru_cache(None)
    def dp(n: int, k: int, e: int) -> int: 
      if k == 0: return 1
      if k > n: return 0
      return (dp(n - 1, k, e) + dp(n + e - 1, k - e, 1 - e)) % kMod
    return dp(n, k, 0)

Solution 4: DP / Mathematical induction

Time complexity: O(nk)
Space complexity: O(nk)

# Author: Huahua 648 ms
class Solution:
  def numberOfSets(self, n: int, k: int) -> int:        
    @lru_cache(None)
    def dp(n: int, k: int) -> int: 
      if k >= n: return 0
      if k == 1: return n * (n - 1) // 2
      if k == n - 1: return 1
      return 2 * dp(n - 1, k) - dp(n - 2, k) + dp(n - 1, k - 1)
    
    return dp(n, k) % (10**9 + 7)

Solution 5: DP / Reduction

This problem can be reduced to: given n + k – 1 points, pick k segments (2*k points).
if two consecutive points were selected by two segments e.g. i for A and i+1 for B, then they share a point in the original space.
Answer C(n + k – 1, 2*k)

Time complexity: O((n+k)*2) Pascal’s triangle
Space complexity: O((n+k)*2)

class Solution {
public:
  int numberOfSets(int n, int k) {
    constexpr int kMod = 1e9 + 7;
    vector<vector<int>> dp(n + k , vector<int>(n + k));
    for (int i = 0; i < n + k; ++i) {
      dp[i][0] = dp[i][i] = 1;
      for (int j = 1; j < i; ++j)
        dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % kMod;
    }
    return dp[n + k - 1][2 * k];
  }
};

The post 花花酱 LeetCode 1621. Number of Sets of K Non-Overlapping Line Segments appeared first on Huahua's Tech Road.

You are given an array requests where requests[i] = [fromi, toi] represents an employee’s request to transfer from building fromi to building toi.

All buildings are full, so a list of requests is achievable only if for each building, the net change in employee transfers is zero. This means the number of employees leaving is equal to the number of employees moving in. For example if n = 3 and two employees are leaving building 0, one is leaving building 1, and one is leaving building 2, there should be two employees moving to building 0, one employee moving to building 1, and one employee moving to building 2.

Return the maximum number of achievable requests.

Example 1:

Input: n = 5, requests = [[0,1],[1,0],[0,1],[1,2],[2,0],[3,4]]
Output: 5
Explantion: Let's see the requests:
From building 0 we have employees x and y and both want to move to building 1.
From building 1 we have employees a and b and they want to move to buildings 2 and 0 respectively.
From building 2 we have employee z and they want to move to building 0.
From building 3 we have employee c and they want to move to building 4.
From building 4 we don't have any requests.
We can achieve the requests of users x and b by swapping their places.
We can achieve the requests of users y, a and z by swapping the places in the 3 buildings.

Example 2:

Input: n = 3, requests = [[0,0],[1,2],[2,1]]
Output: 3
Explantion: Let's see the requests:
From building 0 we have employee x and they want to stay in the same building 0.
From building 1 we have employee y and they want to move to building 2.
From building 2 we have employee z and they want to move to building 1.
We can achieve all the requests. 

Example 3:

Input: n = 4, requests = [[0,3],[3,1],[1,2],[2,0]]
Output: 4

Constraints:

• 1 <= n <= 20
• 1 <= requests.length <= 16
• requests[i].length == 2
• 0 <= fromi, toi < n

Solution: Combination

Try all combinations: O(2^n * (r + n))
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int maximumRequests(int n, vector<vector<int>>& requests) {
    const int r = requests.size(); 
    int ans = 0;
    vector<int> nets(n);
    for (int s = 0; s < 1 << r; ++s) {
      fill(begin(nets), end(nets), 0);
      for (int j = 0; j < r; ++j)
        if (s & (1 << j)) {
          --nets[requests[j][0]];
          ++nets[requests[j][1]];
        }
      if (all_of(begin(nets), end(nets), [](const int x) { return x == 0; }))
        ans = max(ans, __builtin_popcount(s));
    }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def maximumRequests(self, n: int, requests: List[List[int]]) -> int:
    r = len(requests)
    ans = 0
    for s in range(1 << r):
      degrees = [0] * n
      for i in range(r):
        if s & (1 << i):
          degrees[requests[i][0]] -= 1
          degrees[requests[i][1]] += 1
      if not any(degrees):
        ans = max(ans, bin(s).count('1'))
    return ans

The post 花花酱 LeetCode 1601. Maximum Number of Achievable Transfer Requests appeared first on Huahua's Tech Road.

Given a string s, return the maximum number of unique substrings that the given string can be split into.

You can split string s into any list of non-empty substrings, where the concatenation of the substrings forms the original string. However, you must split the substrings such that all of them are unique.

A substring is a contiguous sequence of characters within a string.

Example 1:

Input: s = "ababccc"
Output: 5
Explanation: One way to split maximally is ['a', 'b', 'ab', 'c', 'cc']. Splitting like ['a', 'b', 'a', 'b', 'c', 'cc'] is not valid as you have 'a' and 'b' multiple times.

Example 2:

Input: s = "aba"
Output: 2
Explanation: One way to split maximally is ['a', 'ba'].

Example 3:

Input: s = "aa"
Output: 1
Explanation: It is impossible to split the string any further.

Constraints:

• 1 <= s.length <= 16
• s contains only lower case English letters.

Solution: Brute Force

Try all combinations.
Time complexity: O(2^n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int maxUniqueSplit(string_view s) {
    const int n = s.length();
    if (n == 1) return 1;
    size_t ans = 1;
    unordered_set<string_view> seen;
    for (int m = 1; m < 1 << (n - 1); ++m) {
      if (__builtin_popcount(m) < ans) continue; // 956 ms -> 52 ms
      bool valid = true;
      int p = 0;
      for (int i = 1; i <= n && valid; ++i) {
        if (m & (1 << (i - 1)) || i == n) {
          valid &= seen.insert(s.substr(p, i - p)).second;
          p = i;
        }
      }
      if (valid) ans = max(ans, seen.size());
      seen.clear();
    }
    return ans;
  }
};

// Author: Huahua
class Solution {
public:
  int maxUniqueSplit(string_view s) {
    size_t ans = 1;
    const int n = s.length();
    unordered_set<string_view> seen;
    function<void(int)> dfs = [&](int p) {
      if (p == n) {        
        ans = max(ans, seen.size());
        return;
      }
      for (int i = p; i < n; ++i) {
        string_view ss = s.substr(p, i - p + 1);
        if (!seen.insert(ss).second) continue;
        dfs(i + 1);
        seen.erase(ss);
      }
    };
    dfs(0);
    return ans;
  }
};

The post 花花酱 LeetCode 1593. Split a String Into the Max Number of Unique Substrings appeared first on Huahua's Tech Road.

• Type 1: Triplet (i, j, k) if nums1[i]2 == nums2[j] * nums2[k] where 0 <= i < nums1.length and 0 <= j < k < nums2.length.
• Type 2: Triplet (i, j, k) if nums2[i]2 == nums1[j] * nums1[k] where 0 <= i < nums2.length and 0 <= j < k < nums1.length.

Example 1:

Input: nums1 = [7,4], nums2 = [5,2,8,9]
Output: 1
Explanation: Type 1: (1,1,2), nums1[1]^2 = nums2[1] * nums2[2]. (4^2 = 2 * 8). 

Example 2:

Input: nums1 = [1,1], nums2 = [1,1,1]
Output: 9
Explanation: All Triplets are valid, because 1^2 = 1 * 1.
Type 1: (0,0,1), (0,0,2), (0,1,2), (1,0,1), (1,0,2), (1,1,2).  nums1[i]^2 = nums2[j] * nums2[k].
Type 2: (0,0,1), (1,0,1), (2,0,1). nums2[i]^2 = nums1[j] * nums1[k].

Example 3:

Input: nums1 = [7,7,8,3], nums2 = [1,2,9,7]
Output: 2
Explanation: There are 2 valid triplets.
Type 1: (3,0,2).  nums1[3]^2 = nums2[0] * nums2[2].
Type 2: (3,0,1).  nums2[3]^2 = nums1[0] * nums1[1].

Example 4:

Input: nums1 = [4,7,9,11,23], nums2 = [3,5,1024,12,18]
Output: 0
Explanation: There are no valid triplets.

Constraints:

• 1 <= nums1.length, nums2.length <= 1000
• 1 <= nums1[i], nums2[i] <= 10^5

Solution: Hashtable

For each number y in the second array, count its frequency.

For each number x in the first, if x * x % y == 0, let r = x * x / y
if r == y: ans += f[y] * f[y-1]
else ans += f[y] * f[r]

Final ans /= 2

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

// Author: Huahua
class Solution {
public:
  int numTriplets(vector<int>& nums1, vector<int>& nums2) {
    return solve(nums1, nums2) + solve(nums2, nums1);
  }
private:
  int solve(vector<int>& nums1, vector<int>& nums2) {
    int ans = 0;
    unordered_map<int, int> f;
    for (int y : nums2) ++f[y];
    for (long x : nums1)
      for (const auto& [y, c] : f) {                
        long r = x * x / y;
        if (x * x % y || !f.count(r)) continue;
        if (r == y) ans += c * (c - 1);
        else ans += c * f[r];
      }
    return ans / 2;
  }
};

The post 花花酱 LeetCode 1577. Number of Ways Where Square of Number Is Equal to Product of Two Numbers appeared first on Huahua's Tech Road.

Given a binary string s (a string consisting only of ‘0’s and ‘1’s), we can split s into 3 non-empty strings s1, s2, s3 (s1+ s2+ s3 = s).

Return the number of ways s can be split such that the number of characters ‘1’ is the same in s1, s2, and s3.

Since the answer may be too large, return it modulo 10^9 + 7.

Example 1:

Input: s = "10101"
Output: 4
Explanation: There are four ways to split s in 3 parts where each part contain the same number of letters '1'.
"1|010|1"
"1|01|01"
"10|10|1"
"10|1|01"

Example 2:

Input: s = "1001"
Output: 0

Example 3:

Input: s = "0000"
Output: 3
Explanation: There are three ways to split s in 3 parts.
"0|0|00"
"0|00|0"
"00|0|0"

Example 4:

Input: s = "100100010100110"
Output: 12

Constraints:

• s[i] == '0' or s[i] == '1'
• 3 <= s.length <= 10^5

Solution: Counting

Count how many ones in the binary string as T, if not a factor of 3, then there is no answer.

Count how many positions that have prefix sum of T/3 as l, and how many positions that have prefix sum of T/3*2 as r.

Ans = l * r

But we need to special handle the all zero cases, which equals to C(n-2, 2) = (n – 1) * (n – 2) / 2

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

class Solution {
public:
  int numWays(string s) {
    const int kMod = 1e9 + 7;
    const long n = s.length();
    int t = 0;
    for (char c : s) t += c == '1';
    if (t % 3) return 0;
    if (t == 0)
      return ((1 + (n - 2)) * (n - 2) / 2) % kMod;
    t /= 3;
    long l = 0;
    long r = 0;
    for (int i = 0, c = 0; i < n; ++i) {
      c += (s[i] == '1');
      if (c == t) ++l;
      else if (c == t * 2) ++r;
    }
    return (l * r) % kMod;
  }
};

class Solution:
  def numWays(self, s: str) -> int:
    n = len(s)
    t = s.count('1')
    if t % 3 != 0: return 0
    if t == 0: return ((n - 1) * (n - 2) // 2) % (10**9 + 7)
    t //= 3
    l, r, c = 0, 0, 0
    for i, ch in enumerate(s):
      if ch == '1': c += 1
      if c == t: l += 1
      elif c == t * 2: r += 1
    return (l * r) % (10**9 + 7)

One pass: Space complexity: O(n)

class Solution:
  def numWays(self, s: str) -> int:
    n = len(s)
    p = defaultdict(int)
    c = 0
    for ch in s:
      if ch == '1': c += 1
      p[c] += 1
    if c % 3 != 0: return 0
    if c == 0: return ((n - 1) * (n - 2) // 2) % (10**9 + 7)
    return (p[c // 3] * p[c // 3 * 2]) % (10**9 + 7)

The post 花花酱 LeetCode 1573. Number of Ways to Split a String appeared first on Huahua's Tech Road.

For example, given nums = [2,1,3], we will have 2 as the root, 1 as a left child, and 3 as a right child. The array [2,3,1] also yields the same BST but [3,2,1] yields a different BST.

Return the number of ways to reorder nums such that the BST formed is identical to the original BST formed from nums.

Since the answer may be very large, return it modulo 10^9 + 7.

Example 1:

Input: nums = [2,1,3]
Output: 1
Explanation: We can reorder nums to be [2,3,1] which will yield the same BST. There are no other ways to reorder nums which will yield the same BST.

Example 2:

Input: nums = [3,4,5,1,2]
Output: 5
Explanation: The following 5 arrays will yield the same BST: 
[3,1,2,4,5]
[3,1,4,2,5]
[3,1,4,5,2]
[3,4,1,2,5]
[3,4,1,5,2]

Example 3:

Input: nums = [1,2,3]
Output: 0
Explanation: There are no other orderings of nums that will yield the same BST.

Example 4:

Input: nums = [3,1,2,5,4,6]
Output: 19

Example 5:

Input: nums = [9,4,2,1,3,6,5,7,8,14,11,10,12,13,16,15,17,18]
Output: 216212978
Explanation: The number of ways to reorder nums to get the same BST is 3216212999. Taking this number modulo 10^9 + 7 gives 216212978.

Constraints:

• 1 <= nums.length <= 1000
• 1 <= nums[i] <= nums.length
• All integers in nums are distinct.

Solution: Recursion + Combinatorics

For a given root (first element of the array), we can split the array into left children (nums[i] < nums[0]) and right children (nums[i] > nums[0]). Assuming there are l nodes for the left and r nodes for the right. We have C(l + r, l) different ways to insert l elements into a (l + r) sized array. Within node l / r nodes, we have ways(left) / ways(right) different ways to re-arrange those nodes. So the total # of ways is:
C(l + r, l) * ways(l) * ways(r)
Don’t forget to minus one for the final answer.

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

class Solution {
public:
  int numOfWays(vector<int>& nums) {
    const int n = nums.size();
    const int kMod = 1e9 + 7;
    vector<vector<int>> cnk(n + 1, vector<int>(n + 1, 1));    
    for (int i = 1; i <= n; ++i)      
      for (int j = 1; j < i; ++j)
        cnk[i][j] = (cnk[i - 1][j] + cnk[i - 1][j - 1]) % kMod;    
    function<int(vector<int>)> trees = [&](const vector<int>& nums) {
      const int n = nums.size();
      if (n <= 2) return 1;
      vector<int> left;
      vector<int> right;
      for (int i = 1; i < nums.size(); ++i)
        if (nums[i] < nums[0]) left.push_back(nums[i]);
        else right.push_back(nums[i]);
      long ans = cnk[n - 1][left.size()];
      ans = (ans * trees(left)) % kMod;      
      ans = (ans * trees(right)) % kMod;      
      return static_cast<int>(ans);
    };
    return trees(nums) - 1;
  } 
};

class Solution:
  def numOfWays(self, nums: List[int]) -> int:
    def ways(nums):
      if len(nums) <= 2: return 1
      l = [x for x in nums if x < nums[0]]
      r = [x for x in nums if x > nums[0]]
      return comb(len(l) + len(r), len(l)) * ways(l) * ways(r)
    return (ways(nums) - 1) % (10**9 + 7)

The post 花花酱 LeetCode 1569. Number of Ways to Reorder Array to Get Same BST appeared first on Huahua's Tech Road.

Given 2n balls of k distinct colors. You will be given an integer array balls of size k where balls[i] is the number of balls of color i. 

All the balls will be shuffled uniformly at random, then we will distribute the first n balls to the first box and the remaining n balls to the other box (Please read the explanation of the second example carefully).

Please note that the two boxes are considered different. For example, if we have two balls of colors a and b, and two boxes [] and (), then the distribution [a] (b) is considered different than the distribution [b] (a) (Please read the explanation of the first example carefully).

We want to calculate the probability that the two boxes have the same number of distinct balls.

Example 1:

Input: balls = [1,1]
Output: 1.00000
Explanation: Only 2 ways to divide the balls equally:
- A ball of color 1 to box 1 and a ball of color 2 to box 2
- A ball of color 2 to box 1 and a ball of color 1 to box 2
In both ways, the number of distinct colors in each box is equal. The probability is 2/2 = 1

Example 2:

Input: balls = [2,1,1]
Output: 0.66667
Explanation: We have the set of balls [1, 1, 2, 3]
This set of balls will be shuffled randomly and we may have one of the 12 distinct shuffles with equale probability (i.e. 1/12):
[1,1 / 2,3], [1,1 / 3,2], [1,2 / 1,3], [1,2 / 3,1], [1,3 / 1,2], [1,3 / 2,1], [2,1 / 1,3], [2,1 / 3,1], [2,3 / 1,1], [3,1 / 1,2], [3,1 / 2,1], [3,2 / 1,1]
After that we add the first two balls to the first box and the second two balls to the second box.
We can see that 8 of these 12 possible random distributions have the same number of distinct colors of balls in each box.
Probability is 8/12 = 0.66667

Example 3:

Input: balls = [1,2,1,2]
Output: 0.60000
Explanation: The set of balls is [1, 2, 2, 3, 4, 4]. It is hard to display all the 180 possible random shuffles of this set but it is easy to check that 108 of them will have the same number of distinct colors in each box.
Probability = 108 / 180 = 0.6

Example 4:

Input: balls = [3,2,1]
Output: 0.30000
Explanation: The set of balls is [1, 1, 1, 2, 2, 3]. It is hard to display all the 60 possible random shuffles of this set but it is easy to check that 18 of them will have the same number of distinct colors in each box.
Probability = 18 / 60 = 0.3

Example 5:

Input: balls = [6,6,6,6,6,6]
Output: 0.90327

Constraints:

• 1 <= balls.length <= 8
• 1 <= balls[i] <= 6
• sum(balls) is even.
• Answers within 10^-5 of the actual value will be accepted as correct.

Solution 0: Permutation (TLE)

Enumerate all permutations of the balls, count valid ones and divide that by the total.

Time complexity: O((8*6)!) = O(48!)
After deduplication: O(48!/(6!)^8) ~ 1.7e38
Space complexity: O(8*6)

// Author: Huahua, TLE 4/21 passed
class Solution {
public:
  double getProbability(vector<int>& balls) {
    const int k = balls.size();
    vector<int> bs;
    for (int i = 0; i < k; ++i)
      for (int j = 0; j < balls[i]; ++j)
        bs.push_back(i);
    const int n = bs.size();
    double total = 0.0;
    double valid = 0.0;
    // d : depth
    // used : bitmap of bs's usage
    // c1: bitmap of colors of box1
    // c2: bitmap of colors of box1
    function<void(int, long, int, int)> dfs = [&](int d, long used, int c1, int c2) {    
      if (d == n) {          
        total += 1;
        valid += __builtin_popcount(c1) == __builtin_popcount(c2);                
        return;
      }
      for (int i = 0; i < n; ++i) {
        if (used & (1L << i)) continue;
        // Deduplication.
        if (i > 0 && bs[i] == bs[i - 1] && !(used & (1L << (i - 1)))) continue;        
        int tc1 = (d < n / 2) ? (c1 | (1 << bs[i])) : c1;
        int tc2 = (d < n / 2) ? c2 : (c2 | (1 << bs[i]));
        dfs(d + 1, used | (1L << i), tc1, tc2);
      }
    };
    dfs(0, 0, 0, 0);    
    return valid / total;
  }
};

Solution 1: Combination

For each color, put n_i balls into box1, the left t_i – n_i balls go to box2.
permutations = fact(n//2) / PROD(fact(n_i)) * fact(n//2) * PROD(fact(t_i – n_i))
E.g
balls = [1×2, 2×6, 3×4]
One possible combination:
box1: 1 22 333
box2: 1 2222 3
permutations = 6! / (1! * 2! * 3!) * 6! / (1! * 4! * 1!) = 1800

Time complexity: O((t+1)^k) = O(7^8)
Space complexity: O(k + (t*k)) = O(8 + 48)

// Author: Huahua
class Solution {
public:
  double getProbability(vector<int>& balls) {
    const int n = accumulate(begin(balls), end(balls), 0);
    const int k = balls.size();        
    double total = 0.0;
    double valid = 0.0;
    vector<double> fact(50, 1.0);
    for (int i = 1; i < fact.size(); ++i)
      fact[i] = fact[i - 1] * i;
    // d: depth
    // b1, b2: # of balls in box1, box2
    // c1, c2: # of distinct colors in box1, box2
    // p1, p2: # permutations of duplicate balls in box1, box2
    function<void(int, int, int, int, int, double, double)> dfs = [&]
      (int d, int b1, int b2, int c1, int c2, double p1, double p2) {
      if (b1 > n / 2 || b2 > n / 2) return;
      if (d == k) {
        const double count = fact[b1] / p1 * fact[b2] / p2;
        total += count;
        valid += count * (c1 == c2);
        return;
      }
      for (int s1 = 0; s1 <= balls[d]; ++s1) {
        const int s2 = balls[d] - s1;
        dfs(d + 1,
            b1 + s1, 
            b2 + s2,
            c1 + (s1 > 0), 
            c2 + (s2 > 0), 
            p1 * fact[s1], 
            p2 * fact[s2]);
      }
    };
    dfs(0, 0, 0, 0, 0, 1.0, 1.0);
    return valid / total;
  }
};

vector version

// Author: Huahua
class Solution {
public:
  double getProbability(vector<int>& balls) {
    const int k = balls.size();                    
    const int n = accumulate(begin(balls), end(balls), 0);
    vector<double> fact(49, 1.0);
    for (int i = 1; i < fact.size(); ++i)
      fact[i] = fact[i - 1] * i;
    auto perms = [&](const vector<int>& bs, int n) -> double {
      double p = fact[n];
      for (int b : bs) p /= fact[b];        
      return p;
    };
    vector<int> box1, box2;
    function<double(int)> dfs = [&](int d) -> double {
      const int n1 = accumulate(begin(box1), end(box1), 0);
      const int n2 = accumulate(begin(box2), end(box2), 0);
      if (n1 > n / 2 || n2 > n / 2) return 0;
      if (d == k)
        return (box1.size() == box2.size()) * perms(box1, n1) * perms(box2, n2);
      double total = 0;
      for (int s1 = 0; s1 <= balls[d]; ++s1) {
        const int s2 = balls[d] - s1;
        if (s1) box1.push_back(s1);
        if (s2) box2.push_back(s2);
        total += dfs(d + 1);
        if (s1) box1.pop_back();
        if (s2) box2.pop_back();
      }
      return total;
    };
    return dfs(0) / perms(balls, n);
  }
};

The post 花花酱 LeetCode 1467. Probability of a Two Boxes Having The Same Number of Distinct Balls appeared first on Huahua's Tech Road.

You are given n the number of rows of the grid.

Return the number of ways you can paint this grid. As the answer may grow large, the answer must be computed modulo 10^9 + 7.

Example 1:

Input: n = 1
Output: 12
Explanation: There are 12 possible way to paint the grid as shown:

Example 2:

Input: n = 2
Output: 54

Example 3:

Input: n = 3
Output: 246

Example 4:

Input: n = 7
Output: 106494

Example 5:

Input: n = 5000
Output: 30228214

Constraints:

• n == grid.length
• grid[i].length == 3
• 1 <= n <= 5000

Solution: DP

dp[i][0] := # of ways to paint i rows with 2 different colors at the i-th row
dp[i][1] := # of ways to paint i rows with 3 different colors at the i-th row
dp[1][0] = dp[1][1] = 6
dp[i][0] = dp[i-1][0] * 3 + dp[i-1][1] * 2
dp[i][1] = dp[i-1][0] * 2 + dp[i-1][1] * 2

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

// Author: Huahua
class Solution {
public:
  int numOfWays(int n) {
    constexpr int kMod = 1e9 + 7;
    // dp[i][0] = # of ways to paint i rows with i-th row has 2 colors (e.g. 121)
    // dp[i][1] = # of ways to paint i rows with i-th row has 3 colors (e.g. 123)
    // dp[1][0] = dp[1][1] = 6.
    vector<vector<long>> dp(n + 1, vector<long>(2, 6));        
    for (int i = 2; i <= n; ++i) {
      // 121 => 2 colors x 3 {212, 232, 313}, 3 colors x 2 {213, 312}
      // 123 => 2 colors x 2 {212, 232}, 3 colors x 2 {231, 312}      
      dp[i][0] = (dp[i - 1][0] * 3 + dp[i - 1][1] * 2) % kMod;
      dp[i][1] = (dp[i - 1][0] * 2 + dp[i - 1][1] * 2) % kMod;
    }
    return (dp[n][0] + dp[n][1]) % kMod;
  }
};

# Author: Huahua
class Solution:
  def numOfWays(self, n: int) -> int:
    kMod = 10**9 + 7
    dp2, dp3 = 6, 6
    for i in range(1, n):
      t2, t3 = dp2 * 3 + dp3 * 2, dp2 * 2 + dp3 * 2
      dp2, dp3 = t2 % kMod, t3 % kMod
    return (dp2 + dp3) % kMod

Solution 2: DP w/ Matrix Chain Multiplication

ans = {6, 6} * {{3, 2}, {2,2}} ^ (n-1)

Time complexity: O(logn)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int numOfWays(int n) {
    constexpr long kMod = 1e9 + 7;
    vector<vector<long>> ans{{6, 6}}; // 1x2
    vector<vector<long>> M{{3, 2},{2,2}}; // 2x2
    auto mul = [kMod](const vector<vector<long>>& A, 
                      const vector<vector<long>>& B) {
      const int m = A.size(); // m * n
      const int n = B.size(); // n * p
      const int p = B[0].size();
      vector<vector<long>> C(m, vector<long>(p));
      for (int i = 0; i < m; ++i)
        for (int j = 0; j < p; ++j)
          for (int k = 0; k < n; ++k)
            C[i][j] += (A[i][k] * B[k][j]) % kMod;
      return C;
    };
    --n;
    while (n) {      
      if (n & 1) ans = mul(ans, M); // ans = ans * M;
      M = mul(M, M); // M = M^2
      n >>= 1;
    }
    // ans = ans0 * M^(n-1)
    return (ans[0][0] + ans[0][1]) % kMod;
  }
};

The post 花花酱 LeetCode 1411. Number of Ways to Paint N × 3 Grid appeared first on Huahua's Tech Road.