Given an array changed, return original if changed is a doubled array. If changed is not a doubled array, return an empty array. The elements in original may be returned in any order.

Example 1:

Input: changed = [1,3,4,2,6,8]
Output: [1,3,4]
Explanation: One possible original array could be [1,3,4]:
- Twice the value of 1 is 1 * 2 = 2.
- Twice the value of 3 is 3 * 2 = 6.
- Twice the value of 4 is 4 * 2 = 8.
Other original arrays could be [4,3,1] or [3,1,4].

Example 2:

Input: changed = [6,3,0,1]
Output: []
Explanation: changed is not a doubled array.

Example 3:

Input: changed = [1]
Output: []
Explanation: changed is not a doubled array.

Constraints:

• 1 <= changed.length <= 105
• 0 <= changed[i] <= 105

Solution 1: Multiset

Start from the smallest number x, erase one x * 2 from the set.

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

// Author: Huahua
class Solution {
public:
  vector<int> findOriginalArray(vector<int>& changed) {
    if (changed.size() & 1) return {};
    const int n = changed.size() / 2;
    multiset<int> s(begin(changed), end(changed));    
    while (ans.size() != n) {
      int o = *begin(s);
      s.erase(begin(s));
      ans.push_back(o);
      auto it = s.find(o * 2);
      if (it == end(s)) return {};
      s.erase(it);
    }
    return ans;
  }
};

Solution 2: Hashtable

Time complexity: O(max(nums) + n)
Space complexity: O(max(nums))

