Return the maximum sum or -1 if no such pair exists.

Example 1:

Input: nums = [51,71,17,24,42]
Output: 88
Explanation: 
For i = 1 and j = 2, nums[i] and nums[j] have equal maximum digits with a pair sum of 71 + 17 = 88. 
For i = 3 and j = 4, nums[i] and nums[j] have equal maximum digits with a pair sum of 24 + 42 = 66.
It can be shown that there are no other pairs with equal maximum digits, so the answer is 88.

Example 2:

Input: nums = [1,2,3,4]
Output: -1
Explanation: No pair exists in nums with equal maximum digits.

Constraints:

• 2 <= nums.length <= 100
• 1 <= nums[i] <= 104

Solution: Brute Force

Enumerate all pairs of nums and check their sum and max digit.

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

// Author: Huahua
class Solution {
public:
  int maxSum(vector<int>& nums) {
    auto maxDigit = [](int x) {
      int ans = 0;
      while (x) {
        ans = max(ans, x % 10);
        x /= 10;
      }
      return ans;
    };
    int ans = -1;
    const int n = nums.size();
    for (int i = 0; i < n; ++i)
      for (int j = i + 1; j < n; ++j)
        if (nums[i] + nums[j] > ans 
            && maxDigit(nums[i]) == maxDigit(nums[j]))
          ans = nums[i] + nums[j];
    return ans;
  }
};

The post 花花酱 LeetCode 2815. Max Pair Sum in an Array appeared first on Huahua's Tech Road.

A pair (i, j) is fair if:

• 0 <= i < j < n, and
• lower <= nums[i] + nums[j] <= upper

Example 1:

Input: nums = [0,1,7,4,4,5], lower = 3, upper = 6
Output: 6
Explanation: There are 6 fair pairs: (0,3), (0,4), (0,5), (1,3), (1,4), and (1,5).

Example 2:

Input: nums = [1,7,9,2,5], lower = 11, upper = 11
Output: 1
Explanation: There is a single fair pair: (2,3).

Constraints:

• 1 <= nums.length <= 105
• nums.length == n
• -109 <= nums[i] <= 109
• -109 <= lower <= upper <= 109

Solution: Two Pointers

Sort the array, use two pointers to find how # of pairs (i, j) s.t. nums[i] + nums[j] <= limit.
Ans = count(upper) – count(lower – 1)

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

// Author: Huahua
class Solution {
public:
  long long countFairPairs(vector<int>& nums, int lower, int upper) {
    sort(begin(nums), end(nums));
    auto count = [&](int limit) -> long long {
      long long ans = 0;
      for (int i = 0, j = nums.size() - 1; i < j; ++i) {
        while (i < j && nums[i] + nums[j] > limit) --j;
        ans += j - i;
      }
      return ans;
    };
    return count(upper) - count(lower - 1);
  }
};

The post 花花酱 LeetCode 2563. Count the Number of Fair Pairs appeared first on Huahua's Tech Road.

• For example, the product difference between (5, 6) and (2, 7) is (5 * 6) - (2 * 7) = 16.

Given an integer array nums, choose four distinct indices w, x, y, and z such that the product difference between pairs (nums[w], nums[x]) and (nums[y], nums[z]) is maximized.

Return the maximum such product difference.

Example 1:

Input: nums = [5,6,2,7,4]
Output: 34
Explanation: We can choose indices 1 and 3 for the first pair (6, 7) and indices 2 and 4 for the second pair (2, 4).
The product difference is (6 * 7) - (2 * 4) = 34.

Example 2:

Input: nums = [4,2,5,9,7,4,8]
Output: 64
Explanation: We can choose indices 3 and 6 for the first pair (9, 8) and indices 1 and 5 for the second pair (2, 4).
The product difference is (9 * 8) - (2 * 4) = 64.

Constraints:

• 4 <= nums.length <= 104
• 1 <= nums[i] <= 104

Solution: Greedy

Since all the numbers are positive, we just need to find the largest two numbers as the first pair and smallest two numbers are the second pair.

Time complexity: O(nlogn) / sorting, O(n) / finding min/max elements.
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int maxProductDifference(vector<int>& nums) {
    const int n = nums.size();
    sort(begin(nums), end(nums));
    return nums[n - 1] * nums[n - 2] - nums[0] * nums[1];
  }
};

# Author: Huahua
class Solution:
  def maxProductDifference(self, nums: List[int]) -> int:
    nums.sort()
    return nums[-1] * nums[-2] - nums[0] * nums[1]

The post 花花酱 LeetCode 1913. Maximum Product Difference Between Two Pairs appeared first on Huahua's Tech Road.

• For example, if we have pairs (1,5), (2,3), and (4,4), the maximum pair sum would be max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8.

