We say s1[i] and s2[i] are equivalent characters.

• For example, if s1 = "abc" and s2 = "cde", then we have 'a' == 'c', 'b' == 'd', and 'c' == 'e'.

Equivalent characters follow the usual rules of any equivalence relation:

• Reflexivity: 'a' == 'a'.
• Symmetry: 'a' == 'b' implies 'b' == 'a'.
• Transitivity: 'a' == 'b' and 'b' == 'c' implies 'a' == 'c'.

For example, given the equivalency information from s1 = "abc" and s2 = "cde", "acd" and "aab" are equivalent strings of baseStr = "eed", and "aab" is the lexicographically smallest equivalent string of baseStr.

Return the lexicographically smallest equivalent string of baseStr by using the equivalency information from s1 and s2.

Example 1:

Input: s1 = "parker", s2 = "morris", baseStr = "parser"
Output: "makkek"
Explanation: Based on the equivalency information in s1 and s2, we can group their characters as [m,p], [a,o], [k,r,s], [e,i].
The characters in each group are equivalent and sorted in lexicographical order.
So the answer is "makkek".

Example 2:

Input: s1 = "hello", s2 = "world", baseStr = "hold"
Output: "hdld"
Explanation: Based on the equivalency information in s1 and s2, we can group their characters as [h,w], [d,e,o], [l,r].
So only the second letter 'o' in baseStr is changed to 'd', the answer is "hdld".

Example 3:

<strong>Input:</strong> s1 = "leetcode", s2 = "programs", baseStr = "sourcecode"
<strong>Output:</strong> "aauaaaaada"
<strong>Explanation:</strong> We group the equivalent characters in s1 and s2 as [a,o,e,r,s,c], [l,p], [g,t] and [d,m], thus all letters in baseStr except 'u' and 'd' are transformed to 'a', the answer is "aauaaaaada".

Constraints:

• 1 <= s1.length, s2.length, baseStr <= 1000
• s1.length == s2.length
• s1, s2, and baseStr consist of lowercase English letters.

Solution: Union Find

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

