Given a string s, partition the string into one or more substrings such that the characters in each substring are unique. That is, no letter appears in a single substring more than once.

Return the minimum number of substrings in such a partition.

Note that each character should belong to exactly one substring in a partition.

Example 1:

Input: s = "abacaba"
Output: 4
Explanation:
Two possible partitions are ("a","ba","cab","a") and ("ab","a","ca","ba").
It can be shown that 4 is the minimum number of substrings needed.

Example 2:

Input: s = "ssssss"
Output: 6
Explanation:
The only valid partition is ("s","s","s","s","s","s").

Constraints:

• 1 <= s.length <= 105
• s consists of only English lowercase letters.

Solution: Greedy

Extend the cur string as long as possible unless a duplicate character occurs.

You can use hashtable / array or bitmask to mark whether a character has been seen so far.

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

// Author: Huahua
class Solution {
public:
  int partitionString(string s) {
    unordered_set<char> m;
    int ans = 0;
    for (char c : s) {
      if (m.insert(c).second) continue;
      m.clear();
      m.insert(c);
      ++ans;
    }
    return ans + 1;
  }
};

// Author: Huahua
class Solution {
public:
  int partitionString(string s) {
    vector<int> m(26);
    int ans = 0;
    for (char c : s) {
      if (++m[c - 'a'] == 1) continue;
      fill(begin(m), end(m), 0);
      m[c - 'a'] = 1;
      ++ans;
    }
    return ans + 1;
  }
};

// Author: Huahua
class Solution {
public:
  int partitionString(string s) {
    int mask = 0;
    int ans = 0;
    for (char c : s) {
      if (mask & (1 << (c - 'a'))) {
        mask = 0;        
        ++ans;
      }
      mask |= 1 << (c - 'a');
    }
    return ans + 1;
  }
};

The post 花花酱 LeetCode 2405. Optimal Partition of String appeared first on Huahua's Tech Road.

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

For each string in targetWords, check if it is possible to choose a string from startWords and perform a conversion operation on it to be equal to that from targetWords.

The conversion operation is described in the following two steps:

1. Append any lowercase letter that is not present in the string to its end.
   • For example, if the string is "abc", the letters 'd', 'e', or 'y' can be added to it, but not 'a'. If 'd' is added, the resulting string will be "abcd".
2. Rearrange the letters of the new string in any arbitrary order.
   • For example, "abcd" can be rearranged to "acbd", "bacd", "cbda", and so on. Note that it can also be rearranged to "abcd" itself.

Return the number of strings in targetWords that can be obtained by performing the operations on any string of startWords.

Note that you will only be verifying if the string in targetWords can be obtained from a string in startWords by performing the operations. The strings in startWords do not actually change during this process.

Example 1:

Input: startWords = ["ant","act","tack"], targetWords = ["tack","act","acti"]
Output: 2
Explanation:
- In order to form targetWords[0] = "tack", we use startWords[1] = "act", append 'k' to it, and rearrange "actk" to "tack".
- There is no string in startWords that can be used to obtain targetWords[1] = "act".
  Note that "act" does exist in startWords, but we must append one letter to the string before rearranging it.
- In order to form targetWords[2] = "acti", we use startWords[1] = "act", append 'i' to it, and rearrange "acti" to "acti" itself.

Example 2:

Input: startWords = ["ab","a"], targetWords = ["abc","abcd"]
Output: 1
Explanation:
- In order to form targetWords[0] = "abc", we use startWords[0] = "ab", add 'c' to it, and rearrange it to "abc".
- There is no string in startWords that can be used to obtain targetWords[1] = "abcd".

Constraints:

• 1 <= startWords.length, targetWords.length <= 5 * 104
• 1 <= startWords[i].length, targetWords[j].length <= 26
• Each string of startWords and targetWords consists of lowercase English letters only.
• No letter occurs more than once in any string of startWords or targetWords.

Solution: Bitmask w/ Hashtable

Since there is no duplicate letters in each word, we can use a bitmask to represent a word.

Step 1: For each word in startWords, we obtain its bitmask and insert it into a hashtable.
Step 2: For each word in targetWords, enumerate it’s letter and unset 1 bit (skip one letter) and see whether it’s in the hashtable or not.

