Example 1:

Input: nums = [3,1,2,2,2,1,3], k = 2
Output: 4
Explanation:
There are 4 pairs that meet all the requirements:
- nums[0] == nums[6], and 0 * 6 == 0, which is divisible by 2.
- nums[2] == nums[3], and 2 * 3 == 6, which is divisible by 2.
- nums[2] == nums[4], and 2 * 4 == 8, which is divisible by 2.
- nums[3] == nums[4], and 3 * 4 == 12, which is divisible by 2.

Example 2:

Input: nums = [1,2,3,4], k = 1
Output: 0
Explanation: Since no value in nums is repeated, there are no pairs (i,j) that meet all the requirements.

Constraints:

• 1 <= nums.length <= 100
• 1 <= nums[i], k <= 100

Solution: Brute Force

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

// Author: Huahua
class Solution {
public:
  int countPairs(vector<int>& nums, int k) {
    const int n = nums.size();
    int ans = 0;
    for (int i = 0; i < n; ++i)
      for (int j = i + 1; j < n; ++j)
        ans += (nums[i] == nums[j]) && (i * j % k == 0);
    return ans;
  }
};

The post 花花酱 LeetCode 2176. Count Equal and Divisible Pairs in an Array appeared first on Huahua's Tech Road.

The answer to the jth query is the number of pairs of nodes (a, b) that satisfy the following conditions:

• a < b
• cnt is strictly greater than queries[j], where cnt is the number of edges incident to a or b.

Return an array answers such that answers.length == queries.length and answers[j] is the answer of the jth query.

Note that there can be repeated edges.

Example 1:

Input: n = 4, edges = [[1,2],[2,4],[1,3],[2,3],[2,1]], queries = [2,3]
Output: [6,5]
Explanation: The number of edges incident to at least one of each pair is shown above.

Example 2:

Input: n = 5, edges = [[1,5],[1,5],[3,4],[2,5],[1,3],[5,1],[2,3],[2,5]], queries = [1,2,3,4,5]
Output: [10,10,9,8,6]

Constraints:

• 2 <= n <= 2 * 104
• 1 <= edges.length <= 105
• 1 <= ui, vi <= n
• ui != vi
• 1 <= queries.length <= 20
• 0 <= queries[j] < edges.length

Solution 1: Pre-compute

Pre-compute # of pairs with total edges >= k. where k is from 0 to max_degree * 2 + 1.

Time complexity: (|node_degrees|² + V + E)
Space complexity: O(V+E)

// Author: huahua
class Solution {
public:
  vector<int> countPairs(int n, vector<vector<int>>& edges, vector<int>& queries) {
    vector<int> node_degrees(n);
    unordered_map<int, int> edge_freq;
    for (auto& e : edges) {
      sort(begin(e), end(e));
      ++node_degrees[--e[0]];
      ++node_degrees[--e[1]];
      ++edge_freq[(e[0] << 16) | e[1]];
    }
    
    const int max_degree = *max_element(begin(node_degrees), 
                                        end(node_degrees));
    // Need pad one more to handle "not found / 0" case.
    vector<int> counts(max_degree * 2 + 2);
    
    unordered_map<int, int> degree_count;
    for (int i = 0; i < n; ++i) 
      ++degree_count[node_degrees[i]];
    
    for (auto& [d1, c1] : degree_count)
      for (auto& [d2, c2] : degree_count)
        // Only count once if degrees are different to ensure (a < b)
        if (d1 < d2) counts[d1 + d2] += c1 * c2;
        // If degrees are the same C(n, 2) to ensure (a < b)
        else if (d1 == d2) counts[d1 * 2] += c1 * (c1 - 1) / 2;
    
    for (auto& [key, freq] : edge_freq) {
      const int u = key >> 16;
      const int v = key & 0xFFFF;
      // For a pair of (u, v) their actual edge count is 
      // d[u] + d[v] - freq[(u, v)] instead of d[u] + d[v]
      counts[node_degrees[u] + node_degrees[v]] -= 1;
      counts[node_degrees[u] + node_degrees[v] - freq] += 1;
    }
    
    // counts[i] = # of pairs whose total edges >= i
    for (int i = counts.size() - 2; i >= 0; --i)
      counts[i] += counts[i + 1];
    
    vector<int> ans;
    for (int q : queries)
      ans.push_back(counts[min(q + 1, static_cast<int>(counts.size() - 1))]);
    return ans;
  }
};

The post 花花酱 LeetCode 1782. Count Pairs Of Nodes appeared first on Huahua's Tech Road.

The network rankof two different cities is defined as the total number of directly connected roads to either city. If a road is directly connected to both cities, it is only counted once.

The maximal network rank of the infrastructure is the maximum network rank of all pairs of different cities.

Given the integer n and the array roads, return the maximal network rank of the entire infrastructure.

Example 1:

Input: n = 4, roads = [[0,1],[0,3],[1,2],[1,3]]
Output: 4
Explanation: The network rank of cities 0 and 1 is 4 as there are 4 roads that are connected to either 0 or 1. The road between 0 and 1 is only counted once.

Example 2:

Input: n = 5, roads = [[0,1],[0,3],[1,2],[1,3],[2,3],[2,4]]
Output: 5
Explanation: There are 5 roads that are connected to cities 1 or 2.

Example 3:

Input: n = 8, roads = [[0,1],[1,2],[2,3],[2,4],[5,6],[5,7]]
Output: 5
Explanation: The network rank of 2 and 5 is 5. Notice that all the cities do not have to be connected.

Constraints:

