The value of |x| is defined as:

• x if x >= 0.
• -x if x < 0.

Example 1:

Input: nums = [1,2,2,1], k = 1
Output: 4
Explanation: The pairs with an absolute difference of 1 are:
- [1,2,2,1]
- [1,2,2,1]
- [1,2,2,1]
- [1,2,2,1]

Example 2:

Input: nums = [1,3], k = 3
Output: 0
Explanation: There are no pairs with an absolute difference of 3.

Example 3:

Input: nums = [3,2,1,5,4], k = 2
Output: 3
Explanation: The pairs with an absolute difference of 2 are:
- [3,2,1,5,4]
- [3,2,1,5,4]
- [3,2,1,5,4]

Constraints:

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

Solution: Hashtable
|y – x| = k
y = x + k or y = x – k

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

// Author: Huahua
class Solution {
public:
  int countKDifference(vector<int>& nums, int k) {
    unordered_map<int, int> m;
    int ans = 0;
    for (int x : nums) {
      ans += m[x - k];
      ans += m[x + k];
      ++m[x];
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2006. Count Number of Pairs With Absolute Difference K appeared first on Huahua's Tech Road.

You can pick any two different foods to make a good meal.

Given an array of integers deliciousness where deliciousness[i] is the deliciousness of the i​​​​​​th​​​​​​​​ item of food, return the number of different good meals you can make from this list modulo 109 + 7.

Note that items with different indices are considered different even if they have the same deliciousness value.

Example 1:

Input: deliciousness = [1,3,5,7,9]
Output: 4
Explanation: The good meals are (1,3), (1,7), (3,5) and, (7,9).
Their respective sums are 4, 8, 8, and 16, all of which are powers of 2.

Example 2:

Input: deliciousness = [1,1,1,3,3,3,7]
Output: 15
Explanation: The good meals are (1,1) with 3 ways, (1,3) with 9 ways, and (1,7) with 3 ways.

Constraints:

• 1 <= deliciousness.length <= 105
• 0 <= deliciousness[i] <= 220

Solution: Hashtable

Same idea as LeetCode 1: Two Sum

Use a hashtable to store the occurrences of all the numbers added so far. For a new number x, check all possible 2^i – x. ans += freq[2^i – x] 0 <= i <= 21

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

class Solution {
public:
  int countPairs(vector<int>& A) {
    constexpr int kMod = 1e9 + 7;
    unordered_map<int, int> m;    
    long ans = 0;
    for (int x : A) {
      for (int t = 1; t <= 1 << 21; t *= 2) {
        auto it = m.find(t - x);
        if (it != end(m)) ans += it->second;
      }
      ++m[x];
    }
    return ans % kMod;
  }
};

class Solution:
  def countPairs(self, deliciousness: List[int]) -> int:
    sums = [1<<i for i in range(22)]
    m = defaultdict(int)
    ans = 0
    for x in deliciousness:
      for t in sums:
        if t - x in m: ans += m[t - x]
      m[x] += 1
    return ans % (10**9 + 7)

The post 花花酱 LeetCode 1711. Count Good Meals appeared first on Huahua's Tech Road.

Input:
[[0,0],[1,0],[2,0]]

Output:
2

Explanation:
The two boomerangs are [[1,0],[0,0],[2,0]] and [[1,0],[2,0],[0,0]]

Solution: HashTable

For each point, compute the distance to the rest of the points and count.

if there are k points that have the same distance to current point, then there are P(k,2) = k*k-1 Boomerangs.

for example, p1, p2, p3 have the same distance to p0, then there are P(3,2) = 3 * (3-1) = 6 Boomerangs

(p1, p0, p2), (p1, p0, p3)

(p2, p0, p1), (p2, p0, p3)

(p3, p0, p1), (p3, p0, p2)

C++

// Author: Huahua
// Running time: 210 ms (beats 83.33%)
class Solution {
public:
  int numberOfBoomerangs(vector<pair<int, int>>& points) {
    int ans = 0;
    for (int i = 0; i < points.size(); ++i) {
      unordered_map<int, int> dist(points.size());
      for (int j = 0; j < points.size(); ++j) {
        const int dx = points[i].first - points[j].first;
        const int dy = points[i].second - points[j].second;        
        ++dist[dx * dx + dy * dy];
      }
      for (const auto& kv : dist)
        ans += kv.second * (kv.second - 1);      
    }
    return ans;
  }
};

Solution 2: Sorting

dist = [1, 2, 1, 2, 1, 5]

sorted_dist = [1, 1, 1, 2, 2, 5], 1*3, 2*2, 5*1

ans = 3*(3-1) + 2 * (2 – 1) * 1 * (1 – 1) = 8

Time complexity: O(n*nlogn)

Space complexity: O(n)

// Author: Huahua
// Running time: 150 ms (beats 98.52%)
class Solution {
public:
  int numberOfBoomerangs(vector<pair<int, int>>& points) {
    const int n = points.size();
    int ans = 0;
    vector<int> dist(points.size());
    for (int i = 0; i < n; ++i) {   
      for (int j = 0; j < n; ++j) {
        const int dx = points[i].first - points[j].first;
        const int dy = points[i].second - points[j].second;    
        dist[j] = dx * dx + dy * dy;
      }
      
      std::sort(dist.begin(), dist.end());
      
      for (int j = 1; j < n; ++j) {
        int k = 1;
        while (j < n && dist[j] == dist[j - 1]) { ++j; ++k; }
        ans += k * (k - 1);
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 447. Number of Boomerangs appeared first on Huahua's Tech Road.