Given an array nums of even length n, pair up the elements of nums into n / 2 pairs such that:

• Each element of nums is in exactly one pair, and
• The maximum pair sum is minimized.

Return the minimized maximum pair sum after optimally pairing up the elements.

Example 1:

Input: nums = [3,5,2,3]
Output: 7
Explanation: The elements can be paired up into pairs (3,3) and (5,2).
The maximum pair sum is max(3+3, 5+2) = max(6, 7) = 7.

Example 2:

Input: nums = [3,5,4,2,4,6]
Output: 8
Explanation: The elements can be paired up into pairs (3,5), (4,4), and (6,2).
The maximum pair sum is max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8.

Constraints:

• n == nums.length
• 2 <= n <= 105
• n is even.
• 1 <= nums[i] <= 105

Solution: Greedy

Sort the elements, pair nums[i] with nums[n – i – 1] and find the max pair.

Time complexity: O(nlogn) -> O(n) counting sort.
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int minPairSum(vector<int>& nums) {
    const int n = nums.size();
    int ans = 0;
    sort(begin(nums), end(nums));
    for (int i = 0; i < n / 2; ++i)
      ans = max(ans, nums[i] + nums[n - i - 1]);
    return ans;
  }
};

The post 花花酱 LeetCode 1877. Minimize Maximum Pair Sum in Array appeared first on Huahua's Tech Road.

1. set(string key, string value, int timestamp)

• Stores the key and value, along with the given timestamp.

2. get(string key, int timestamp)

• Returns a value such that set(key, value, timestamp_prev) was called previously, with timestamp_prev <= timestamp.
• If there are multiple such values, it returns the one with the largest timestamp_prev.
• If there are no values, it returns the empty string ("").

Example 1:

Input: inputs = ["TimeMap","set","get","get","set","get","get"], inputs = [[],["foo","bar",1],["foo",1],["foo",3],["foo","bar2",4],["foo",4],["foo",5]]
Output: [null,null,"bar","bar",null,"bar2","bar2"]
Explanation:   
TimeMap kv;   
kv.set("foo", "bar", 1); // store the key "foo" and value "bar" along with timestamp = 1   
kv.get("foo", 1);  // output "bar"   
kv.get("foo", 3); // output "bar" since there is no value corresponding to foo at timestamp 3 and timestamp 2, then the only value is at timestamp 1 ie "bar"   
kv.set("foo", "bar2", 4);   
kv.get("foo", 4); // output "bar2"   
kv.get("foo", 5); //output "bar2"   

Example 2:

Input: inputs = ["TimeMap","set","set","get","get","get","get","get"], inputs = [[],["love","high",10],["love","low",20],["love",5],["love",10],["love",15],["love",20],["love",25]]
Output: [null,null,null,"","high","high","low","low"]

Note:

1. All key/value strings are lowercase.
2. All key/value strings have length in the range [1, 100]
3. The timestamps for all TimeMap.set operations are strictly increasing.
4. 1 <= timestamp <= 10^7
5. TimeMap.set and TimeMap.get functions will be called a total of 120000 times (combined) per test case.

Solution: HashTable + Map

// Author: Huahua, running time: 200 ms
class TimeMap {
public:
  /** Initialize your data structure here. */
  TimeMap() {}

  void set(string key, string value, int timestamp) {
    s_[key].emplace(timestamp, std::move(value));
  }

  string get(string key, int timestamp) {
    auto m = s_.find(key);
    if (m == s_.end()) return "";    
    auto it = m->second.upper_bound(timestamp);
    if (it == begin(m->second)) return "";
    return prev(it)->second;
  }
private:
  unordered_map<string, map<int, string>> s_; 
};

The post 花花酱 LeetCode 981. Time Based Key-Value Store appeared first on Huahua's Tech Road.

Problem

You are installing a billboard and want it to have the largest height.  The billboard will have two steel supports, one on each side.  Each steel support must be an equal height.

You have a collection of rods which can be welded together.  For example, if you have rods of lengths 1, 2, and 3, you can weld them together to make a support of length 6.

Return the largest possible height of your billboard installation.  If you cannot support the billboard, return 0.

Example 1:

Input: [1,2,3,6]
Output: 6
Explanation: We have two disjoint subsets {1,2,3} and {6}, which have the same sum = 6.

Example 2:

Input: [1,2,3,4,5,6]
Output: 10
Explanation: We have two disjoint subsets {2,3,5} and {4,6}, which have the same sum = 10.

Example 3:

Input: [1,2]
Output: 0
Explanation: The billboard cannot be supported, so we return 0.

Note:

1. 0 <= rods.length <= 20
2. 1 <= rods[i] <= 1000
3. The sum of rods is at most 5000.