E.g. for target word “abc”, its bitmask is 0…0111, and we test whether “ab” or “ac” or “bc” in the hashtable or not.

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

// Author: Huahua
class Solution {
public:
  int wordCount(vector<string>& startWords, vector<string>& targetWords) {
    unordered_set<int> s;
    auto getKey = [](const string& s) {      
      return accumulate(begin(s), end(s), 0, [](int key, char c) { return key | (1 << (c - 'a')); });
    };
    
    for (const string& w : startWords)
      s.insert(getKey(w));
        
    return accumulate(begin(targetWords), end(targetWords), 0, [&](int ans, const string& w) {
      const int key = getKey(w);
      return ans + any_of(begin(w), end(w), [&](char c) { return s.count(key ^ (1 << (c - 'a'))); });
    });
  }
};

The post 花花酱 LeetCode 2135. Count Words Obtained After Adding a Letter appeared first on Huahua's Tech Road.

• For example, "ccjjc" and "abab" are wonderful, but "ab" is not.

Given a string word that consists of the first ten lowercase English letters ('a' through 'j'), return the number of wonderful non-empty substrings in word. If the same substring appears multiple times in word, then count each occurrence separately.

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

Example 1:

Input: word = "aba"
Output: 4
Explanation: The four wonderful substrings are underlined below:
- "aba" -> "a"
- "aba" -> "b"
- "aba" -> "a"
- "aba" -> "aba"

Example 2:

Input: word = "aabb"
Output: 9
Explanation: The nine wonderful substrings are underlined below:
- "aabb" -> "a"
- "aabb" -> "aa"
- "aabb" -> "aab"
- "aabb" -> "aabb"
- "aabb" -> "a"
- "aabb" -> "abb"
- "aabb" -> "b"
- "aabb" -> "bb"
- "aabb" -> "b"

Example 3:

Input: word = "he"
Output: 2
Explanation: The two wonderful substrings are underlined below:
- "he" -> "h"
- "he" -> "e"

Constraints:

• 1 <= word.length <= 105
• word consists of lowercase English letters from 'a' to 'j'.

Solution: Prefix Bitmask + Hashtable

Similar to 花花酱 LeetCode 1371. Find the Longest Substring Containing Vowels in Even Counts, we use a bitmask to represent the occurrence (odd or even) of each letter and use a hashtable to store the frequency of each bitmask seen so far.

1. “0000000000” means all letters occur even times.
2. “0000000101” means all letters occur even times expect letter ‘a’ and ‘c’ that occur odd times.

We scan the word from left to right and update the bitmask: bitmask ^= (1 << (c-‘a’)).
However, the bitmask only represents the state of the prefix, i.e. word[0:i], then how can we count substrings? The answer is hashtable. If the same bitmask occurs c times before, which means there are c indices that word[0~j1], word[0~j2], …, word[0~jc] have the same state as word[0~i] that means for word[j1+1~i], word[j2+1~i], …, word[jc+1~i], all letters occurred even times.
For the “at most one odd” case, we toggle each bit of the bitmask and check how many times it occurred before.

ans += freq[mask] + sum(freq[mask ^ (1 << i)] for i in range(k))

Time complexity: O(n*k)
Space complexity: O(2^k)
where k = j – a + 1 = 10