// Author: Huahua
class Solution {
public:
  vector<int> findOriginalArray(vector<int>& changed) {
    if (changed.size() & 1) return {};
    const int n = changed.size() / 2;
    const int kMax = *max_element(begin(changed), end(changed));
    vector<int> m(kMax + 1);
    for (int x : changed) ++m[x];
    if (m[0] & 1) return {};
    vector<int> ans(m[0] / 2, 0);
    for (int x = 1; ans.size() != n; ++x) {
      if (x * 2 > kMax || m[x * 2] < m[x]) return {};      
      ans.insert(end(ans), m[x], x);
      m[x * 2] -= m[x];   
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2007. Find Original Array From Doubled Array appeared first on Huahua's Tech Road.

The MKAverage can be calculated using these steps:

1. If the number of the elements in the stream is less than m you should consider the MKAverage to be -1. Otherwise, copy the last m elements of the stream to a separate container.
2. Remove the smallest k elements and the largest k elements from the container.
3. Calculate the average value for the rest of the elements rounded down to the nearest integer.

Implement the MKAverage class:

• MKAverage(int m, int k) Initializes the MKAverage object with an empty stream and the two integers m and k.
• void addElement(int num) Inserts a new element num into the stream.
• int calculateMKAverage() Calculates and returns the MKAverage for the current stream rounded down to the nearest integer.

Example 1:

Input
["MKAverage", "addElement", "addElement", "calculateMKAverage", "addElement", "calculateMKAverage", "addElement", "addElement", "addElement", "calculateMKAverage"]
[[3, 1], [3], [1], [], [10], [], [5], [5], [5], []]
Output
[null, null, null, -1, null, 3, null, null, null, 5]
Explanation MKAverage obj = new MKAverage(3, 1); obj.addElement(3); // current elements are [3] obj.addElement(1); // current elements are [3,1] obj.calculateMKAverage(); // return -1, because m = 3 and only 2 elements exist. obj.addElement(10); // current elements are [3,1,10] obj.calculateMKAverage(); // The last 3 elements are [3,1,10]. // After removing smallest and largest 1 element the container will be [3]. // The average of [3] equals 3/1 = 3, return 3 obj.addElement(5); // current elements are [3,1,10,5] obj.addElement(5); // current elements are [3,1,10,5,5] obj.addElement(5); // current elements are [3,1,10,5,5,5] obj.calculateMKAverage(); // The last 3 elements are [5,5,5]. // After removing smallest and largest 1 element the container will be [5]. // The average of [5] equals 5/1 = 5, return 5

Constraints:

• 3 <= m <= 105
• 1 <= k*2 < m
• 1 <= num <= 105
• At most 105 calls will be made to addElement and calculateMKAverage.

Solution 1: Multiset * 3

Use three multiset to track the left part (smallest k elements), right part (largest k elements) and mid (middle part of m – 2*k elements).

Time complexity: addElememt: O(logn), average: O(1)
Space complexity: O(n)

class MKAverage {
public:
  MKAverage(int m, int k): 
    sum(0), m(m), k(k), n(m - 2*k) {}

  void addElement(int num) {
    if (q.size() == m) {      
      remove(q.front());
      q.pop();
    }
    q.push(num);
    add(num);
  }

  int calculateMKAverage() {    
    return (q.size() < m) ? -1 : sum / n;
  }
private:
  void add(int x) {
    left.insert(x);
    
    if (left.size() > k) {
      auto it = prev(end(left));
      sum += *it;
      mid.insert(*it);      
      left.erase(it);
    }
    
    if (mid.size() > n) {
      auto it = prev(end(mid));
      sum -= *it; 
      right.insert(*it);
      mid.erase(it);
    }
  }
  
  void remove(int x) {
    if (x <= *rbegin(left)) {
      left.erase(left.find(x));
    } else if (x <= *rbegin(mid)) {
      sum -= x;
      mid.erase(mid.find(x));
    } else {
      right.erase(right.find(x));
    }
    
    if (left.size() < k) {
      auto it = begin(mid);
      sum -= *it;
      left.insert(*it);
      mid.erase(it);
    }
    
    if (mid.size() < n) {
      auto it = begin(right);
      sum += *it;
      mid.insert(*it);
      right.erase(it);
    }
  }
  
  queue<int> q;
  multiset<int> left, mid, right;  
  long sum;
  const int m;
  const int k;
  const int n;
};

The post 花花酱 LeetCode 1825. Finding MK Average appeared first on Huahua's Tech Road.

Given an array of integers nums and an integer limit, return the size of the longest continuous subarray such that the absolute difference between any two elements is less than or equal to limit.

In case there is no subarray satisfying the given condition return 0.

Example 1:

Input: nums = [8,2,4,7], limit = 4
Output: 2 
Explanation: All subarrays are: 
[8] with maximum absolute diff |8-8| = 0 <= 4.
[8,2] with maximum absolute diff |8-2| = 6 > 4. 
[8,2,4] with maximum absolute diff |8-2| = 6 > 4.
[8,2,4,7] with maximum absolute diff |8-2| = 6 > 4.
[2] with maximum absolute diff |2-2| = 0 <= 4.
[2,4] with maximum absolute diff |2-4| = 2 <= 4.
[2,4,7] with maximum absolute diff |2-7| = 5 > 4.
[4] with maximum absolute diff |4-4| = 0 <= 4.
[4,7] with maximum absolute diff |4-7| = 3 <= 4.
[7] with maximum absolute diff |7-7| = 0 <= 4. 
Therefore, the size of the longest subarray is 2.

Example 2:

Input: nums = [10,1,2,4,7,2], limit = 5
Output: 4 
Explanation: The subarray [2,4,7,2] is the longest since the maximum absolute diff is |2-7| = 5 <= 5.

Example 3:

Input: nums = [4,2,2,2,4,4,2,2], limit = 0
Output: 3

Constraints:

• 1 <= nums.length <= 10^5
• 1 <= nums[i] <= 10^9
• 0 <= limit <= 10^9

Solution 1: Sliding Window + TreeSet

Use a treeset to maintain a range of [l, r] such that max(nums[l~r]) – min(nums[l~r]) <= limit.
Every time, we add nums[r] into the tree, and move l towards r to keep the max diff under limit.

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

// Author: Huahua
class Solution {
public:
  int longestSubarray(vector<int>& nums, int limit) {
    multiset<int> s;
    int l = 0;
    int ans = 0;
    for (int r = 0; r < nums.size(); ++r) {
      s.insert(nums[r]);
      while (*rbegin(s) - *begin(s) > limit)
        s.erase(s.equal_range(nums[l++]).first);
      ans = max(ans, r - l + 1);
    }
    return ans;
  }
};

Solution 2: Dual Monotonic Queue

Similar to https://zxi.mytechroad.com/blog/dynamic-programming/leetcode-1425-constrained-subset-sum/

We want to maintain a range [l, r] that max(nums[l~r]) – min(nums[l~r]) <= limit, to track the max/min of a range efficiently we could use monotonic queue. One for max and one for min.

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

// Author: Huahua
class Solution {
public:
  int longestSubarray(vector<int>& nums, int limit) {
    deque<int> max_q;
    deque<int> min_q;
    int ans = 0;
    int l = 0;
    for (int r = 0; r < nums.size(); ++r) {
      while (!min_q.empty() && nums[r] < min_q.back()) 
        min_q.pop_back();
      while (!max_q.empty() && nums[r] > max_q.back()) 
        max_q.pop_back();
      min_q.push_back(nums[r]);
      max_q.push_back(nums[r]);
      while (max_q.front() - min_q.front() > limit) {
        if (max_q.front() == nums[l]) max_q.pop_front();
        if (min_q.front() == nums[l]) min_q.pop_front();
        ++l;
      }
      ans = max(ans, r - l + 1);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1438. Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit appeared first on Huahua's Tech Road.

Example 1:

Input: nums = [1,2,3,1], k = 3, t = 0
Output: true

Example 2:

Input: nums = [1,0,1,1], k = 1, t = 2
Output: true

Example 3:

Input: nums = [1,5,9,1,5,9], k = 2, t = 3
Output: false

Solution: Sliding Window + Multiset (OrderedSet)

Maintaining a sliding window of sorted numbers of k + 1. After the i-th number was inserted into the sliding window, check whether its left and right neighbors satisfy abs(nums[i] – neighbor) <= t

Time complexity: O(nlogk)
Space complexity: O(k)

// Author: Huahua, running time: 12 ms
class Solution {
public:
  bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
    multiset<long> s;
    for (int i = 0; i < nums.size(); ++i) {
      if (i > k)
        s.erase(s.find(nums[i - k - 1]));
            
      auto it = s.insert(nums[i]);
      if (it != begin(s) && *it - *prev(it) <= t)
        return true;
      if (next(it) != end(s) && *next(it) - *it <= t)
        return true;
    }
    return false;
  }
};

The post 花花酱 LeetCode 220. Contains Duplicate III appeared first on Huahua's Tech Road.

Suppose LeetCode will start its IPO soon. In order to sell a good price of its shares to Venture Capital, LeetCode would like to work on some projects to increase its capital before the IPO. Since it has limited resources, it can only finish at most k distinct projects before the IPO. Help LeetCode design the best way to maximize its total capital after finishing at most k distinct projects.

You are given several projects. For each project i, it has a pure profit P_i and a minimum capital of C_i is needed to start the corresponding project. Initially, you have W capital. When you finish a project, you will obtain its pure profit and the profit will be added to your total capital.

To sum up, pick a list of at most k distinct projects from given projects to maximize your final capital, and output your final maximized capital.

Example 1:

Input: k=2, W=0, Profits=[1,2,3], Capital=[0,1,1].

Output: 4

Explanation: Since your initial capital is 0, you can only start the project indexed 0.
             After finishing it you will obtain profit 1 and your capital becomes 1.
             With capital 1, you can either start the project indexed 1 or the project indexed 2.
             Since you can choose at most 2 projects, you need to finish the project indexed 2 to get the maximum capital.
             Therefore, output the final maximized capital, which is 0 + 1 + 3 = 4.

Note:

1. You may assume all numbers in the input are non-negative integers.
2. The length of Profits array and Capital array will not exceed 50,000.
3. The answer is guaranteed to fit in a 32-bit signed integer.

Solution: Greedy

For each round, find the most profitable job whose capital requirement <= W.

Finish that job and increase W.

Brute force (TLE)

Time complexity: O(kn)

Space complexity: O(1)

C++

class Solution {
public:
  int findMaximizedCapital(int k, int W, vector<int>& Profits, vector<int>& Capital) {
    for (int i = 0; i < k; ++i) {
      int best_j = -1;
      int best_profit = 0;
      for (int j = 0; j < Profits.size(); ++j) {
        if (Capital[j] <= W && Profits[j] > best_profit) {
          best_j = j;
          best_profit = Profits[j];
        }
      }
      if (best_profit == 0) break;
      W += Profits[best_j];
      Profits[best_j] = INT_MIN; // Used.
    }
    return W;
  }
};

Use priority queue and multiset to track doable and undoable projects at given W.

Time complexity: O(nlogn)

Space complexity: O(n)

// Author: Huahua
// Running time: 28 ms (beats 96.4%)
class Solution {
public:
  int findMaximizedCapital(int k, int W, vector<int>& Profits, vector<int>& Capital) {    
    priority_queue<int> doable;         // sorted by profit high to low.
    multiset<pair<int, int>> undoable;  // {capital, profit}
    for (int i = 0; i < Profits.size(); ++i) {
      if (Profits[i] <= 0) continue;
      if (Capital[i] <= W) 
        doable.push(Profits[i]);
      else
        undoable.emplace(Capital[i], Profits[i]);
    }
    auto it = undoable.cbegin();
    while (!doable.empty() && k--) {
      W += doable.top(); doable.pop();      
      while (it != undoable.cend() && it->first <= W)
        doable.push(it++->second);      
    }
    return W;
  }
};

Or use an array and sort by capital

// Author: Huahua
// Running time: 28 ms (beats 96.4%)
class Solution {
public:
  int findMaximizedCapital(int k, int W, vector<int>& Profits, vector<int>& Capital) {    
    priority_queue<int> doable;         // sorted by profit high to low.
    vector<pair<int, int>> undoable;    // {capital, profit}
    for (int i = 0; i < Profits.size(); ++i) {
      if (Profits[i] <= 0) continue;
      if (Capital[i] <= W) 
        doable.push(Profits[i]);
      else
        undoable.emplace_back(Capital[i], Profits[i]);
    }
    sort(begin(undoable), end(undoable));
    auto it = undoable.cbegin();
    while (!doable.empty() && k--) {
      W += doable.top(); doable.pop();      
      while (it != undoable.cend() && it->first <= W)
        doable.push(it++->second);      
    }
    return W;
  }
};

The post 花花酱 LeetCode 502. IPO appeared first on Huahua's Tech Road.

Given two arrays A and B of equal size, the advantage of A with respect to B is the number of indices i for which A[i] > B[i].

Return any permutation of A that maximizes its advantage with respect to B.

Input: A = [2,7,11,15], B = [1,10,4,11]
Output: [2,11,7,15]

Input: A = [12,24,8,32], B = [13,25,32,11]
Output: [24,32,8,12]

// Author: Huahua
// Running time: 124 ms
class Solution {
public:
  vector<int> advantageCount(vector<int>& A, vector<int>& B) {
    multiset<int> s(begin(A), end(A));
    vector<int> ans;    
    for (int b : B) {
      auto it = s.upper_bound(b);
      if (it == s.end()) it = s.begin();      
      ans.push_back(*it);
      s.erase(it);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 870. Advantage Shuffle appeared first on Huahua's Tech Road.