Solution: DP

如果直接暴力搜索的话时间复杂度是O(3^N)，铁定超时。对于每一根我们可以选择1、放到左边，2、放到右边，3、不使用。最后再看一下左边和右边是否相同。

题目的数据规模中的这句话非常重要：

The sum of rods is at most 5000.

这句话就是告诉你算法的时间复杂度和sum of rods有关系，通常需要使用DP。

由于每根柱子只能使用一次（让我们想到了 回复 01背包），但是我们怎么去描述放到左边还是放到右边呢？

Naive的方法是用 dp[i] 表示使用前i个柱子能够构成的柱子高度的集合。

e.g. dp[i] = {(h1, h2)},  h1 <= h2

和暴力搜索比起来DP已经对状态进行了压缩，因为我并不需要关心h1, h2是通过哪些（在我之前的）柱子构成了，我只关心它们的当前高度。

然后我可以选择

1、不用第i根柱子

2、放到低的那一堆

3、放到高的那一堆

状态转移的伪代码：

for h1, h2 in dp[i – 1]:

dp[i] += (h1, h2)        # not used

dp[i] += (h1, h2 + h)  # put on higher

if h1 + h < h2:

dp[i] += (h1 + h, h2)  # put on lower

else:

dp[i] += (h2, h1 + h)  # put on lower

假设 rods=[1,1,2]

dp[0] = {(0,0)}

dp[1] = {(0,0), (0,1)}

dp[2] = {(0,0), (0,1), (0,2), (1,1)}

dp[3] = {(0,0), (0,1), (0,2), (0,3), (0,4), (1,1), (1,2), (1,3), (2,2)}

但是dp[i]这个集合的大小可能达到sum^2，所以还是会超时…

时间复杂度 O(n*sum^2)

空间复杂度 O(n*sum^2) 可降维至 O(sum^2)

革命尚未成功，同志仍需努力!

all pairs的cost太大，我们还需要继续压缩状态！

重点来了

通过观察发现，若有2个pairs：

(h1, h2), (h3, h4),

h1 <= h2, h3 <= h4, h1 < h3, h2 – h1 = h4 – h3 即 高度差 相同

如果 min(h1, h2) < min(h3, h4) 那么(h1, h2) 不可能产生最优解，直接舍弃。

因为如果后面的柱子可以构成 h4 – h3/h2 – h1 填补高度差，使得两根柱子一样高，那么答案就是 h2 和 h4。但h2 < h4，所以最优解只能来自后者。

举个例子：我有 (1, 3) 和 (2, 4) 两个pairs，它们的高度差都是2，假设我还有一个长度为2的柱子，那么我可以构成(1+2, 3) 以及 (2+2, 4)，虽然这两个都是解。但是后者的高度要大于前者，所以前者无法构成最优解，也就没必要存下来。

所以，我们可以把状态压缩到高度差，对于相同的高度差，我只存h1最大的。

我们用 dp[i][j] 来表示使用前i个柱子，高度差为j的情况下最大的公共高度h1是多少。

状态转移（如下图）

dp[i][j] = max(dp[i][j], dp[i – 1][j])

dp[i][j+h] = max(dp[i][j + h], dp[i – 1][j])

dp[i][|j-h|] = max(dp[i][|j-h|], dp[i – 1][j] + min(j, h))

时间复杂度 O(nsum)

空间复杂度 O(nsum) 可降维至 O(sum)

dp[i] := max common height of two piles of height difference i.

e.g. y1 = 5, y2 = 9 => dp[9 – 5] = min(5, 9) => dp[4] = 5.

answer: dp[0]

Time complexity: O(n*Sum)

Space complexity: O(Sum)

// Author: Huahua, 172 ms
class Solution {
public:
  int tallestBillboard(vector<int>& rods) {
    unordered_map<int, int> dp;
    dp[0] = 0;
    for (int rod : rods) {      
      auto cur = dp;
      for (const auto& kv : cur) {
        const int k = kv.first;
        dp[k + rod] = max(dp[k + rod], cur[k]);
        dp[abs(k - rod)] = max(dp[abs(k - rod)], cur[k] + min(rod, k));
      }    
    }
    return dp[0];
  }
};

// Author: Huahua, 8 ms
class Solution {
public:
  int tallestBillboard(vector<int>& rods) {    
    const int s = accumulate(begin(rods), end(rods), 0);
    vector<int> dp(s + 1, -1);    
    dp[0] = 0;
    for (int rod : rods) {    
      vector<int> cur(dp);
      for (int i = 0; i <= s - rod; ++i) {
        if (cur[i] < 0) continue;
        dp[i + rod] = max(dp[i + rod], cur[i]);
        dp[abs(i - rod)] = max(dp[abs(i - rod)], cur[i] + min(rod, i));
      }    
    }
    return dp[0];
  }
};

