A prefix common array of A and B is an array C such that C[i] is equal to the count of numbers that are present at or before the index i in both A and B.

Return the prefix common array of A and B.

A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.

Example 1:

Input: A = [1,3,2,4], B = [3,1,2,4]
Output: [0,2,3,4]
Explanation: At i = 0: no number is common, so C[0] = 0.
At i = 1: 1 and 3 are common in A and B, so C[1] = 2.
At i = 2: 1, 2, and 3 are common in A and B, so C[2] = 3.
At i = 3: 1, 2, 3, and 4 are common in A and B, so C[3] = 4.

Example 2:

Input: A = [2,3,1], B = [3,1,2]
Output: [0,1,3]
Explanation: At i = 0: no number is common, so C[0] = 0.
At i = 1: only 3 is common in A and B, so C[1] = 1.
At i = 2: 1, 2, and 3 are common in A and B, so C[2] = 3.

Constraints:

• 1 <= A.length == B.length == n <= 50
• 1 <= A[i], B[i] <= n
• It is guaranteed that A and B are both a permutation of n integers.

Solution 1: Bitset

Use bitsets to store the numbers seen so far for each array, and use sA & sB to count the common elements.

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

// Author: Huahua
class Solution {
public:
  vector<int> findThePrefixCommonArray(vector<int>& A, vector<int>& B) {
    bitset<51> sA;
    bitset<51> sB;
    vector<int> ans;
    for (int i = 0; i < A.size(); ++i) {
      sA.set(A[i]);
      sB.set(B[i]);
      ans.push_back((sA & sB).count());
    }
    return ans;
  }
};

Solution 2: Counter

Use a counter to track the frequency of each element, when the counter[x] == 2, we found a pair.

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