// Author: Huahua
class Solution {
public:
  string smallestEquivalentString(string s1, string s2, string baseStr) {
    vector<int> p(26);
    iota(begin(p), end(p), 0);
    function<int(int)> find = [&](int x) {
      return p[x] == x ? x : p[x] = find(p[x]);
    };
    for (int i = 0; i < s1.length(); ++i) {
      int r1 = find(s1[i] - 'a');
      int r2 = find(s2[i] - 'a');
      if (r2 < r1) swap(r1, r2);
      p[r2] = r1;
    }
    
    string ans(baseStr);
    for (int i = 0; i < baseStr.length(); ++i) {
      ans[i] = find(baseStr[i] - 'a') + 'a';
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1061. Lexicographically Smallest Equivalent String appeared first on Huahua's Tech Road.

You are given an integer n. There is an undirected graph with n nodes, numbered from 0 to n - 1. You are given a 2D integer array edges where edges[i] = [ai, bi] denotes that there exists an undirected edge connecting nodes ai and bi.

Return the number of pairs of different nodes that are unreachable from each other.

Example 1:

Input: n = 3, edges = [[0,1],[0,2],[1,2]]
Output: 0
Explanation: There are no pairs of nodes that are unreachable from each other. Therefore, we return 0.

Example 2:

Input: n = 7, edges = [[0,2],[0,5],[2,4],[1,6],[5,4]]
Output: 14
Explanation: There are 14 pairs of nodes that are unreachable from each other:
[[0,1],[0,3],[0,6],[1,2],[1,3],[1,4],[1,5],[2,3],[2,6],[3,4],[3,5],[3,6],[4,6],[5,6]].
Therefore, we return 14.

Constraints:

• 1 <= n <= 105
• 0 <= edges.length <= 2 * 105
• edges[i].length == 2
• 0 <= ai, bi < n
• ai != bi
• There are no repeated edges.

Solution 1: DFS

Use DFS to find all CCs

Time complexity: O(V+E)
Space complexity: O(V+E)

// Author: Huahua
// Author: Huahua, 791ms, 136 MB
class Solution {
public:
  long long countPairs(int n, vector<vector<int>>& edges) {
    vector<vector<int>> g(n);
    for (const auto& e : edges) {
      g[e[0]].push_back(e[1]);
      g[e[1]].push_back(e[0]);
    }
    vector<int> seen(n);
    long long cur = 0;
    
    function<void(int)> dfs = [&](int u) {
      ++cur;
      for (int v : g[u])
        if (seen[v]++ == 0) dfs(v);      
    };
    long long ans = 0;    
    for (int i = 0; i < n; ++i) {
      if (seen[i]++) continue;
      cur = 0;
      dfs(i);
      ans += (n - cur) * cur;
    }
    return ans / 2;
  }
};

Solution 2: Union Find

Time complexity: O(V+E)
Space complexity: O(V)

// Author: Huahua
class Solution {
public:
  long long countPairs(int n, vector<vector<int>>& edges) {
    vector<int> parents(n);
    vector<int> counts(n, 1);
    std::iota(begin(parents), end(parents), 0);
    
    function<int(int)> find = [&](int x) {
      if (parents[x] == x) return x;
      return parents[x] = find(parents[x]);
    };
    
    for (const auto& e : edges) {
      int ru = find(e[0]);
      int rv = find(e[1]);
      if (ru != rv) {
        parents[rv] = ru;
        counts[ru] += counts[rv];        
      }
    }
    long long ans = 0;    
    for (int i = 0; i < n; ++i)      
      ans += n - counts[find(i)];
    return ans / 2;
  }
};

The post 花花酱 LeetCode 2316. Count Unreachable Pairs of Nodes in an Undirected Graph appeared first on Huahua's Tech Road.

Two strings s1 and s2 are said to be connected if the set of letters of s2 can be obtained from the set of letters of s1 by any one of the following operations:

• Adding exactly one letter to the set of the letters of s1.
• Deleting exactly one letter from the set of the letters of s1.
• Replacing exactly one letter from the set of the letters of s1 with any letter, including itself.

The array words can be divided into one or more non-intersecting groups. A string belongs to a group if any one of the following is true:

• It is connected to at least one other string of the group.
• It is the only string present in the group.

Note that the strings in words should be grouped in such a manner that a string belonging to a group cannot be connected to a string present in any other group. It can be proved that such an arrangement is always unique.

Return an array ans of size 2 where:

• ans[0] is the total number of groups words can be divided into, and
• ans[1] is the size of the largest group.

Example 1:

Input: words = ["a","b","ab","cde"]
Output: [2,3]
Explanation:
- words[0] can be used to obtain words[1] (by replacing 'a' with 'b'), and words[2] (by adding 'b'). So words[0] is connected to words[1] and words[2].
- words[1] can be used to obtain words[0] (by replacing 'b' with 'a'), and words[2] (by adding 'a'). So words[1] is connected to words[0] and words[2].
- words[2] can be used to obtain words[0] (by deleting 'b'), and words[1] (by deleting 'a'). So words[2] is connected to words[0] and words[1].
- words[3] is not connected to any string in words.
Thus, words can be divided into 2 groups ["a","b","ab"] and ["cde"]. The size of the largest group is 3.  

Example 2:

Input: words = ["a","ab","abc"]
Output: [1,3]
Explanation:
- words[0] is connected to words[1].
- words[1] is connected to words[0] and words[2].
- words[2] is connected to words[1].
Since all strings are connected to each other, they should be grouped together.
Thus, the size of the largest group is 3.

Constraints:

• 1 <= words.length <= 2 * 104
• 1 <= words[i].length <= 26
• words[i] consists of lowercase English letters only.
• No letter occurs more than once in words[i].

Solution: Bitmask + DFS

Use a bitmask to represent a string. Use dfs to find connected components.

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

// Author: Huahua
class Solution {
public:
  vector<int> groupStrings(vector<string>& words) {
    unordered_map<int, int> m;
    for (const string& w : words)
      ++m[accumulate(begin(w), end(w), 0, [](int k, char c){ return k | (1 << (c - 'a')); })];
    function<int(int)> dfs = [&](int mask) {
      auto it = m.find(mask);
      if (it == end(m)) return 0;
      int ans = it->second;      
      m.erase(it);
      for (int i = 0; i < 26; ++i) {        
        ans += dfs(mask ^ (1 << i));
        for (int j = i + 1; j < 26; ++j)
          if ((mask >> i & 1) != (mask >> j & 1))
            ans += dfs(mask ^ (1 << i) ^ (1 << j));
      }
      return ans;
    };
    int size = 0;
    int groups = 0;
    while (!m.empty()) {
      size = max(size, dfs(begin(m)->first));
      ++groups;
    }
    return {groups, size};
  }
};

The post 花花酱 LeetCode 2157. Groups of Strings appeared first on Huahua's Tech Road.

• Swap the positions of two elements nums[i] and nums[j] if gcd(nums[i], nums[j]) > 1 where gcd(nums[i], nums[j]) is the greatest common divisor of nums[i] and nums[j].

Return true if it is possible to sort nums in non-decreasing order using the above swap method, or false otherwise.

Example 1:

Input: nums = [7,21,3]
Output: true
Explanation: We can sort [7,21,3] by performing the following operations:
- Swap 7 and 21 because gcd(7,21) = 7. nums = [21,7,3]
- Swap 21 and 3 because gcd(21,3) = 3. nums = [3,7,21]

Example 2:

Input: nums = [5,2,6,2]
Output: false
Explanation: It is impossible to sort the array because 5 cannot be swapped with any other element.

Example 3:

Input: nums = [10,5,9,3,15]
Output: true
We can sort [10,5,9,3,15] by performing the following operations:
- Swap 10 and 15 because gcd(10,15) = 5. nums = [15,5,9,3,10]
- Swap 15 and 3 because gcd(15,3) = 3. nums = [3,5,9,15,10]
- Swap 10 and 15 because gcd(10,15) = 5. nums = [3,5,9,10,15]

Constraints:

• 1 <= nums.length <= 3 * 104
• 2 <= nums[i] <= 105

Solution: Union-Find

Let nums[j]’s target position be i. In order to put nums[j] to pos i by swapping. nums[i] and nums[j] must be in the same connected component. There is an edge between two numbers if they have gcd > 1.

We union two numbers if their have gcd > 1. However, it will be TLE if we do all pairs . Thus, for each number, we union it with its divisors instead.

Time complexity: O(n²) TLE -> O(sum(sqrt(nums[i]))) <= O(n*sqrt(m))
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  bool gcdSort(vector<int>& nums) {
    const int m = *max_element(begin(nums), end(nums));
    const int n = nums.size();
    
    vector<int> p(m + 1);
    iota(begin(p), end(p), 0);
  
    function<int(int)> find = [&](int x) {
      return p[x] == x ? x : (p[x] = find(p[x]));
    };
  
    for (int x : nums)
      for (int d = 2; d <= sqrt(x); ++d)
        if (x % d == 0)
          p[find(x)] = p[find(x / d)] = find(d);

    vector<int> sorted(nums);
    sort(begin(sorted), end(sorted));
    
    for (int i = 0; i < n; ++i)
      if (find(sorted[i]) != find(nums[i])) 
        return false;

    return true;
  }
};

The post 花花酱 LeetCode 1998. GCD Sort of an Array appeared first on Huahua's Tech Road.

Person 0 has a secret and initially shares the secret with a person firstPerson at time 0. This secret is then shared every time a meeting takes place with a person that has the secret. More formally, for every meeting, if a person xi has the secret at timei, then they will share the secret with person yi, and vice versa.

The secrets are shared instantaneously. That is, a person may receive the secret and share it with people in other meetings within the same time frame.

Return a list of all the people that have the secret after all the meetings have taken place. You may return the answer in any order.

Example 1:

Input: n = 6, meetings = [[1,2,5],[2,3,8],[1,5,10]], firstPerson = 1
Output: [0,1,2,3,5]
Explanation:
At time 0, person 0 shares the secret with person 1.
At time 5, person 1 shares the secret with person 2.
At time 8, person 2 shares the secret with person 3.
At time 10, person 1 shares the secret with person 5.​​​​
Thus, people 0, 1, 2, 3, and 5 know the secret after all the meetings.

Example 2:

Input: n = 4, meetings = [[3,1,3],[1,2,2],[0,3,3]], firstPerson = 3
Output: [0,1,3]
Explanation:
At time 0, person 0 shares the secret with person 3.
At time 2, neither person 1 nor person 2 know the secret.
At time 3, person 3 shares the secret with person 0 and person 1.
Thus, people 0, 1, and 3 know the secret after all the meetings.

Example 3:

Input: n = 5, meetings = [[3,4,2],[1,2,1],[2,3,1]], firstPerson = 1
Output: [0,1,2,3,4]
Explanation:
At time 0, person 0 shares the secret with person 1.
At time 1, person 1 shares the secret with person 2, and person 2 shares the secret with person 3.
Note that person 2 can share the secret at the same time as receiving it.
At time 2, person 3 shares the secret with person 4.
Thus, people 0, 1, 2, 3, and 4 know the secret after all the meetings.

Example 4:

Input: n = 6, meetings = [[0,2,1],[1,3,1],[4,5,1]], firstPerson = 1
Output: [0,1,2,3]
Explanation:
At time 0, person 0 shares the secret with person 1.
At time 1, person 0 shares the secret with person 2, and person 1 shares the secret with person 3.
Thus, people 0, 1, 2, and 3 know the secret after all the meetings.

Constraints:

• 2 <= n <= 105
• 1 <= meetings.length <= 105
• meetings[i].length == 3
• 0 <= xi, yi <= n - 1
• xi != yi
• 1 <= timei <= 105
• 1 <= firstPerson <= n - 1

Solution: Union Find

Sorting meetings by time.

At each time stamp, union people who meet.
Key step: “un-union” people if they DO NOT connected to 0 / known the secret after each timestamp.

Time complexity: O(nlogn + m + n)
Space complexity: O(m + n)

// Author: Huahua
class Solution {
public:
  vector<int> findAllPeople(int n, vector<vector<int>>& meetings, int firstPerson) {        
    map<int, vector<pair<int, int>>> events;
    for (const auto& m : meetings)
      events[m[2]].emplace_back(m[0], m[1]);
    vector<int> p(n);
    iota(begin(p), end(p), 0);
    function<int(int)> find = [&](int x) {
      return p[x] == x ? x : (p[x] = find(p[x]));
    };
    p[firstPerson] = 0;
    for (const auto& [t, s] : events) {
      for (const auto [u, v] : s)
        p[find(u)] = find(v);
      for (const auto [u, v] : s) {
        if (find(u) != find(0)) p[u] = u;
        if (find(v) != find(0)) p[v] = v;
      }
    }    
    vector<int> ans;
    for (int i = 0; i < n; ++i)
      if (find(i) == find(0)) ans.push_back(i);
    return ans;
  }
};

Related Problems

• 花花酱 LeetCode 1202. Smallest String With Swaps
• 花花酱 LeetCode 1489. Find Critical and Pseudo-Critical Edges in Minimum Spanning Tree
• 花花酱 LeetCode 2076. Process Restricted Friend Requests
• 花花酱 LeetCode 1722. Minimize Hamming Distance After Swap Operations
• 花花酱 LeetCode Disjoint set / Union Find Forest SP1

The post 花花酱 LeetCode 2092. Find All People With Secret appeared first on Huahua's Tech Road.

You are also given a 0-indexed 2D integer array restrictions, where restrictions[i] = [xi, yi] means that person xi and person yi cannot become friends,either directly or indirectly through other people.

Initially, no one is friends with each other. You are given a list of friend requests as a 0-indexed 2D integer array requests, where requests[j] = [uj, vj] is a friend request between person uj and person vj.

A friend request is successful if uj and vj can be friends. Each friend request is processed in the given order (i.e., requests[j] occurs before requests[j + 1]), and upon a successful request, uj and vj become direct friends for all future friend requests.

Return a boolean array result, where each result[j] is true if the jth friend request is successful or false if it is not.

Note: If uj and vj are already direct friends, the request is still successful.

Example 1:

Input: n = 3, restrictions = [[0,1]], requests = [[0,2],[2,1]]
Output: [true,false]
Explanation:
Request 0: Person 0 and person 2 can be friends, so they become direct friends. 
Request 1: Person 2 and person 1 cannot be friends since person 0 and person 1 would be indirect friends (1--2--0).

Example 2:

Input: n = 3, restrictions = [[0,1]], requests = [[1,2],[0,2]]
Output: [true,false]
Explanation:
Request 0: Person 1 and person 2 can be friends, so they become direct friends.
Request 1: Person 0 and person 2 cannot be friends since person 0 and person 1 would be indirect friends (0--2--1).

Example 3:

Input: n = 5, restrictions = [[0,1],[1,2],[2,3]], requests = [[0,4],[1,2],[3,1],[3,4]]
Output: [true,false,true,false]
Explanation:
Request 0: Person 0 and person 4 can be friends, so they become direct friends.
Request 1: Person 1 and person 2 cannot be friends since they are directly restricted.
Request 2: Person 3 and person 1 can be friends, so they become direct friends.
Request 3: Person 3 and person 4 cannot be friends since person 0 and person 1 would be indirect friends (0--4--3--1).

Constraints:

• 2 <= n <= 1000
• 0 <= restrictions.length <= 1000
• restrictions[i].length == 2
• 0 <= xi, yi <= n - 1
• xi != yi
• 1 <= requests.length <= 1000
• requests[j].length == 2
• 0 <= uj, vj <= n - 1
• uj != vj

Solution: Union Find / Brute Force

For each request, check all restrictions.

Time complexity: O(req * res)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  vector<bool> friendRequests(int n, vector<vector<int>>& restrictions, vector<vector<int>>& requests) {
    vector<int> parents(n);
    iota(begin(parents), end(parents), 0);
    function<int(int)> find = [&](int x) {
      if (parents[x] == x) return x;
      return parents[x] = find(parents[x]);
    };
    auto check = [&](int u, int v) {
      for (const auto& r : restrictions) {
        int pu = find(r[0]);
        int pv = find(r[1]);
        if ((pu == u && pv == v) || (pu == v && pv == u))
          return false;
      }
      return true;
    };
    vector<bool> ans;
    for (const auto& r : requests) {      
      int pu = find(r[0]);
      int pv = find(r[1]);
      if (pu == pv || check(pu, pv)) {
        parents[pu] = pv;
        ans.push_back(true);
      } else {
        ans.push_back(false);
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2076. Process Restricted Friend Requests appeared first on Huahua's Tech Road.

Given an array queries, where queries[j] = [pj, qj, limitj], your task is to determine for each queries[j] whether there is a path between pj and qjsuch that each edge on the path has a distance strictly less than limitj .

Return a boolean array answer, where answer.length == queries.length and the jth value of answer is true if there is a path for queries[j] is true, and false otherwise.

Example 1:

Input: n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]], queries = [[0,1,2],[0,2,5]]
Output: [false,true]
Explanation: The above figure shows the given graph. Note that there are two overlapping edges between 0 and 1 with distances 2 and 16.
For the first query, between 0 and 1 there is no path where each distance is less than 2, thus we return false for this query.
For the second query, there is a path (0 -> 1 -> 2) of two edges with distances less than 5, thus we return true for this query.

Example 2:

Input: n = 5, edgeList = [[0,1,10],[1,2,5],[2,3,9],[3,4,13]], queries = [[0,4,14],[1,4,13]]
Output: [true,false]
Exaplanation: The above figure shows the given graph.

Constraints:

• 2 <= n <= 105
• 1 <= edgeList.length, queries.length <= 105
• edgeList[i].length == 3
• queries[j].length == 3
• 0 <= ui, vi, pj, qj <= n - 1
• ui != vi
• pj != qj
• 1 <= disi, limitj <= 109
• There may be multiple edges between two nodes.

Solution: Union Find

Since queries are offline, we can reorder them to optimize time complexity. Answer queries by their limits in ascending order while union edges by weights up to the limit. In this case, we just need to go through the entire edge list at most once.

Time complexity: O(QlogQ + ElogE)
Space complexity: O(Q + E)

// Author: Huahua
class Solution {
public:
  vector<bool> distanceLimitedPathsExist(int n, vector<vector<int>>& E, vector<vector<int>>& Q) {
    vector<int> parents(n);
    iota(begin(parents), end(parents), 0);
    function<int(int)> find = [&](int x) {
      return parents[x] == x ? x : parents[x] = find(parents[x]);
    };
    const int m = Q.size();
    for (int i = 0; i < m; ++i) Q[i].push_back(i);
    // Sort edges by weight in ascending order.
    sort(begin(E), end(E), [](const auto& a, const auto& b) { return a[2] < b[2]; });
    // Sort queries by limit in ascending order
    sort(begin(Q), end(Q), [](const auto& a, const auto& b) { return a[2] < b[2]; });
    vector<bool> ans(m);
    int i = 0;
    for (const auto& q : Q) {      
      while (i < E.size() && E[i][2] < q[2])
        parents[find(E[i++][0])] = find(E[i][1]);        
      ans[q[3]] = find(q[0]) == find(q[1]);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1697. Checking Existence of Edge Length Limited Paths appeared first on Huahua's Tech Road.

The rank is an integer that represents how large an element is compared to other elements. It is calculated using the following rules:

• The rank is an integer starting from 1.
• If two elements p and q are in the same row or column, then:
  • If p < q then rank(p) < rank(q)
  • If p == q then rank(p) == rank(q)
  • If p > q then rank(p) > rank(q)
• The rank should be as small as possible.

It is guaranteed that answer is unique under the given rules.

Example 1:

Input: matrix = [[1,2],[3,4]]
Output: [[1,2],[2,3]]
Explanation:
The rank of matrix[0][0] is 1 because it is the smallest integer in its row and column.
The rank of matrix[0][1] is 2 because matrix[0][1] > matrix[0][0] and matrix[0][0] is rank 1.
The rank of matrix[1][0] is 2 because matrix[1][0] > matrix[0][0] and matrix[0][0] is rank 1.
The rank of matrix[1][1] is 3 because matrix[1][1] > matrix[0][1], matrix[1][1] > matrix[1][0], and both matrix[0][1] and matrix[1][0] are rank 2.

Example 2:

Input: matrix = [[7,7],[7,7]]
Output: [[1,1],[1,1]]

Example 3:

Input: matrix = [[20,-21,14],[-19,4,19],[22,-47,24],[-19,4,19]]
Output: [[4,2,3],[1,3,4],[5,1,6],[1,3,4]]

Example 4:

Input: matrix = [[7,3,6],[1,4,5],[9,8,2]]
Output: [[5,1,4],[1,2,3],[6,3,1]]

Constraints:

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 500
• -109 <= matrix[row][col] <= 109

Solution: Union Find

Group cells by their values, process groups (cells that have the same value) in ascending order (smaller number has smaller rank).

For cells that are in the same row and same cols union them using union find, they should have the same rank which equals to max(max_rank_x[cols], max_rank_y[rows]) + 1.

Time complexity: O(m*n*(m+n))
Space complexity: O(m*n)

// Author: Huahua
class DSU {
public:
  DSU(int n): p_(n, -1) {}
  int find(int x) {
    return p_[x] == -1 ? x : p_[x] = find(p_[x]);
  }  
  void merge(int x, int y) {
    x = find(x), y = find(y);
    if (x != y) p_[x] = y;    
  }
private:
  vector<int> p_;
};

class Solution {
public:
  vector<vector<int>> matrixRankTransform(vector<vector<int>>& matrix) {
    const int m = matrix.size();
    const int n = matrix[0].size();
    vector<vector<int>> ans(m, vector<int>(n));
    map<int, vector<pair<int, int>>> mp; // val -> {positions}
    for (int y = 0; y < m; ++y)
      for (int x = 0; x < n; ++x)
        mp[matrix[y][x]].emplace_back(x, y);
    vector<int> rx(n), ry(m);
    for (const auto& [val, ps]: mp) {
      DSU dsu(n + m);
      vector<vector<pair<int, int>>> cc(n + m); // val -> {positions}
      for (const auto& [x, y]: ps)
        dsu.merge(x, y + n);
      for (const auto& [x, y]: ps)        
        cc[dsu.find(x)].emplace_back(x, y);      
      for (const auto& ps: cc) {
        int rank = 1;
        for (const auto& [x, y]: ps)
          rank = max(rank, max(rx[x], ry[y]) + 1);
        for (const auto& [x, y]: ps)
          rx[x] = ry[y] = ans[y][x] = rank;   
      }      
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1632. Rank Transform of a Matrix appeared first on Huahua's Tech Road.

• x % z == 0,
• y % z == 0, and
• z > threshold.

Given the two integers, n and threshold, and an array of queries, you must determine for each queries[i] = [ai, bi] if cities ai and bi are connected (i.e. there is some path between them).

Return an array answer, where answer.length == queries.length and answer[i] is true if for the ith query, there is a path between ai and bi, or answer[i] is false if there is no path.

Example 1:

Input: n = 6, threshold = 2, queries = [[1,4],[2,5],[3,6]]
Output: [false,false,true]
Explanation: The divisors for each number:
1:   1
2:   1, 2
3:   1, 3
4:   1, 2, 4
5:   1, 5
6:   1, 2, 3, 6
Using the underlined divisors above the threshold, only cities 3 and 6 share a common divisor, so they are the
only ones directly connected. The result of each query:
[1,4]   1 is not connected to 4
[2,5]   2 is not connected to 5
[3,6]   3 is connected to 6 through path 3--6

Example 2:

Input: n = 6, threshold = 0, queries = [[4,5],[3,4],[3,2],[2,6],[1,3]]
Output: [true,true,true,true,true]
Explanation: The divisors for each number are the same as the previous example. However, since the threshold is 0,
all divisors can be used. Since all numbers share 1 as a divisor, all cities are connected.

Example 3:

Input: n = 5, threshold = 1, queries = [[4,5],[4,5],[3,2],[2,3],[3,4]]
Output: [false,false,false,false,false]
Explanation: Only cities 2 and 4 share a common divisor 2 which is strictly greater than the threshold 1, so they are the only ones directly connected.
Please notice that there can be multiple queries for the same pair of nodes [x, y], and that the query [x, y] is equivalent to the query [y, x].

Constraints:

• 2 <= n <= 104
• 0 <= threshold <= n
• 1 <= queries.length <= 105
• queries[i].length == 2
• 1 <= ai, bi <= cities
• ai != bi

Solution: Union Find

For x, merge 2x, 3x, 4x, ..,
If a number is already “merged”, skip it.

Time complexity: O(nlogn? + queries)?
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  vector<bool> areConnected(int n, int threshold, vector<vector<int>>& queries) {
    if (threshold == 0) return vector<bool>(queries.size(), true);
    
    vector<int> ds(n + 1);
    iota(begin(ds), end(ds), 0);
    function<int(int)> find = [&](int x) {
      return ds[x] == x ? x : ds[x] = find(ds[x]);
    };
    
    for (int x = threshold + 1; x <= n; ++x)
      if (ds[x] == x)
        for (int y = 2 * x; y <= n; y += x)    
          ds[max(find(x), find(y))] = min(find(x), find(y));
    
    vector<bool> ans;
    for (const vector<int>& q : queries)
      ans.push_back(find(q[0]) == find(q[1]));    
    return ans;
  }
};

# Author: Huahua
class Solution:
  def areConnected(self, n: int, threshold: int, 
                   queries: List[List[int]]) -> List[bool]:
    if threshold == 0: return [True] * len(queries)
    
    ds = list(range(n + 1))
    def find(x: int) -> int:
      if x != ds[x]: ds[x] = find(ds[x])
      return ds[x]

    for x in range(threshold + 1, n + 1):
      if ds[x] == x:
        for y in range(2 * x, n + 1, x):
          ds[max(find(x), find(y))] = min(find(x), find(y))

    return [find(x) == find(y) for x, y in queries]

The post 花花酱 LeetCode 1627. Graph Connectivity With Threshold appeared first on Huahua's Tech Road.

Alice and Bob have an undirected graph of n nodes and 3 types of edges:

• Type 1: Can be traversed by Alice only.
• Type 2: Can be traversed by Bob only.
• Type 3: Can by traversed by both Alice and Bob.

Given an array edges where edges[i] = [typei, ui, vi] represents a bidirectional edge of type typei between nodes ui and vi, find the maximum number of edges you can remove so that after removing the edges, the graph can still be fully traversed by both Alice and Bob. The graph is fully traversed by Alice and Bob if starting from any node, they can reach all other nodes.

Return the maximum number of edges you can remove, or return -1 if it’s impossible for the graph to be fully traversed by Alice and Bob.

Example 1:

Input: n = 4, edges = [[3,1,2],[3,2,3],[1,1,3],[1,2,4],[1,1,2],[2,3,4]]
Output: 2
Explanation: If we remove the 2 edges [1,1,2] and [1,1,3]. The graph will still be fully traversable by Alice and Bob. Removing any additional edge will not make it so. So the maximum number of edges we can remove is 2.

Example 2:

Input: n = 4, edges = [[3,1,2],[3,2,3],[1,1,4],[2,1,4]]
Output: 0
Explanation: Notice that removing any edge will not make the graph fully traversable by Alice and Bob.

Example 3:

Input: n = 4, edges = [[3,2,3],[1,1,2],[2,3,4]]
Output: -1
Explanation: In the current graph, Alice cannot reach node 4 from the other nodes. Likewise, Bob cannot reach 1. Therefore it's impossible to make the graph fully traversable.

Constraints:

• 1 <= n <= 10^5
• 1 <= edges.length <= min(10^5, 3 * n * (n-1) / 2)
• edges[i].length == 3
• 1 <= edges[i][0] <= 3
• 1 <= edges[i][1] < edges[i][2] <= n
• All tuples (typei, ui, vi) are distinct.

Solution: Greedy + Spanning Tree / Union Find

Use type 3 (both) edges first.

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

class DSU {
public: 
  DSU(int n): p_(n + 1), e_(0) {
    iota(begin(p_), end(p_), 0);
  }
  
  int find(int x) {
    if (p_[x] == x) return x;
    return p_[x] = find(p_[x]);    
  }
  
  int merge(int x, int y) {
    int rx = find(x);
    int ry = find(y);
    if (rx == ry) return 1;
    p_[rx] = ry;
    ++e_;
    return 0;
  }  
  
  int edges() const { return e_; }
private:
  vector<int> p_;
  int e_;
};

class Solution {
public:
  int maxNumEdgesToRemove(int n, vector<vector<int>>& edges) {
    int ans = 0;
    DSU A(n), B(n);
    for (const auto& e: edges) {
      if (e[0] != 3) continue;
      ans += A.merge(e[1], e[2]);
      B.merge(e[1], e[2]);
    }
    for (const auto& e: edges) {
      if (e[0] == 3) continue;
      DSU& d = e[0] == 1 ? A : B;
      ans += d.merge(e[1], e[2]);
    }
    return (A.edges() == n - 1 && B.edges() == n - 1) ? ans : -1;
  }
};

class DSU:
  def __init__(self, n: int):
    self.p = list(range(n))
    self.e = 0
    
  def find(self, x: int) -> int:
    if x != self.p[x]: self.p[x] = self.find(self.p[x])
    return self.p[x]
  
  def merge(self, x: int, y: int) -> int:
    rx, ry = self.find(x), self.find(y)
    if rx == ry: return 1
    self.p[rx] = ry
    self.e += 1
    return 0
  
class Solution:
  def maxNumEdgesToRemove(self, n: int, edges: List[List[int]]) -> int:
    A, B = DSU(n + 1), DSU(n + 1)    
    ans = 0
    for t, x, y in edges:
      if t != 3: continue
      ans += A.merge(x, y)
      B.merge(x, y)
    for t, x, y in edges:
      if t == 3: continue
      d = A if t == 1 else B
      ans += d.merge(x, y)
    return ans if A.e == B.e == n - 1 else -1

The post 花花酱 LeetCode 1579. Remove Max Number of Edges to Keep Graph Fully Traversable appeared first on Huahua's Tech Road.

Given a weighted undirected connected graph with n vertices numbered from 0 to n-1, and an array edges where edges[i] = [fromi, toi, weighti] represents a bidirectional and weighted edge between nodes fromi and toi. A minimum spanning tree (MST) is a subset of the edges of the graph that connects all vertices without cycles and with the minimum possible total edge weight.

Find all the critical and pseudo-critical edges in the minimum spanning tree (MST) of the given graph. An MST edge whose deletion from the graph would cause the MST weight to increase is called a critical edge. A pseudo-critical edge, on the other hand, is that which can appear in some MSTs but not all.

Note that you can return the indices of the edges in any order.

Example 1:

Input: n = 5, edges = [[0,1,1],[1,2,1],[2,3,2],[0,3,2],[0,4,3],[3,4,3],[1,4,6]]
Output: [[0,1],[2,3,4,5]]
Explanation: The figure above describes the graph.
The following figure shows all the possible MSTs:

Notice that the two edges 0 and 1 appear in all MSTs, therefore they are critical edges, so we return them in the first list of the output.
The edges 2, 3, 4, and 5 are only part of some MSTs, therefore they are considered pseudo-critical edges. We add them to the second list of the output.

Example 2:

Input: n = 4, edges = [[0,1,1],[1,2,1],[2,3,1],[0,3,1]]
Output: [[],[0,1,2,3]]
Explanation: We can observe that since all 4 edges have equal weight, choosing any 3 edges from the given 4 will yield an MST. Therefore all 4 edges are pseudo-critical.

Constraints:

• 2 <= n <= 100
• 1 <= edges.length <= min(200, n * (n - 1) / 2)
• edges[i].length == 3
• 0 <= fromi < toi < n
• 1 <= weighti <= 1000
• All pairs (fromi, toi) are distinct.

Solution: Brute Force?

For each edge
1. exclude it and build a MST, cost increased => critical
2. for a non critical edge, force include it and build a MST, cost remains the same => pseudo critical

Proof of 2, if a non critical / non pseudo critical edge was added into the MST, the total cost must be increased. So if the cost remains the same, must be the other case. Since we know the edge is non-critical, so it has to be pseudo critical.

// Author: Huahua
class UnionFind {
 public:
  explicit UnionFind(int n): p_(n), r_(n) { iota(begin(p_), end(p_), 0); } // e.g. p[i] = i
  int Find(int x) { return p_[x] == x ? x : p_[x] = Find(p_[x]); }
  bool Union(int x, int y) {
    int rx = Find(x);
    int ry = Find(y);
    if (rx == ry) return false;
    if (r_[rx] == r_[ry]) {
      p_[rx] = ry;
      ++r_[ry];
    } else if (r_[rx] > r_[ry]) {
      p_[ry] = rx;
    } else {
      p_[rx] = ry;
    }    
    return true;
  }
 private:
  vector<int> p_, r_;  
};

class Solution {
public:
  vector<vector<int>> findCriticalAndPseudoCriticalEdges(int n, vector<vector<int>>& edges) {
    // Record the original id.
    for (int i = 0; i < edges.size(); ++i) edges[i].push_back(i);
    // Sort edges by weight.
    sort(begin(edges), end(edges), [&](const auto& e1, const auto& e2){
      if (e1[2] != e2[2]) return e1[2] < e2[2];        
      return e1 < e2;
    });
    // Cost of MST, ex: edge to exclude, in: edge to include.
    auto MST = [&](int ex = -1, int in = -1) -> int {
      UnionFind uf(n);
      int cost = 0;
      int count = 0;
      if (in >= 0) {
        cost += edges[in][2];
        uf.Union(edges[in][0], edges[in][1]);
        count++;
      }
      for (int i = 0; i < edges.size(); ++i) {        
        if (i == ex) continue;
        if (!uf.Union(edges[i][0], edges[i][1])) continue;
        cost += edges[i][2];
        ++count;
      }
      return count == n - 1 ? cost : INT_MAX;
    };
    const int min_cost = MST();
    vector<int> criticals;
    vector<int> pseudos;
    for (int i = 0; i < edges.size(); ++i) {
      // Cost increased or can't form a tree.
      if (MST(i) > min_cost) {
        criticals.push_back(edges[i][3]);
      } else if (MST(-1, i) == min_cost) {
        pseudos.push_back(edges[i][3]);
      }
    }
    return {criticals, pseudos};
  }
};

The post 花花酱 LeetCode 1489. Find Critical and Pseudo-Critical Edges in Minimum Spanning Tree appeared first on Huahua's Tech Road.

Now, we would like to merge these accounts. Two accounts definitely belong to the same person if there is some email that is common to both accounts. Note that even if two accounts have the same name, they may belong to different people as people could have the same name. A person can have any number of accounts initially, but all of their accounts definitely have the same name.

After merging the accounts, return the accounts in the following format: the first element of each account is the name, and the rest of the elements are emails in sorted order. The accounts themselves can be returned in any order.

Example 1:

Input: 
accounts = [["John", "johnsmith@mail.com", "john00@mail.com"], ["John", "johnnybravo@mail.com"], ["John", "johnsmith@mail.com", "john_newyork@mail.com"], ["Mary", "mary@mail.com"]]
Output: [["John", 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com'],  ["John", "johnnybravo@mail.com"], ["Mary", "mary@mail.com"]]
Explanation: 
The first and third John's are the same person as they have the common email "johnsmith@mail.com".
The second John and Mary are different people as none of their email addresses are used by other accounts.
We could return these lists in any order, for example the answer [['Mary', 'mary@mail.com'], ['John', 'johnnybravo@mail.com'], 
['John', 'john00@mail.com', 'john_newyork@mail.com', 'johnsmith@mail.com']] would still be accepted.

Note:The length of accounts will be in the range [1, 1000].The length of accounts[i] will be in the range [1, 10].The length of accounts[i][j] will be in the range [1, 30].

Solution: Union-Find

// Author: Huahua
class Solution {
public:
  vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
    unordered_map<string_view, int> ids;   // email to id
    unordered_map<int, string_view> names; // id to name
    vector<int> p(10000);
    iota(begin(p), end(p), 0);
    
    function<int(int)> find = [&](int x) {
      if (p[x] != x) p[x] = find(p[x]);
      return p[x];
    };
    
    auto getIdByEmail = [&](string_view email) {
      auto it = ids.find(email);
      if (it == ids.end()) {
        int id = ids.size();
        return ids[email] = id;
      }
      return it->second;
    };

    for (const auto& account : accounts) {      
      int u = find(getIdByEmail(account[1]));      
      for (int i = 2; i < account.size(); ++i) 
        p[find(u)] = find(getIdByEmail(account[i]));      
      names[find(u)] = string_view(account[0]);
    }

    unordered_map<int, set<string>> mergered;
    for (const auto& account : accounts)
      for (int i = 1; i < account.size(); ++i) {
        int id = find(getIdByEmail(account[i]));
        mergered[id].insert(account[i]);
      }    

    vector<vector<string>> ans;
    for (const auto& kv : mergered) {
      ans.push_back({string(names[kv.first])});
      ans.back().insert(ans.back().end(), kv.second.begin(), kv.second.end());
    }

    return ans;
  }
};

The post 花花酱 LeetCode 721. Accounts Merge appeared first on Huahua's Tech Road.

There are n computers numbered from 0 to n-1 connected by ethernet cables connections forming a network where connections[i] = [a, b] represents a connection between computers a and b. Any computer can reach any other computer directly or indirectly through the network.

Given an initial computer network connections. You can extract certain cables between two directly connected computers, and place them between any pair of disconnected computers to make them directly connected. Return the minimum number of times you need to do this in order to make all the computers connected. If it’s not possible, return -1. 

Example 1:

Input: n = 4, connections = [[0,1],[0,2],[1,2]]
Output: 1
Explanation: Remove cable between computer 1 and 2 and place between computers 1 and 3.

Example 2:

Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2],[1,3]]
Output: 2

Example 3:

Input: n = 6, connections = [[0,1],[0,2],[0,3],[1,2]]
Output: -1
Explanation: There are not enough cables.

Example 4:

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

Constraints:

• 1 <= n <= 10^5
• 1 <= connections.length <= min(n*(n-1)/2, 10^5)
• connections[i].length == 2
• 0 <= connections[i][0], connections[i][1] < n
• connections[i][0] != connections[i][1]
• There are no repeated connections.
• No two computers are connected by more than one cable.

Solution 1: Union-Find

Time complexity: O(V+E)
Space complexity: O(V)

// Author: Huahua
class Solution {
public:
  int makeConnected(int n, vector<vector<int>>& connections) {
    if (connections.size() < n - 1) return -1;
    vector<int> p(n);
    iota(begin(p), end(p), 0);
    
    function<int(int)> find = [&](int x) {
      return p[x] == x ? x : p[x] = find(p[x]);
    };
    
    for (const auto& c : connections)
      p[find(c[0])] = find(c[1]);    
    
    unordered_set<int> s;
    for (int i = 0; i < n; ++i)
      s.insert(find(i));
    
    return s.size() - 1;        
  }
};

Solution 2: DFS

Time complexity: O(V+E)
Space complexity: O(V+E)

// Author: Huahua
class Solution {
public:
  int makeConnected(int n, vector<vector<int>>& connections) {
    if (connections.size() < n - 1) return -1;
    vector<vector<int>> g(n);
    for (const auto& c : connections) {
      g[c[0]].push_back(c[1]);
      g[c[1]].push_back(c[0]);
    }
    vector<int> seen(n);
    int count = 0;
    function<void(int)> dfs = [&](int cur) {
      for (int nxt : g[cur])
        if (!seen[nxt]++) dfs(nxt);      
    };
    for (int i = 0; i < n; ++i)
      if (!seen[i]++ && ++count)
        dfs(i);        
    return count - 1;
  }
};

The post 花花酱 LeetCode 1319. Number of Operations to Make Network Connected appeared first on Huahua's Tech Road.

You are given a string s, and an array of pairs of indices in the string pairs where pairs[i] = [a, b] indicates 2 indices(0-indexed) of the string.

You can swap the characters at any pair of indices in the given pairs any number of times.

Return the lexicographically smallest string that s can be changed to after using the swaps.

Example 1:

Input: s = "dcab", pairs = [[0,3],[1,2]]
Output: "bacd"
Explaination: 
Swap s[0] and s[3], s = "bcad"
Swap s[1] and s[2], s = "bacd"

Example 2:

Input: s = "dcab", pairs = [[0,3],[1,2],[0,2]]
Output: "abcd"
Explaination: 
Swap s[0] and s[3], s = "bcad"
Swap s[0] and s[2], s = "acbd"
Swap s[1] and s[2], s = "abcd"

Example 3:

Input: s = "cba", pairs = [[0,1],[1,2]]
Output: "abc"
Explaination: 
Swap s[0] and s[1], s = "bca"
Swap s[1] and s[2], s = "bac"
Swap s[0] and s[1], s = "abc"

Constraints:

• 1 <= s.length <= 10^5
• 0 <= pairs.length <= 10^5
• 0 <= pairs[i][0], pairs[i][1] < s.length
• s only contains lower case English letters.

Solution: Connected Components

Use DFS / Union-Find to find all the connected components of swapable indices. For each connected components (index group), extract the subsequence of corresponding chars as a string, sort it and put it back to the original string in the same location.

e.g. s = “dcab”, pairs = [[0,3],[1,2]]
There are two connected components: {0,3}, {1,2}
subsequences:
1. 0,3 “db”, sorted: “bd”
2. 1,2 “ca”, sorted: “ac”
0 => b
1 => a
2 => c
3 => d
final = “bacd”

Time complexity: DFS: O(nlogn + k*(V+E)), Union-Find: O(nlogn + V+E)
Space complexity: O(n)

// Author: Huahua, 268 ms, 89 MB
class Solution {
public:
  string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
    vector<vector<int>> g(s.length());
    for (const auto& e : pairs) {
      g[e[0]].push_back(e[1]);
      g[e[1]].push_back(e[0]);
    }

    unordered_set<int> seen;
    vector<int> idx;
    string tmp;
    function<void(int)> dfs = [&](int cur) {
      if (seen.count(cur)) return;
      seen.insert(cur);
      idx.push_back(cur);
      tmp += s[cur];
      for (int nxt : g[cur]) dfs(nxt);
    };

    for (int i = 0; i < s.length(); ++i) {
      if (seen.count(i)) continue;
      idx.clear();
      tmp.clear();
      dfs(i);
      sort(begin(tmp), end(tmp));
      sort(begin(idx), end(idx));      
      for (int k = 0; k < idx.size(); ++k)
        s[idx[k]] = tmp[k];
    }
    return s;
  }
};

// Author: Huahua, 152 ms, 48.2 MB
class Solution {
public:
  string smallestStringWithSwaps(string s, vector<vector<int>>& pairs) {
    int n = s.length();
    vector<int> p(n);    
    iota(begin(p), end(p), 0); // p = {0, 1, 2, ... n - 1}
    
    function<int(int)> find = [&](int x) {
      return p[x] == x ? x : p[x] = find(p[x]);
    };        
    
    for (const auto& e : pairs)
      p[find(e[0])] = find(e[1]); // union
    
    vector<vector<int>> idx(n);
    vector<string> ss(n);
    
    for (int i = 0; i < s.length(); ++i) {
      int id = find(i);      
      idx[id].push_back(i); // already sorted
      ss[id].push_back(s[i]);
    }
    
    for (int i = 0; i < n; ++i) {      
      sort(begin(ss[i]), end(ss[i]));
      for (int k = 0; k < idx[i].size(); ++k)
        s[idx[i][k]] = ss[i][k];
    }
    
    return s;
  }
};

The post 花花酱 LeetCode 1202. Smallest String With Swaps appeared first on Huahua's Tech Road.

Given an array equations of strings that represent relationships between variables, each string equations[i] has length 4 and takes one of two different forms: "a==b" or "a!=b".  Here, a and b are lowercase letters (not necessarily different) that represent one-letter variable names.

Return true if and only if it is possible to assign integers to variable names so as to satisfy all the given equations.

Example 1:

Input: ["a==b","b!=a"]
Output: false
Explanation: If we assign say, a = 1 and b = 1, then the first equation is satisfied, but not the second.  There is no way to assign the variables to satisfy both equations.

Example 2:

Input: ["b==a","a==b"]
Output: true
Explanation: We could assign a = 1 and b = 1 to satisfy both equations.

Example 3:

Input: ["a==b","b==c","a==c"]
Output: true

Example 4:

Input: ["a==b","b!=c","c==a"]
Output: false

Example 5:

Input: ["c==c","b==d","x!=z"]
Output: true

Note:

1. 1 <= equations.length <= 500
2. equations[i].length == 4
3. equations[i][0] and equations[i][3] are lowercase letters
4. equations[i][1] is either '=' or '!'
5. equations[i][2] is '='

Solution: Union Find

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

// Author: Huahua, running time: 12 ms, 7.1 MB
class Solution {
public:
  bool equationsPossible(vector<string>& equations) {        
    iota(begin(parents_), end(parents_), 0);    
    for (const auto& eq : equations)     
      if (eq[1] == '=')
        parents_[find(eq[0])] = find(eq[3]);
    for (const auto& eq : equations)     
      if (eq[1] == '!' && find(eq[0]) == find(eq[3]))        
          return false;
    return true;
  }
private:
  array<int, 128> parents_;
  int find(int x) {
    if (x != parents_[x])
      parents_[x] = find(parents_[x]);
    return parents_[x];
  }  
};

The post 花花酱 LeetCode 990. Satisfiability of Equality Equations appeared first on Huahua's Tech Road.