// Author: Huahua, 12 ms
class Solution {
public:
  int tallestBillboard(vector<int>& rods) {    
    const int n = rods.size();
    const int s = accumulate(begin(rods), end(rods), 0);
    // dp[i][j] := min(h1, h2), j = abs(h1 - h2)
    vector<vector<int>> dp(n + 1, vector<int>(s + 1, -1));
    dp[0][0] = 0;
    for (int i = 1; i <= n; ++i) {      
      int h = rods[i - 1];
      for (int j = 0; j <= s - h; ++j) {
        if (dp[i - 1][j] < 0) continue;
        // not used
        dp[i][j] = max(dp[i][j], dp[i - 1][j]);  
        // put on the taller one 
        dp[i][j + h] = max(dp[i][j + h], dp[i - 1][j]); 
        // put on the shorter one
        dp[i][abs(j - h)] = max(dp[i][abs(j - h)], dp[i - 1][j] + min(h, j)); 
      }    
    }
    return dp[n][0];
  }
};

The post 花花酱 LeetCode 956. Tallest Billboard appeared first on Huahua's Tech Road.

Problem:

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

Idea:

Brute force / Hashtable

Solution1:

Brute force / C++

Time complexity: O(n^2)

Space complexity: O(1)

// Author: Huahua
// Runtime: 166 ms
class Solution {
public:
  vector<int> twoSum(vector<int>& nums, int target) {
    for (int i = 0; i < nums.size(); ++i) {
      for (int j = i + 1;j < nums.size(); ++j) {
        int sum = nums[i] + nums[j];
        if (sum == target) {
          return {i, j};
        }
      }
    }
    return {};
  }
};

Solution 2:

Hashtable / C++

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
// Runtime: 6 ms
class Solution {
public:
  vector<int> twoSum(vector<int>& nums, int target) {
    unordered_map<int, int> indies;
    for (int i = 0; i < nums.size(); ++i)
      indies[nums[i]] = i;
    
    for (int i = 0; i < nums.size(); ++i) {
      int left = target - nums[i];
      if (indies.count(left) && indies[left] != i) {
          return {i, indies[left]};
      }
    }
    return {};
  }
};

The post 花花酱 LeetCode 1. Two Sum appeared first on Huahua's Tech Road.

题目大意：给你一个数组，返回所有数对中，绝对值差第k小的值。

Problem:

Given an integer array, return the k-th smallest distance among all the pairs. The distance of a pair (A, B) is defined as the absolute difference between A and B.

Example 1:

Input:
nums = [1,3,1]
k = 1
Output: 0 
Explanation:
Here are all the pairs:
(1,3) -> 2
(1,1) -> 0
(3,1) -> 2
Then the 1st smallest distance pair is (1,1), and its distance is 0.

Note:

1. 2 <= len(nums) <= 10000.
2. 0 <= nums[i] < 1000000.
3. 1 <= k <= len(nums) * (len(nums) - 1) / 2.

Idea

Bucket sort

Binary search / dp

Solution

C++ / binary search

// Author: Huahua
// Runtime: 9 ms
class Solution {
public:
    int smallestDistancePair(vector<int>& nums, int k) {
        std::sort(nums.begin(), nums.end());
        int n = nums.size();
        int l = 0;
        int r = nums.back() - nums.front();
        while (l <= r) {
            int cnt = 0;
            int j = 0;
            int m = l + (r - l) / 2;
            for (int i = 0; i < n; ++i) {
                while (j < n && nums[j] - nums[i] <= m) ++j;
                cnt += j - i - 1;
            }
            cnt >= k ? r = m - 1 : l = m + 1;
        }        
        return l;
    }
};

C++ / bucket sort w/ vector O(n^2)

// Author: Huahua
// Runtime: 549 ms
class Solution {
public:
    int smallestDistancePair(vector<int>& nums, int k) {
        std::sort(nums.begin(), nums.end());
        const int N = nums.back();
        vector<int> count(N + 1, 0);        
        const int n = nums.size();
        for (int i = 0; i < n; ++i)
            for (int j = i + 1; j < n; ++j)
               ++count[nums[j] - nums[i]];
        for (int i = 0; i <= N; ++i) {
            k -= count[i];
            if (k <= 0) return i;
        }
        return 0;
    }
};

Related Problems:

• 花花酱 LeetCode 786. K-th Smallest Prime Fraction
• 花花酱 LeetCode 378. Kth Smallest Element in a Sorted Matrix

The post 花花酱 LeetCode 719. Find K-th Smallest Pair Distance appeared first on Huahua's Tech Road.