• 2 <= n <= 100
• 0 <= roads.length <= n * (n - 1) / 2
• roads[i].length == 2
• 0 <= ai, bi <= n-1
• ai != bi
• Each pair of cities has at most one road connecting them.

Solution: Counting degrees and all pairs

Counting degrees for each node, if a and b are not connected, ans = degrees(a) + degrees(b), otherwise ans -= 1

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

// Author: Huahua
class Solution {
public:
  int maximalNetworkRank(int n, vector<vector<int>>& roads) {
    vector<int> degrees(n);
    unordered_set<int> connected;
    for (const auto& road : roads) {
      ++degrees[road[0]];
      ++degrees[road[1]];
      connected.insert((road[0] << 16) | road[1]);
      connected.insert((road[1] << 16) | road[0]);
    }
    int ans = 0;
    for (int i = 0; i < n; ++i)
      for (int j = i + 1; j < n; ++j)
        ans = max(ans, degrees[i] + degrees[j] 
                         - (connected.count((i << 16) | j) ? 1 : 0));
    return ans;
  }
};

The post 花花酱 LeetCode 1615. Maximal Network Rank appeared first on Huahua's Tech Road.

Return a list of pairs in ascending order(with respect to pairs), each pair [a, b] follows

• a, b are from arr
• a < b
• b - a equals to the minimum absolute difference of any two elements in arr

Example 1:

Input: arr = [4,2,1,3]
Output: [[1,2],[2,3],[3,4]]
Explanation: The minimum absolute difference is 1. List all pairs with difference equal to 1 in ascending order.

Example 2:

Input: arr = [1,3,6,10,15]
Output: [[1,3]]

Example 3:

Input: arr = [3,8,-10,23,19,-4,-14,27]
Output: [[-14,-10],[19,23],[23,27]]

Constraints:

• 2 <= arr.length <= 10^5
• -10^6 <= arr[i] <= 10^6

Solution: Sorting

The min abs difference could only happen between consecutive numbers in sorted form.

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> minimumAbsDifference(vector<int>& arr) {
    sort(begin(arr), end(arr));
    vector<vector<int>> ans;
    int best = INT_MAX;
    for (int i = 1; i < arr.size(); ++i) {
      int d = abs(arr[i] - arr[i - 1]);      
      if (d < best) {
        ans.clear();
        best = d;
      }
      if (d == best) ans.push_back({arr[i - 1], arr[i]});      
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1200. Minimum Absolute Difference appeared first on Huahua's Tech Road.

Find the maximum width of a ramp in A.  If one doesn’t exist, return 0.

Example 1:

Input: [6,0,8,2,1,5] 
Output: 4 
Explanation:  The maximum width ramp is achieved at (i, j) = (1, 5): A[1] = 0 and A[5] = 5. 

Example 2:

Input: [9,8,1,0,1,9,4,0,4,1] 
Output: 7 
Explanation:  The maximum width ramp is achieved at (i, j) = (2, 9): A[2] = 1 and A[9] = 1. 

Note:

1. 2 <= A.length <= 50000
2. 0 <= A[i] <= 50000

Solution: Stack

1. Using a stack to store start candidates’ (decreasing order) index
2. Scan from right to left, compare the current number with the one on the top of the stack, pop if greater.

e.g.
A = [6,0,8,2,1,5]
stack = [0, 1] => [6, 0]
cur: A[5] = 5, stack.top = A[1] = 0, ramp = 5, stack.pop()
cur: A[4] = 1, stack.top = A[0] = 6
cur: A[3] = 2, stack.top = A[0] = 6
cur: A[2] = 8, stack.top = A[0] = 6, ramp = 2, stack.pop()
stack.isEmpty() => END

// Author: Huahua, running time: 44 ms
class Solution {
public:
  int maxWidthRamp(vector<int>& A) {
    stack<int> s;
    for (int i = 0; i < A.size(); ++i)
      if (s.empty() || A[i] < A[s.top()])
        s.push(i);
    int ans = 0;
    for (int i = A.size() - 1; i >= 0; --i)
      while (!s.empty() && A[i] >= A[s.top()]) {
        ans = max(ans, i - s.top());
        s.pop();
      }
    return ans;
  }
};

# Author: Huahua, running time: 92 ms
class Solution:
  def maxWidthRamp(self, A):
    s = []
    for i in range(len(A)):
      if not s or A[i] < A[s[-1]]: s.append(i)
    ans = 0
    for i in range(len(A) - 1, -1, -1):
      while s and A[i] >= A[s[-1]]:
        ans = max(ans, i - s.pop())        
    return ans

The post 花花酱 LeetCode 962. Maximum Width Ramp appeared first on Huahua's Tech Road.

Given an array A of integers, for each integer A[i] we may choose any x with -K <= x <= K, and add xto A[i].

After this process, we have some array B.

Return the smallest possible difference between the maximum value of B and the minimum value of B.

Input: A = [1], K = 0
Output: 0
Explanation: B = [1]

Input: A = [0,10], K = 2
Output: 6
Explanation: B = [2,8]

Input: A = [1,3,6], K = 3
Output: 0
Explanation: B = [3,3,3] or B = [4,4,4]

// Author: Huahua
class Solution {
public:
  int smallestRangeI(vector<int>& A, int K) {
    int a_min = *min_element(begin(A), end(A));
    int a_max = *max_element(begin(A), end(A));
    return max(0, (a_max - a_min) - 2 * K);
  }
};

# Author: Huahua, 72 ms
class Solution:
  def smallestRangeI(self, A, K):
    return max(0, max(A) - min(A) - 2 * K);

The post 花花酱 LeetCode 908. Smallest Range I appeared first on Huahua's Tech Road.