// Author: Huahua
class Solution {
public:
  vector<int> findThePrefixCommonArray(vector<int>& A, vector<int>& B) {
    vector<int> count(A.size() + 1);
    vector<int> ans;
    for (int i = 0, s = 0; i < A.size(); ++i) {
      if (++count[A[i]] == 2) ++s;
      if (++count[B[i]] == 2) ++s;
      ans.push_back(s);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2657. Find the Prefix Common Array of Two Arrays appeared first on Huahua's Tech Road.

Given an n x n integer matrix matrix, return true if the matrix is valid. Otherwise, return false.

Example 1:

Input: matrix = [[1,2,3],[3,1,2],[2,3,1]]
Output: true
Explanation: In this case, n = 3, and every row and column contains the numbers 1, 2, and 3.
Hence, we return true.

Example 2:

Input: matrix = [[1,1,1],[1,2,3],[1,2,3]]
Output: false
Explanation: In this case, n = 3, but the first row and the first column do not contain the numbers 2 or 3.
Hence, we return false.

Constraints:

• n == matrix.length == matrix[i].length
• 1 <= n <= 100
• 1 <= matrix[i][j] <= n

Solution: Bitset / hashtable

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

// Author: Huahua
class Solution {
public:
  bool checkValid(vector<vector<int>>& matrix) {
    const int n = matrix.size();
    for (int i = 0; i < n; ++i) {
      bitset<101> row;
      bitset<101> col;
      for (int j = 0; j < n; ++j)
        col[matrix[i][j]] = row[matrix[j][i]] = true;      
      if (row.count() != n || col.count() != n) 
        return false;
    }
    return true;
  }
};

The post 花花酱 LeetCode 2133. Check if Every Row and Column Contains All Numbers appeared first on Huahua's Tech Road.

Given a string text of words separated by a single space (no leading or trailing spaces) and a string brokenLetters of all distinct letter keys that are broken, return the number of words in text you can fully type using this keyboard.

Example 1:

Input: text = "hello world", brokenLetters = "ad"
Output: 1
Explanation: We cannot type "world" because the 'd' key is broken.

Example 2:

Input: text = "leet code", brokenLetters = "lt"
Output: 1
Explanation: We cannot type "leet" because the 'l' and 't' keys are broken.

Example 3:

Input: text = "leet code", brokenLetters = "e"
Output: 0
Explanation: We cannot type either word because the 'e' key is broken.

Constraints:

• 1 <= text.length <= 104
• 0 <= brokenLetters.length <= 26
• text consists of words separated by a single space without any leading or trailing spaces.
• Each word only consists of lowercase English letters.
• brokenLetters consists of distinct lowercase English letters.

Solution: Hashset / bitset

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

// Author: Huahua
class Solution {
public:
  int canBeTypedWords(string text, string brokenLetters) {
    const int n = text.size();
    
    bitset<26> b;
    for (char c : brokenLetters) b.set(c - 'a');
    
    int ans = 0;
    for (int i = 0, broken = 0; i <= n; ++i) {
      if (i == n || text[i] == ' ') {
        if (!broken) ++ans;
        broken = 0;
      } else {
        broken |= b[text[i] - 'a'];
      }
    }
    
    return ans;
  }
};

The post 花花酱 LeetCode 1935. Maximum Number of Words You Can Type appeared first on Huahua's Tech Road.

Note that even if there are multiple ways to obtain the same subsequence, it is still only counted once.

A palindrome is a string that reads the same forwards and backwards.

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

• For example, "ace" is a subsequence of "abcde".

Example 1:

Input: s = "aabca"
Output: 3
Explanation: The 3 palindromic subsequences of length 3 are:
- "aba" (subsequence of "aabca")
- "aaa" (subsequence of "aabca")
- "aca" (subsequence of "aabca")

Example 2:

Input: s = "adc"
Output: 0
Explanation: There are no palindromic subsequences of length 3 in "adc".

Example 3:

Input: s = "bbcbaba"
Output: 4
Explanation: The 4 palindromic subsequences of length 3 are:
- "bbb" (subsequence of "bbcbaba")
- "bcb" (subsequence of "bbcbaba")
- "bab" (subsequence of "bbcbaba")
- "aba" (subsequence of "bbcbaba")

Constraints:

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

Solution: Enumerate first character of a palindrome

For a length 3 palindrome, we just need to enumerate the first character c.
We found the first and last occurrence of c in original string and scan the middle part to see how many unique characters there.

e.g. aabca
Enumerate from a to z, looking for a*a, b*b, …, z*z.
For a*a, aabca, we found first and last a, in between is abc, which has 3 unique letters.
We can use a hastable or a bitset to track unique letters.

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

// Author: Huahua
class Solution {
public:
  int countPalindromicSubsequence(string s) {
    auto count = [&](char c) -> int {
      int l = s.find_first_of(c);
      int r = s.find_last_of(c);
      if (l == string::npos || r == string::npos) return 0;
      bitset<26> m;
      for (int i = l + 1; i < r; ++i)
        m.set(s[i] - 'a');
      return m.count();
    };
    int ans = 0;
    for (char c = 'a'; c <= 'z'; ++c)
      ans += count(c);
    return ans;
  }
};

The post 花花酱 LeetCode 1930. Unique Length-3 Palindromic Subsequences appeared first on Huahua's Tech Road.

• There are no duplicates.
• xi < yi

Let ways be the number of rooted trees that satisfy the following conditions:

• The tree consists of nodes whose values appeared in pairs.
• A pair [xi, yi] exists in pairs if and only if xi is an ancestor of yi or yi is an ancestor of xi.
• Note: the tree does not have to be a binary tree.

Two ways are considered to be different if there is at least one node that has different parents in both ways.

Return:

• 0 if ways == 0
• 1 if ways == 1
• 2 if ways > 1

A rooted tree is a tree that has a single root node, and all edges are oriented to be outgoing from the root.

An ancestor of a node is any node on the path from the root to that node (excluding the node itself). The root has no ancestors.

Example 1:

Input: pairs = [[1,2],[2,3]]
Output: 1
Explanation: There is exactly one valid rooted tree, which is shown in the above figure.

Example 2:

Input: pairs = [[1,2],[2,3],[1,3]]
Output: 2
Explanation: There are multiple valid rooted trees. Three of them are shown in the above figures.

Example 3:

Input: pairs = [[1,2],[2,3],[2,4],[1,5]]
Output: 0
Explanation: There are no valid rooted trees.

Constraints:

• 1 <= pairs.length <= 105
• 1 <= xi < yi <= 500
• The elements in pairs are unique.

Solution: Bitset

Time complexity: O(E*V)
Space complexity: O(V^2)

// Author: Huahua
class Solution {
public:
  int checkWays(vector<vector<int>>& pairs) {
    // Construct a map, key is the node, value is the accessible nodes.
    unordered_map<int, bitset<501>> m;
    for (auto& e : pairs) 
      m[e[0]][e[0]] = m[e[1]][e[1]] = m[e[0]][e[1]] = m[e[1]][e[0]] = 1;
    
    // The tree must have one+ node/root that has paths to all the nodes.
    if (!any_of(begin(m), end(m), [&m](const auto& kv) {
      return kv.second.count() == m.size();})) return 0;
    
    int multiple = 0;
    for (const auto& e : pairs) {
      // For each pair, check whether one can be the parent of another
      // that can conver all the children nodes.
      const auto& all = m[e[0]] | m[e[1]];
      const int r0 = m[e[0]] == all;
      const int r1 = m[e[1]] == all;
      if (r0 + r1 == 0) return 0;
      // If both can be parents, there can be multiple trees.
      multiple |= r0 * r1;
    }
    return 1 + multiple;
  }
};

# Author: Huahua
class Solution:
  def checkWays(self, pairs: List[List[int]]) -> int:
    m = defaultdict(set)
    for u, v in pairs:
      m[u] |= set((u, v))
      m[v] |= set((u, v))
    
    if not any(len(m[x]) == len(m) for x in m):
      return 0
    
    multiple = 0
    for u, v in pairs:
      union = m[u] | m[v]
      ru, rv = int(m[u] == union), int(m[v] == union)
      if not ru + rv: return 0
      multiple |= ru * rv
    return 1 + multiple

The post 花花酱 LeetCode 1719. Number Of Ways To Reconstruct A Tree appeared first on Huahua's Tech Road.

Given an integer array with even length, where different numbers in this array represent different kinds of candies. Each number means one candy of the corresponding kind. You need to distribute these candies equally in number to brother and sister. Return the maximum number of kinds of candies the sister could gain.

Example 1:

Input: candies = [1,1,2,2,3,3]
Output: 3
Explanation:
There are three different kinds of candies (1, 2 and 3), and two candies for each kind.
Optimal distribution: The sister has candies [1,2,3] and the brother has candies [1,2,3], too. 
The sister has three different kinds of candies.

Example 2:

Input: candies = [1,1,2,3]
Output: 2
Explanation: For example, the sister has candies [2,3] and the brother has candies [1,1]. 
The sister has two different kinds of candies, the brother has only one kind of candies.

Note:

1. The length of the given array is in range [2, 10,000], and will be even.
2. The number in given array is in range [-100,000, 100,000].

Solution 1: Greedy

Give all unique candies to sisters until they have n/2 candies.

Time complexity: O(n)

Space complexity: O(n)

C++ Hashset

// Author: Huahua
// Running time: 258 ms
class Solution {
public:
  int distributeCandies(vector<int>& candies) {
    unordered_set<int> kinds(candies.begin(), candies.end());
    return min(kinds.size(), candies.size() / 2);
  }
};

C++ Bitset

// Author: Huahua
// Running time: 195 ms (beats 97.61%)
class Solution {
public:
  int distributeCandies(vector<int>& candies) {
    constexpr int kMaxKinds = 200001;
    constexpr int kOffset = 100000;
    bitset<kMaxKinds> s;    
    for (int candy : candies)
      if (!s.test(candy + kOffset))
          s.set(candy + kOffset);
    return std::min(s.count(), candies.size() / 2);
  }
};

The post 花花酱 LeetCode 575. Distribute Candies appeared first on Huahua's Tech Road.