// Author: Huahua
class Solution {
public:
  long long wonderfulSubstrings(string word) {
    constexpr int l = 'j' - 'a' + 1;
    vector<int> count(1 << l);
    count[0] = 1;
    int mask = 0;
    long long ans = 0;
    for (char c : word) {
      mask ^= 1 << (c - 'a'); 
      for (int i = 0; i < l; ++i)
        ans += count[mask ^ (1 << i)]; // one odd.
      ans += count[mask]++; // all even.
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1915. Number of Wonderful Substrings appeared first on Huahua's Tech Road.

The tournament consists of multiple rounds (starting from round number 1). In each round, the ith player from the front of the row competes against the ith player from the end of the row, and the winner advances to the next round. When the number of players is odd for the current round, the player in the middle automatically advances to the next round.

• For example, if the row consists of players 1, 2, 4, 6, 7
  • Player 1 competes against player 7.
  • Player 2 competes against player 6.
  • Player 4 automatically advances to the next round.

After each round is over, the winners are lined back up in the row based on the original ordering assigned to them initially (ascending order).

The players numbered firstPlayer and secondPlayer are the best in the tournament. They can win against any other player before they compete against each other. If any two other players compete against each other, either of them might win, and thus you may choose the outcome of this round.

Given the integers n, firstPlayer, and secondPlayer, return an integer array containing two values, the earliest possible round number and the latest possible round number in which these two players will compete against each other, respectively.

Example 1:

Input: n = 11, firstPlayer = 2, secondPlayer = 4
Output: [3,4]
Explanation:
One possible scenario which leads to the earliest round number:
First round: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
Second round: 2, 3, 4, 5, 6, 11
Third round: 2, 3, 4
One possible scenario which leads to the latest round number:
First round: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
Second round: 1, 2, 3, 4, 5, 6
Third round: 1, 2, 4
Fourth round: 2, 4

Example 2:

Input: n = 5, firstPlayer = 1, secondPlayer = 5
Output: [1,1]
Explanation: The players numbered 1 and 5 compete in the first round.
There is no way to make them compete in any other round.

Constraints:

• 2 <= n <= 28
• 1 <= firstPlayer < secondPlayer <= n

Solution 1: Simulation using recursion

All possible paths,
Time complexity: O(n²*2ⁿ)
Space complexity: O(logn)

dfs(s, i, j, d) := let i battle with j at round d, given s (binary mask of dead players).

// Author: Huahua
class Solution {
public:
  vector<int> earliestAndLatest(int n, int a, int b) {
    vector<int> ans{INT_MAX, INT_MIN};    
    function<void(int, int, int, int)> dfs = [&](int s, int i, int j, int d) {
      while (i < j && s >> i & 1) ++i;
      while (i < j && s >> j & 1) --j;
      if (i >= j) {
        return dfs(s, 1, n, d + 1);
      } else if (i == a && j == b) {
        ans[0] = min(ans[0], d);
        ans[1] = max(ans[1], d);
      } else {
        if (i != a && i != b)
          dfs(s | (1 << i), i + 1, j - 1, d);
        if (j != a && j != b)
          dfs(s | (1 << j), i + 1, j - 1, d);
      }
    };
    dfs(0, 1, n, 1);
    return ans;
  }
};

The post 花花酱 LeetCode 1900. The Earliest and Latest Rounds Where Players Compete appeared first on Huahua's Tech Road.

There are k workers that you can assign jobs to. Each job should be assigned to exactly one worker. The working time of a worker is the sum of the time it takes to complete all jobs assigned to them. Your goal is to devise an optimal assignment such that the maximum working time of any worker is minimized.

Return the minimum possible maximum working time of any assignment.

Example 1:

Input: jobs = [3,2,3], k = 3
Output: 3
Explanation: By assigning each person one job, the maximum time is 3.

Example 2:

Input: jobs = [1,2,4,7,8], k = 2
Output: 11
Explanation: Assign the jobs the following way:
Worker 1: 1, 2, 8 (working time = 1 + 2 + 8 = 11)
Worker 2: 4, 7 (working time = 4 + 7 = 11)
The maximum working time is 11.

Constraints:

• 1 <= k <= jobs.length <= 12
• 1 <= jobs[i] <= 107

Solution 1: All subsets

dp[i][t] := min of max working time by assigning a subset of jobs s to the first i workers.

dp[i][t] = min{max(dp[i – 1][s], cost[s ^ t])} where s is a subset of t.

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

// Author: Huahua
// Author: Huahua
class Solution {
public:
  int minimumTimeRequired(vector<int>& jobs, int k) {    
    const int n = jobs.size();
    int dp[13][4096];
    memset(dp, 0x7f, sizeof(dp));
    dp[0][0] = 0;
    
    vector<int> cost(1 << n);
    for (int t = 0; t < 1 << n; ++t) {
      for (int j = 0; j < n; ++j)
        if (t >> j & 1) cost[t] += jobs[j];
      dp[1][t] = cost[t]; // do jobs t by one worker
    }
    
    for (int i = 2; i <= k; ++i)
      for (int t = 0; t < 1 << n; ++t)
        for (int s = t; s; s = (s - 1) & t)
          dp[i][t] = min(dp[i][t], max(dp[i - 1][s], cost[t ^ s]));
    return dp[k][(1 << n) - 1];
  }
};

Solution 2: Search + Pruning

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

class Solution {
public:
  int minimumTimeRequired(vector<int>& jobs, int k) {
    vector<int> times(k);
    int ans = INT_MAX;
    function<void(int, int)> dfs = [&](int i, int cur) {
      if (cur >= ans) return;
      if (i == jobs.size()) {
        ans = cur;
        return;
      }
      unordered_set<int> seen;
      for (int j = 0; j < k; ++j) {
        if (!seen.insert(times[j]).second) continue;
        times[j] += jobs[i];
        dfs(i + 1, max(cur, times[j]));
        times[j] -= jobs[i];
      }
    };
    sort(rbegin(jobs), rend(jobs));
    dfs(0, 0);
    return ans;
  }
};

The post 花花酱 LeetCode 1723. Find Minimum Time to Finish All Jobs appeared first on Huahua's Tech Road.

You are given an integer array nums​​​ and an integer k. You are asked to distribute this array into k subsets of equal size such that there are no two equal elements in the same subset.

A subset’s incompatibility is the difference between the maximum and minimum elements in that array.

Return the minimum possible sum of incompatibilities of the k subsets after distributing the array optimally, or return -1 if it is not possible.

A subset is a group integers that appear in the array with no particular order.

Example 1:

Input: nums = [1,2,1,4], k = 2
Output: 4
Explanation: The optimal distribution of subsets is [1,2] and [1,4].
The incompatibility is (2-1) + (4-1) = 4.
Note that [1,1] and [2,4] would result in a smaller sum, but the first subset contains 2 equal elements.

Example 2:

Input: nums = [6,3,8,1,3,1,2,2], k = 4
Output: 6
Explanation: The optimal distribution of subsets is [1,2], [2,3], [6,8], and [1,3].
The incompatibility is (2-1) + (3-2) + (8-6) + (3-1) = 6.

Example 3:

Input: nums = [5,3,3,6,3,3], k = 3
Output: -1
Explanation: It is impossible to distribute nums into 3 subsets where no two elements are equal in the same subset.

Constraints:

• 1 <= k <= nums.length <= 16
• nums.length is divisible by k
• 1 <= nums[i] <= nums.length

Solution: TSP

dp[s][i] := min cost to distribute a set of numbers represented as a binary mask s, the last number in the set is the i-th number.

Init:
1.dp[*][*] = inf
2. dp[1 <<i][i] = 0, cost of selecting a single number is zero.

Transition:
1. dp[s | (1 << j)][j] = dp[s][i] if s % (n / k) == 0, we start a new group, no extra cost.
2. dp[s | (1 << j)][j] = dp[s][i] + nums[j] – nums[i] if nums[j] > nums[i]. In the same group, we require the selected numbers are monotonically increasing. Each cost is nums[j] – nums[i].
e.g. 1, 3, 7, 20, cost is (3 – 1) + (7 – 3) + (20 – 7) = 20 – 1 = 19.

Ans: min(dp[(1 << n) – 1])

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

// Author: Huahua
class Solution {
public:
  int minimumIncompatibility(vector<int>& nums, int k) {
    const int n = nums.size(); 
    const int c = n / k;
    int dp[1 << 16][16];
    memset(dp, 0x7f, sizeof(dp));
    for (int i = 0; i < n; ++i) dp[1 << i][i] = 0;
    for (int s = 0; s < 1 << n; ++s)
      for (int i = 0; i < n; ++i) {
        if ((s & (1 << i)) == 0) continue;
        for (int j = 0; j < n; ++j) {
          if ((s & (1 << j))) continue;
          const int t = s | (1 << j);
          if (__builtin_popcount(s) % c == 0) {
            dp[t][j] = min(dp[t][j], dp[s][i]);
          } else if (nums[j] > nums[i]) {           
            dp[t][j] = min(dp[t][j], 
                           dp[s][i] + nums[j] - nums[i]);            
          }
        }        
    }
    int ans = *min_element(begin(dp[(1 << n) - 1]), 
                           end(dp[(1 << n) - 1]));
    return ans > 1e9 ? - 1 : ans;
  }
};

The post 花花酱 LeetCode 1681. Minimum Incompatibility appeared first on Huahua's Tech Road.

• The ith customer gets exactly quantity[i] integers,
• The integers the ith customer gets are all equal, and
• Every customer is satisfied.

Return true if it is possible to distribute nums according to the above conditions.

Example 1:

Input: nums = [1,2,3,4], quantity = [2]
Output: false
Explanation: The 0th customer cannot be given two different integers.

Example 2:

Input: nums = [1,2,3,3], quantity = [2]
Output: true
Explanation: The 0th customer is given [3,3]. The integers [1,2] are not used.

Example 3:

Input: nums = [1,1,2,2], quantity = [2,2]
Output: true
Explanation: The 0th customer is given [1,1], and the 1st customer is given [2,2].

Example 4:

Input: nums = [1,1,2,3], quantity = [2,2]
Output: false
Explanation: Although the 0th customer could be given [1,1], the 1st customer cannot be satisfied.

Example 5:

Input: nums = [1,1,1,1,1], quantity = [2,3]
Output: true
Explanation: The 0th customer is given [1,1], and the 1st customer is given [1,1,1].

Constraints:

• n == nums.length
• 1 <= n <= 105
• 1 <= nums[i] <= 1000
• m == quantity.length
• 1 <= m <= 10
• 1 <= quantity[i] <= 105
• There are at most 50 unique values in nums.

Solution1: Backtracking

Time complexity: O(|vals|^m)
Space complexity: O(|vals| + m)

// Author: Huahua
class Solution {
public:
  bool canDistribute(vector<int>& nums, vector<int>& quantity) {
    unordered_map<int, int> m;
    for (int x : nums) ++m[x];
    vector<int> cnt;
    for (const auto& [x, c] : m) cnt.push_back(c);
    
    const int q = quantity.size();
    const int n = cnt.size();
    function<bool(int)> dfs = [&](int d) {
      if (d == q) return true;
      for (int i = 0; i < n; ++i) 
        if (cnt[i] >= quantity[d]) {
          cnt[i] -= quantity[d];
          if (dfs(d + 1)) return true;
          cnt[i] += quantity[d];
        }
      return false;
    };
    
    sort(rbegin(cnt), rend(cnt));
    sort(rbegin(quantity), rend(quantity));
    
    return dfs(0);
  }
};

Solution 2: Bitmask + all subsets

dp(mask, i) := whether we can distribute to a subset of customers represented as a bit mask, using the i-th to (n-1)-th numbers.

Time complexity: O(2^m * m * |vals|) = O(2^10 * 10 * 50)
Space complexity: O(2^m * |vals|)

class Solution {
public:
  bool canDistribute(vector<int>& nums, vector<int>& quantity) {
    vector<int> cnt;
    unordered_map<int, int> freq;
    for (int x : nums) ++freq[x]; 
    for (const auto& [x, f] : freq) cnt.push_back(f);
    
    const int n = cnt.size();
    const int m = quantity.size();        
    
    vector<vector<optional<bool>>> cache(1 << m, vector<optional<bool>>(n));
    
    vector<int> sums(1 << m);
    for (int mask = 0; mask < 1 << m; ++mask)
      for (int i = 0; i < m; ++i)
        if (mask & (1 << i))
          sums[mask] += quantity[i];
    
    function<bool(int, int)> dp = [&](int mask, int i) -> bool {
      if (mask == 0) return true;
      if (i == n) return false;
      
      auto& ans = cache[mask][i];
      
      if (ans.has_value()) return ans.value();
      
      int cur = mask;
      while (cur) {
        if (sums[cur] <= cnt[i] && dp(mask ^ cur, i + 1)) {
          ans = true;
          return true;
        }
        cur = (cur - 1) & mask;
      }
      
      ans = dp(mask, i + 1);
      return ans.value();
    };
    
    return dp((1 << m) - 1, 0);
  }
};

# Author: Huahua
class Solution:
  def canDistribute(self, nums: List[int], 
                    quantity: List[int]) -> bool:    
    cnts = list(Counter(nums).values())
    m = len(quantity)
    n = len(cnts)
    sums = [0] * (1 << m)
    for mask in range(1 << m):
      for i in range(m):
        if mask & (1 << i): sums[mask] += quantity[i]
    
    @lru_cache(None)
    def dp(mask: int, i: int) -> bool:
      if not mask: return True
      if i < 0: return False
      
      cur = mask
      while cur:
        if sums[cur] <= cnts[i] and dp(mask ^ cur, i - 1):
          return True
        cur = (cur - 1) & mask
      
      return dp(mask, i - 1)
    
    return dp((1 << m) - 1, n - 1)

Bottom up:

class Solution {
public:
  bool canDistribute(vector<int>& nums, vector<int>& quantity) {
    vector<int> cnt;
    unordered_map<int, int> freq;
    for (int x : nums) ++freq[x]; 
    for (const auto& [x, f] : freq) cnt.push_back(f);
    
    const int n = cnt.size();
    const int m = quantity.size();            
    
    vector<int> sums(1 << m);
    for (int mask = 0; mask < 1 << m; ++mask)
      for (int i = 0; i < m; ++i)
        if (mask & (1 << i))
          sums[mask] += quantity[i];
    
    // dp[mask][i] := use first i types to satisfy mask customers.
    vector<vector<int>> dp(1 << m, vector<int>(n + 1));
    dp[0][0] = 1;    
    for (int mask = 0; mask < 1 << m; ++mask)
      for (int i = 0; i < n; ++i) {
        dp[mask][i + 1] |= dp[mask][i];
        for (int cur = mask; cur; cur = (cur - 1) & mask)
          if (sums[cur] <= cnt[i] && dp[mask ^ cur][i])
            dp[mask][i + 1] = 1;
      }
    
    return dp[(1 << m) - 1][n];
  }
};

The post 花花酱 LeetCode 1655. Distribute Repeating Integers appeared first on Huahua's Tech Road.

You are given two groups of points where the first group has size1 points, the second group has size2 points, and size1 >= size2.

The cost of the connection between any two points are given in an size1 x size2 matrix where cost[i][j] is the cost of connecting point i of the first group and point j of the second group. The groups are connected if each point in both groups is connected to one or more points in the opposite group. In other words, each point in the first group must be connected to at least one point in the second group, and each point in the second group must be connected to at least one point in the first group.

Return the minimum cost it takes to connect the two groups.

Example 1:

Input: cost = [[15, 96], [36, 2]]
Output: 17
Explanation: The optimal way of connecting the groups is:
1--A
2--B
This results in a total cost of 17.

Example 2:

Input: cost = [[1, 3, 5], [4, 1, 1], [1, 5, 3]]
Output: 4
Explanation: The optimal way of connecting the groups is:
1--A
2--B
2--C
3--A
This results in a total cost of 4.
Note that there are multiple points connected to point 2 in the first group and point A in the second group. This does not matter as there is no limit to the number of points that can be connected. We only care about the minimum total cost.

Example 3:

Input: cost = [[2, 5, 1], [3, 4, 7], [8, 1, 2], [6, 2, 4], [3, 8, 8]]
Output: 10

Constraints:

• size1 == cost.length
• size2 == cost[i].length
• 1 <= size1, size2 <= 12
• size1 >= size2
• 0 <= cost[i][j] <= 100

Solution 1: Bistmask DP

dp[i][s] := min cost to connect first i (1-based) points in group1 and a set of points (represented by a bitmask s) in group2.

ans = dp[m][1 << n – 1]

dp[i][s | (1 << j)] := min(dp[i][s] + cost[i][j], dp[i-1][s] + cost[i][j])

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

class Solution {
public:
  int connectTwoGroups(vector<vector<int>>& cost) {
    constexpr int kInf = 1e9;
    const int m = cost.size();
    const int n = cost[0].size();
    // dp[i][s] := min cost to connect first i points in group1 
    // and points (bitmask s) in group2.
    vector<vector<int>> dp(m + 1, vector<int>(1 << n, kInf));
    dp[0][0] = 0;
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        for (int s = 0; s < 1 << n; ++s)
          dp[i + 1][s | (1 << j)] = min({dp[i + 1][s | (1 << j)], 
                                         dp[i + 1][s] + cost[i][j],
                                         dp[i][s] + cost[i][j]});
    return dp[m].back();
  }
};

The post 花花酱 LeetCode 1595. Minimum Cost to Connect Two Groups of Points appeared first on Huahua's Tech Road.

Given a string s. An awesome substring is a non-empty substring of s such that we can make any number of swaps in order to make it palindrome.

Return the length of the maximum length awesome substring of s.

Example 1:

Input: s = "3242415"
Output: 5
Explanation: "24241" is the longest awesome substring, we can form the palindrome "24142" with some swaps.

Example 2:

Input: s = "12345678"
Output: 1

Example 3:

Input: s = "213123"
Output: 6
Explanation: "213123" is the longest awesome substring, we can form the palindrome "231132" with some swaps.

Example 4:

Input: s = "00"
Output: 2

Constraints:

• 1 <= s.length <= 10^5
• s consists only of digits.

Solution: Prefix mask + Hashtable

For a palindrome all digits must occurred even times expect one. We can use a 10 bit mask to track the occurrence of each digit for prefix s[0~i]. 0 is even, 1 is odd.

We use a hashtable to track the first index of each prefix state.
If s[0~i] and s[0~j] have the same state which means every digits in s[i+1~j] occurred even times (zero is also even) and it’s an awesome string. Then (j – (i+1) + 1) = j – i is the length of the palindrome. So far so good.

But we still need to consider the case when there is a digit with odd occurrence. We can enumerate all possible ones from 0 to 9, and temporarily flip the bit of the digit and see whether that state happened before.

fisrt_index[0] = -1, first_index[*] = inf
ans = max(ans, j – first_index[mask])

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

class Solution {
public:
  int longestAwesome(string s) {
    constexpr int kInf = 1e9;
    vector<int> idx(1024, kInf);
    idx[0] = -1;
    int mask = 0; // prefix's state 0:even, 1:odd
    int ans = 0;
    for (int i = 0; i < s.length(); ++i) {
      mask ^= (1 << (s[i] - '0'));
      ans = max(ans, i - idx[mask]);
      // One digit with odd count is allowed.
      for (int j = 0; j < 10; ++j)
        ans = max(ans, i - idx[mask ^ (1 << j)]);
      idx[mask] = min(idx[mask], i);
    }
    return ans;
  }
};

// Author: Huahua
class Solution {
  public int longestAwesome(String s) {
    final int n = s.length();
    int[] idx = new int[1024];
    Arrays.fill(idx, n);
    idx[0] = -1;
    int mask = 0;
    int ans = 0;
    for (int i = 0; i < n; ++i) {
      mask ^= (1 << (s.charAt(i) - '0'));
      ans = Math.max(ans, i - idx[mask]);      
      for (int j = 0; j < 10; ++j)
        ans = Math.max(ans, 
                       i - idx[mask ^ (1 << j)]);
      idx[mask] = Math.min(idx[mask], i);
    }
    return ans;
  }
}

# Author: Huahua
class Solution:
  def longestAwesome(self, s: str) -> int:  
    idx = [-1] + [len(s)] * 1023
    ans, mask = 0, 0
    for i, c in enumerate(s):
      mask ^= 1 << (ord(c) - ord('0'))
      ans = max([ans, i - idx[mask]]
                + [i - idx[mask ^ (1 << j)] for j in range(10)])
      idx[mask] = min(idx[mask], i)
    return ans

The post 花花酱 LeetCode 1542. Find Longest Awesome Substring appeared first on Huahua's Tech Road.

In one semester you can take at most k courses as long as you have taken all the prerequisites for the courses you are taking.

Return the minimum number of semesters to take all courses. It is guaranteed that you can take all courses in some way.

Example 1:

Input: n = 4, dependencies = [[2,1],[3,1],[1,4]], k = 2
Output: 3 
Explanation: The figure above represents the given graph. In this case we can take courses 2 and 3 in the first semester, then take course 1 in the second semester and finally take course 4 in the third semester.

Example 2:

Input: n = 5, dependencies = [[2,1],[3,1],[4,1],[1,5]], k = 2
Output: 4 
Explanation: The figure above represents the given graph. In this case one optimal way to take all courses is: take courses 2 and 3 in the first semester and take course 4 in the second semester, then take course 1 in the third semester and finally take course 5 in the fourth semester.

Example 3:

Input: n = 11, dependencies = [], k = 2
Output: 6

Constraints:

• 1 <= n <= 15
• 1 <= k <= n
• 0 <= dependencies.length <= n * (n-1) / 2
• dependencies[i].length == 2
• 1 <= xi, yi <= n
• xi != yi
• All prerequisite relationships are distinct, that is, dependencies[i] != dependencies[j].
• The given graph is a directed acyclic graph.

Solution: DP / Bitmask

NOTE: This is a NP problem, any polynomial-time algorithm is incorrect otherwise P = NP.

Variant 1:
dp[m] := whether state m is reachable, where m is the bitmask of courses studied.
For each semester, we enumerate all possible states from 0 to 2^n – 1, if that state is reachable, then we choose c (c <= k) courses from n and check whether we can study those courses.
If we can study those courses, we have a new reachable state, we set dp[m | courses] = true.

Time complexity: O(n*2^n*2^n) = O(n*n^4) <– This will be much smaller in practice.
and can be reduced to O(n*3^n).
Space complexity: O(2^n)

// Author: Huahua, 52 ms, 14.5 MB
class Solution {
public:
  int minNumberOfSemesters(int n, vector<vector<int>>& dependencies, int k) {    
    const int S = 1 << n;
    vector<int> deps(n); // deps[i] = dependency mask for course i.
    for (const auto& d : dependencies)
      deps[d[1] - 1] |= 1 << (d[0] - 1);    
    // dp(i)[s] := reachable(s) at semester i.
    vector<int> dp(S);
    dp[0] = 1;
    for (int d = 1; d <= n; ++d) { // at most n semesters.
      vector<int> tmp(S); // start a new semesters.
      for (int s = 0; s < S; ++s) {
        if (!dp[s]) continue; // not a reachable state.
        int mask = 0;
        for (int i = 0; i < n; ++i)
          if (!(s & (1 << i)) && (s & deps[i]) == deps[i]) 
            mask |= (1 << i);
        // Prunning, take all.
        if (__builtin_popcount(mask) <= k) {
          tmp[s | mask] = 1;         
        } else {
          // Try all subsets. 
          for (int c = mask; c; c = (c - 1) & mask)
            if (__builtin_popcount(c) <= k) {
              tmp[s | c] = 1;
            }
        }
        if (tmp.back()) return d;
      }
      dp.swap(tmp);      
    }
    return -1;
  }
};

Variant 2:
dp[m] := min semesters to reach state m.
dp[m | c] = min{dp[m | c], dp[m] + 1}, if we can reach m | c from m.
This allows us to get rid of enumerate n semesters.
Time complexity: O(2^n*2^n) <– This will be much smaller in practice.
and can be reduced to O(3^n).
Space complexity: O(2^n)

// Author: Huahua, 16 ms, 8.5 MB
class Solution {
public:
  int minNumberOfSemesters(int n, vector<vector<int>>& dependencies, int k) {
    const int kInf = 1e9;
    const int S = 1 << n;
    vector<int> deps(n); // deps[i] = dependency mask for course i.
    for (const auto& d : dependencies)
      deps[d[1] - 1] |= 1 << (d[0] - 1);    
    // dp[m] := min semesters to reach state m.
    vector<int> dp(S, kInf);
    dp[0] = 0;
    for (int s = 0; s < S; ++s) {
      if (dp[s] == kInf) continue; // not reachable.
      // Generate a mask of courses we can study under state s.
      int mask = 0;
      for (int i = 0; i < n; ++i)
        if (!(s & (1 << i)) && (s & deps[i]) == deps[i])
          mask |= (1 << i);
      // Prunning, take all.
      if (__builtin_popcount(mask) <= k) {
        dp[s | mask] = min(dp[s | mask], dp[s] + 1);       
      } else {
        // Try all subsets.
        for (int c = mask; c; c = (c - 1) & mask)
          if (__builtin_popcount(c) <= k)
            dp[s | c] = min(dp[s | c], dp[s] + 1);
      }
      // Early termination?
      if (dp.back() != kInf) return dp.back();
    }
    return dp.back();
  }
};

The post 花花酱 LeetCode 1494. Parallel Courses II appeared first on Huahua's Tech Road.