You are given a 0-indexed integer array scores of length n where scores[i] denotes the score of node i. You are also given a 2D integer array edges where edges[i] = [ai, bi] denotes that there exists an undirected edge connecting nodes ai and bi.

A node sequence is valid if it meets the following conditions:

• There is an edge connecting every pair of adjacent nodes in the sequence.
• No node appears more than once in the sequence.

The score of a node sequence is defined as the sum of the scores of the nodes in the sequence.

Return the maximum score of a valid node sequence with a length of 4. If no such sequence exists, return -1.

Example 1:

Input: scores = [5,2,9,8,4], edges = [[0,1],[1,2],[2,3],[0,2],[1,3],[2,4]]
Output: 24
Explanation: The figure above shows the graph and the chosen node sequence [0,1,2,3].
The score of the node sequence is 5 + 2 + 9 + 8 = 24.
It can be shown that no other node sequence has a score of more than 24.
Note that the sequences [3,1,2,0] and [1,0,2,3] are also valid and have a score of 24.
The sequence [0,3,2,4] is not valid since no edge connects nodes 0 and 3.

Example 2:

Input: scores = [9,20,6,4,11,12], edges = [[0,3],[5,3],[2,4],[1,3]]
Output: -1
Explanation: The figure above shows the graph.
There are no valid node sequences of length 4, so we return -1.

Constraints:

• n == scores.length
• 4 <= n <= 5 * 104
• 1 <= scores[i] <= 108
• 0 <= edges.length <= 5 * 104
• edges[i].length == 2
• 0 <= ai, bi <= n - 1
• ai != bi
• There are no duplicate edges.

Solution: Greedy / Top3 neighbors

Since |E| is already 5*10⁴, we can’t enumerate all possible sequences. We must do in O(|E|) or O(|E|log|E|).

Enumerate all the edges, we have a pair of node a, b. To get the optimal answer, we just need to find the largest neighbor of a and b, which we call c, d respectively. Just need to make sure a, b, c, d are unique. i.e. c != d, c != b and d != a. Since the a’s largest neighbor can be either b or d. We can’t just store the largest neighbor, but top 3 instead for each node to avoid duplications.

Time complexity: O(|E|*9)
Space complexity: O(|V|*3)

// Author: Huahua
class Solution {
public:
  int maximumScore(vector<int>& scores, vector<vector<int>>& edges) {
    const int n = scores.size();
    vector<set<pair<int, int>>> top3(n);
    for (const auto& e : edges) {      
      top3[e[0]].emplace(scores[e[1]], e[1]);
      top3[e[1]].emplace(scores[e[0]], e[0]);
      if (top3[e[0]].size() > 3) top3[e[0]].erase(begin(top3[e[0]]));
      if (top3[e[1]].size() > 3) top3[e[1]].erase(begin(top3[e[1]]));
    }
    int ans = -1;
    for (const auto& e : edges) {
      const int a = e[0], b = e[1], sa = scores[a], sb = scores[b];
      for (const auto& [sc, c] : top3[a])
        for (const auto& [sd, d] : top3[b])          
          if (sa + sb + sc + sd > ans && c != b && c != d && d != a)
            ans = sa + sb + sc + sd;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2242. Maximum Score of a Node Sequence appeared first on Huahua's Tech Road.

Return the minimum number of operations to reduce the sum of nums by at least half.

Example 1:

Input: nums = [5,19,8,1]
Output: 3
Explanation: The initial sum of nums is equal to 5 + 19 + 8 + 1 = 33.
The following is one of the ways to reduce the sum by at least half:
Pick the number 19 and reduce it to 9.5.
Pick the number 9.5 and reduce it to 4.75.
Pick the number 8 and reduce it to 4.
The final array is [5, 4.75, 4, 1] with a total sum of 5 + 4.75 + 4 + 1 = 14.75. 
The sum of nums has been reduced by 33 - 14.75 = 18.25, which is at least half of the initial sum, 18.25 >= 33/2 = 16.5.
Overall, 3 operations were used so we return 3.
It can be shown that we cannot reduce the sum by at least half in less than 3 operations.

Example 2:

Input: nums = [3,8,20]
Output: 3
Explanation: The initial sum of nums is equal to 3 + 8 + 20 = 31.
The following is one of the ways to reduce the sum by at least half:
Pick the number 20 and reduce it to 10.
Pick the number 10 and reduce it to 5.
Pick the number 3 and reduce it to 1.5.
The final array is [1.5, 8, 5] with a total sum of 1.5 + 8 + 5 = 14.5. 
The sum of nums has been reduced by 31 - 14.5 = 16.5, which is at least half of the initial sum, 16.5 >= 31/2 = 16.5.
Overall, 3 operations were used so we return 3.
It can be shown that we cannot reduce the sum by at least half in less than 3 operations.

Constraints:

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 107

Solution: Greedy + PriorityQueue/Max Heap

Always half the largest number, put all the numbers onto a max heap (priority queue), extract the largest one, and put reduced number back.

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

// Author: Huahua
class Solution {
public:
  int halveArray(vector<int>& nums) {
    double sum = accumulate(begin(nums), end(nums), 0.0);
    priority_queue<double> q;
    for (int num : nums) q.push(num);
    int ans = 0;
    for (double cur = sum; cur > sum / 2; ++ans) {    
      double num = q.top(); q.pop();
      cur -= num / 2;
      q.push(num / 2);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2208. Minimum Operations to Halve Array Sum appeared first on Huahua's Tech Road.

• Choose any piles[i] and remove floor(piles[i] / 2) stones from it.

Notice that you can apply the operation on the same pile more than once.

Return the minimum possible total number of stones remaining after applying the k operations.

floor(x) is the greatest integer that is smaller than or equal to x (i.e., rounds x down).

Example 1:

Input: piles = [5,4,9], k = 2
Output: 12
Explanation: Steps of a possible scenario are:
- Apply the operation on pile 2. The resulting piles are [5,4,5].
- Apply the operation on pile 0. The resulting piles are [3,4,5].
The total number of stones in [3,4,5] is 12.

Example 2:

Input: piles = [4,3,6,7], k = 3
Output: 12
Explanation: Steps of a possible scenario are:
- Apply the operation on pile 2. The resulting piles are [4,3,3,7].
- Apply the operation on pile 3. The resulting piles are [4,3,3,4].
- Apply the operation on pile 0. The resulting piles are [2,3,3,4].
The total number of stones in [2,3,3,4] is 12.

Constraints:

• 1 <= piles.length <= 105
• 1 <= piles[i] <= 104
• 1 <= k <= 105

Solution: Greedy / Heap

Always choose the largest pile to remove.

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

// Author: Huahua
class Solution {
public:
  int minStoneSum(vector<int>& piles, int k) {
    int total = accumulate(begin(piles), end(piles), 0);
    priority_queue<int> q(begin(piles), end(piles));
    while (k--) {
      int curr = q.top(); q.pop();
      int remove = curr / 2;
      total -= remove;
      q.push(curr - remove);
    }
    return total;
  }
};

The post 花花酱 LeetCode 1962. Remove Stones to Minimize the Total appeared first on Huahua's Tech Road.

• For example, if chairs 0, 1, and 5 are occupied when a friend comes, they will sit on chair number 2.

When a friend leaves the party, their chair becomes unoccupied at the moment they leave. If another friend arrives at that same moment, they can sit in that chair.

You are given a 0-indexed 2D integer array times where times[i] = [arrivali, leavingi], indicating the arrival and leaving times of the ith friend respectively, and an integer targetFriend. All arrival times are distinct.

Return the chair number that the friend numbered targetFriend will sit on.

Example 1:

Input: times = [[1,4],[2,3],[4,6]], targetFriend = 1
Output: 1
Explanation: 
- Friend 0 arrives at time 1 and sits on chair 0.
- Friend 1 arrives at time 2 and sits on chair 1.
- Friend 1 leaves at time 3 and chair 1 becomes empty.
- Friend 0 leaves at time 4 and chair 0 becomes empty.
- Friend 2 arrives at time 4 and sits on chair 0.
Since friend 1 sat on chair 1, we return 1.

Example 2:

Input: times = [[3,10],[1,5],[2,6]], targetFriend = 0
Output: 2
Explanation: 
- Friend 1 arrives at time 1 and sits on chair 0.
- Friend 2 arrives at time 2 and sits on chair 1.
- Friend 0 arrives at time 3 and sits on chair 2.
- Friend 1 leaves at time 5 and chair 0 becomes empty.
- Friend 2 leaves at time 6 and chair 1 becomes empty.
- Friend 0 leaves at time 10 and chair 2 becomes empty.
Since friend 0 sat on chair 2, we return 2.

Constraints:

• n == times.length
• 2 <= n <= 104
• times[i].length == 2
• 1 <= arrivali < leavingi <= 105
• 0 <= targetFriend <= n - 1
• Each arrivali time is distinct.

Solution: Treeset + Simulation

Use a treeset to track available chairs, sort events by time.
note: process leaving events first.

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

// Author: Huahua
class Solution {
public:
  int smallestChair(vector<vector<int>>& times, int targetFriend) {
    const int n = times.size();
    vector<pair<int, int>> arrival(n);
    vector<pair<int, int>> leaving(n);
    for (int i = 0; i < n; ++i) {
      arrival[i] = {times[i][0], i};
      leaving[i] = {times[i][1], i};
    }
    vector<int> pos(n);
    iota(begin(pos), end(pos), 0); // pos = [0, 1, ..., n -1]
    set<int> aval(begin(pos), end(pos));    
    sort(begin(arrival), end(arrival));
    sort(begin(leaving), end(leaving));
    for (int i = 0, j = 0; i < n; ++i) {
      const auto [t, u] = arrival[i];
      while (j < n && leaving[j].first <= t)        
        aval.insert(pos[leaving[j++].second]);        
      aval.erase(pos[u] = *begin(aval));      
      if (u == targetFriend) return pos[u];
    }
    return -1;
  }
};

The post 花花酱 LeetCode 1942. The Number of the Smallest Unoccupied Chair appeared first on Huahua's Tech Road.

Return this maximum sum.

Note that the start time and end time is inclusive: that is, you cannot attend two events where one of them starts and the other ends at the same time. More specifically, if you attend an event with end time t, the next event must start at or after t + 1.

Example 1:

Input: events = [[1,3,2],[4,5,2],[2,4,3]]
Output: 4
Explanation: Choose the green events, 0 and 1 for a sum of 2 + 2 = 4.

Example 2:

Input: events = [[1,3,2],[4,5,2],[1,5,5]]
Output: 5
Explanation: Choose event 2 for a sum of 5.

Example 3:

Input: events = [[1,5,3],[1,5,1],[6,6,5]]
Output: 8
Explanation: Choose events 0 and 2 for a sum of 3 + 5 = 8.

Constraints:

• 2 <= events.length <= 105
• events[i].length == 3
• 1 <= startTimei <= endTimei <= 109
• 1 <= valuei <= 106

Solution: Sort + Heap

Sort events by start time, process them from left to right.

Use a min heap to store the events processed so far, a variable cur to track the max value of a non-overlapping event.

For a given event, pop all non-overlapping events whose end time is smaller than its start time and update cur.

ans = max(val + cur)

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

// Author: Huahua
class Solution {
public:
  int maxTwoEvents(vector<vector<int>>& events) {
    using E = pair<int,int>;
    sort(begin(events), end(events));
    priority_queue<E, vector<E>, greater<E>> q; // (end_time, val)
    int ans = 0;
    int cur = 0;
    for (const auto& e : events) {
      while (!q.empty() && q.top().first < e[0]) {
        cur = max(cur, q.top().second);
        q.pop();
      }
      ans = max(ans, cur + e[2]);
      q.emplace(e[1], e[2]);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2054. Two Best Non-Overlapping Events appeared first on Huahua's Tech Road.

• 0 if it is a batch of buy orders, or
• 1 if it is a batch of sell orders.

Note that orders[i] represents a batch of amounti independent orders with the same price and order type. All orders represented by orders[i] will be placed before all orders represented by orders[i+1] for all valid i.

There is a backlog that consists of orders that have not been executed. The backlog is initially empty. When an order is placed, the following happens:

• If the order is a buy order, you look at the sell order with the smallest price in the backlog. If that sell order’s price is smaller than or equal to the current buy order’s price, they will match and be executed, and that sell order will be removed from the backlog. Else, the buy order is added to the backlog.
• Vice versa, if the order is a sell order, you look at the buy order with the largest price in the backlog. If that buy order’s price is larger than or equal to the current sell order’s price, they will match and be executed, and that buy order will be removed from the backlog. Else, the sell order is added to the backlog.

Return the total amount of orders in the backlog after placing all the orders from the input. Since this number can be large, return it modulo 109 + 7.

Example 1:

Input: orders = [[10,5,0],[15,2,1],[25,1,1],[30,4,0]]
Output: 6
Explanation: Here is what happens with the orders:
- 5 orders of type buy with price 10 are placed. There are no sell orders, so the 5 orders are added to the backlog.
- 2 orders of type sell with price 15 are placed. There are no buy orders with prices larger than or equal to 15, so the 2 orders are added to the backlog.
- 1 order of type sell with price 25 is placed. There are no buy orders with prices larger than or equal to 25 in the backlog, so this order is added to the backlog.
- 4 orders of type buy with price 30 are placed. The first 2 orders are matched with the 2 sell orders of the least price, which is 15 and these 2 sell orders are removed from the backlog. The 3rd order is matched with the sell order of the least price, which is 25 and this sell order is removed from the backlog. Then, there are no more sell orders in the backlog, so the 4th order is added to the backlog.
Finally, the backlog has 5 buy orders with price 10, and 1 buy order with price 30. So the total number of orders in the backlog is 6.

Example 2:

Input: orders = [[7,1000000000,1],[15,3,0],[5,999999995,0],[5,1,1]]
Output: 999999984
Explanation: Here is what happens with the orders:
- 109 orders of type sell with price 7 are placed. There are no buy orders, so the 109 orders are added to the backlog.
- 3 orders of type buy with price 15 are placed. They are matched with the 3 sell orders with the least price which is 7, and those 3 sell orders are removed from the backlog.
- 999999995 orders of type buy with price 5 are placed. The least price of a sell order is 7, so the 999999995 orders are added to the backlog.
- 1 order of type sell with price 5 is placed. It is matched with the buy order of the highest price, which is 5, and that buy order is removed from the backlog.
Finally, the backlog has (1000000000-3) sell orders with price 7, and (999999995-1) buy orders with price 5. So the total number of orders = 1999999991, which is equal to 999999984 % (109 + 7).

Constraints:

• 1 <= orders.length <= 105
• orders[i].length == 3
• 1 <= pricei, amounti <= 109
• orderTypei is either 0 or 1.

Solution: Treemap / PriorityQueue / Heap

buy backlog: max heap
sell backlog: min heap
Trade happens between the tops of two queues.

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

// Author: Huahua
class Solution {
public:
  int getNumberOfBacklogOrders(vector<vector<int>>& orders) {  
    constexpr int kMod = 1e9 + 7;
    map<int64_t, int64_t> buys;
    map<int64_t, int64_t> sells;
    for (const auto& order : orders) {      
      auto& m = order[2] == 0 ? buys : sells;
      m[order[0]] += order[1];
      while (buys.size() && sells.size()) {
        auto b = rbegin(buys);
        auto s = begin(sells);
        if (b->first < s->first) break;
        const int k = min(b->second, s->second);
        if (!(b->second -= k)) buys.erase((++b).base());
        if (!(s->second -= k)) sells.erase(s);
      }
    }
    int64_t ans = 0;
    for (const auto& [p, c] : buys) ans += c;
    for (const auto& [p, c] : sells) ans += c;    
    return ans % kMod;
  }
};

The post LeetCode 1801. Number of Orders in the Backlog appeared first on Huahua's Tech Road.

There is a school that has classes of students and each class will be having a final exam. You are given a 2D integer array classes, where classes[i] = [passi, totali]. You know beforehand that in the ith class, there are totali total students, but only passi number of students will pass the exam.

You are also given an integer extraStudents. There are another extraStudents brilliant students that are guaranteed to pass the exam of any class they are assigned to. You want to assign each of the extraStudents students to a class in a way that maximizes the average pass ratio across all the classes.

The pass ratio of a class is equal to the number of students of the class that will pass the exam divided by the total number of students of the class. The average pass ratio is the sum of pass ratios of all the classes divided by the number of the classes.

Return the maximum possible average pass ratio after assigning the extraStudents students. Answers within 10-5 of the actual answer will be accepted.

Example 1:

Input: classes = [[1,2],[3,5],[2,2]], extraStudents = 2
Output: 0.78333
Explanation: You can assign the two extra students to the first class. The average pass ratio will be equal to (3/4 + 3/5 + 2/2) / 3 = 0.78333.

Example 2:

Input: classes = [[2,4],[3,9],[4,5],[2,10]], extraStudents = 4
Output: 0.53485

Constraints:

• 1 <= classes.length <= 105
• classes[i].length == 2
• 1 <= passi <= totali <= 105
• 1 <= extraStudents <= 105

Solution: Greedy + Heap

Sort by the ratio increase potential (p + 1) / (t + 1) – p / t.

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

// Author: Huahua
class Solution {
public:
  double maxAverageRatio(vector<vector<int>>& classes, int extraStudents) {
    const int n = classes.size();
    auto ratio = [&](int i, int delta = 0) {
      return static_cast<double>(classes[i][0] + delta) / 
        (classes[i][1] + delta);
    };
    priority_queue<pair<double, int>> q;
    for (int i = 0; i < n; ++i)
      q.emplace(ratio(i, 1) - ratio(i), i);
    while (extraStudents--) {
      const auto [r, i] = q.top(); q.pop();      
      ++classes[i][0];
      ++classes[i][1];
      q.emplace(ratio(i, 1) - ratio(i), i);
    }
    double total_ratio = 0;
    for (int i = 0; i < n; ++i)
      total_ratio += ratio(i);
    return total_ratio / n;
  }
};

# Author: Huahua
class Solution:
  def maxAverageRatio(self, classes: List[List[int]], extraStudents: int) -> float:
    def ratio(i, delta=0):
      return (classes[i][0] + delta) / (classes[i][1] + delta)
    q = []
    for i, c in enumerate(classes):
      heapq.heappush(q, (-(ratio(i, 1) - ratio(i)), i))
    for _ in range(extraStudents):
      _, i = heapq.heappop(q)
      classes[i][0] += 1
      classes[i][1] += 1
      heapq.heappush(q, (-(ratio(i, 1) - ratio(i)), i))
    return mean(ratio(i) for i, _ in enumerate(classes))

The post 花花酱 LeetCode 1792. Maximum Average Pass Ratio appeared first on Huahua's Tech Road.

You decided to eat at most one apple a day (to keep the doctors away). Note that you can keep eating after the first n days.

Given two integer arrays days and apples of length n, return the maximum number of apples you can eat.

Example 1:

Input: apples = [1,2,3,5,2], days = [3,2,1,4,2]
Output: 7
Explanation: You can eat 7 apples:
- On the first day, you eat an apple that grew on the first day.
- On the second day, you eat an apple that grew on the second day.
- On the third day, you eat an apple that grew on the second day. After this day, the apples that grew on the third day rot.
- On the fourth to the seventh days, you eat apples that grew on the fourth day.

Example 2:

Input: apples = [3,0,0,0,0,2], days = [3,0,0,0,0,2]
Output: 5
Explanation: You can eat 5 apples:
- On the first to the third day you eat apples that grew on the first day.
- Do nothing on the fouth and fifth days.
- On the sixth and seventh days you eat apples that grew on the sixth day.

Constraints:

• apples.length == n
• days.length == n
• 1 <= n <= 2 * 104
• 0 <= apples[i], days[i] <= 2 * 104
• days[i] = 0 if and only if apples[i] = 0.

Solution: PriorityQueue

Sort by rotten day in ascending order, only push onto the queue when that day has come (be able to grow apples).

Time complexity: O((n+ d)logn)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  int eatenApples(vector<int>& apples, vector<int>& days) {
    const int n = apples.size();
    using P = pair<int, int>;    
    priority_queue<P, vector<P>, greater<P>> q; // {rotten_day, index}    
    int ans = 0;
    for (int d = 0; d < n || !q.empty(); ++d) {
      if (d < n && apples[d]) q.emplace(d + days[d], d);
      while (!q.empty() 
             && (q.top().first <= d || apples[q.top().second] == 0)) q.pop();
      if (q.empty()) continue;
      --apples[q.top().second];      
      ++ans;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1705. Maximum Number of Eaten Apples appeared first on Huahua's Tech Road.

You are given an integer array heights representing the heights of buildings, some bricks, and some ladders.

You start your journey from building 0 and move to the next building by possibly using bricks or ladders.

While moving from building i to building i+1 (0-indexed),

• If the current building’s height is greater than or equal to the next building’s height, you do not need a ladder or bricks.
• If the current building’s height is less than the next building’s height, you can either use one ladder or (h[i+1] - h[i]) bricks.

Return the furthest building index (0-indexed) you can reach if you use the given ladders and bricks optimally.

Example 1:

Input: heights = [4,2,7,6,9,14,12], bricks = 5, ladders = 1
Output: 4
Explanation: Starting at building 0, you can follow these steps:
- Go to building 1 without using ladders nor bricks since 4 >= 2.
- Go to building 2 using 5 bricks. You must use either bricks or ladders because 2 < 7.
- Go to building 3 without using ladders nor bricks since 7 >= 6.
- Go to building 4 using your only ladder. You must use either bricks or ladders because 6 < 9.
It is impossible to go beyond building 4 because you do not have any more bricks or ladders.

Example 2:

Input: heights = [4,12,2,7,3,18,20,3,19], bricks = 10, ladders = 2
Output: 7

Example 3:

Input: heights = [14,3,19,3], bricks = 17, ladders = 0
Output: 3

Constraints:

• 1 <= heights.length <= 105
• 1 <= heights[i] <= 106
• 0 <= bricks <= 109
• 0 <= ladders <= heights.length

Solution 0: DFS

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

AC but should be TLE

Solution 1: Binary Search + Greedy

Guess we can reach to m, sort the height differences from 0~m. Use ladders for larger values and use bricks for smallest values left.

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

// Author: Huahua, 300 ms
class Solution {
public:
  int furthestBuilding(vector<int>& heights, int bricks, int ladders) {
    const int n = heights.size();
    if (ladders >= n - 1) return n - 1;
    vector<int>  diffs(n);
    for (int i = 1; i < n; ++i)
      diffs[i - 1] = max(0, heights[i] - heights[i - 1]);
    int l = ladders;
    int r = n;
    while (l < r) {
      int m = l + (r - l) / 2;
      vector<int> d(begin(diffs), begin(diffs) + m);
      nth_element(begin(d), end(d) - ladders, end(d));
      if (accumulate(begin(d), end(d) - ladders, 0) > bricks)
        r = m;
      else
        l = m + 1;
    }
    return l - 1;
  }
};

Solution 2: Min heap

Use a min heap to store all the height differences ( > 0) so far, if heap size is greater than ladders, which means we have to use bricks, extract the smallest value and subtract the bricks.

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

// Author: Huahua, 216 ms
class Solution {
public:
  int furthestBuilding(vector<int>& heights, int bricks, int ladders) {
    const int n = heights.size();        
    priority_queue<int, vector<int>, greater<int>> q;
    for (int i = 1; i < n; ++i) {
      const int d = heights[i] - heights[i - 1];
      if (d <= 0) continue;
      q.push(d);
      if (q.size() <= ladders) continue;
      bricks -= q.top(); q.pop();
      if (bricks < 0) return i - 1;      
    }
    return n - 1;
  }
};

The post 花花酱 LeetCode 1642. Furthest Building You Can Reach appeared first on Huahua's Tech Road.

You have k servers numbered from 0 to k-1 that are being used to handle multiple requests simultaneously. Each server has infinite computational capacity but cannot handle more than one request at a time. The requests are assigned to servers according to a specific algorithm:

• The ith (0-indexed) request arrives.
• If all servers are busy, the request is dropped (not handled at all).
• If the (i % k)th server is available, assign the request to that server.
• Otherwise, assign the request to the next available server (wrapping around the list of servers and starting from 0 if necessary). For example, if the ith server is busy, try to assign the request to the (i+1)th server, then the (i+2)th server, and so on.

You are given a strictly increasing array arrival of positive integers, where arrival[i] represents the arrival time of the ith request, and another array load, where load[i] represents the load of the ith request (the time it takes to complete). Your goal is to find the busiest server(s). A server is considered busiest if it handled the most number of requests successfully among all the servers.

Return a list containing the IDs (0-indexed) of the busiest server(s). You may return the IDs in any order.

Example 1:

Input: k = 3, arrival = [1,2,3,4,5], load = [5,2,3,3,3] 
Output: [1] 
Explanation:
All of the servers start out available.
The first 3 requests are handled by the first 3 servers in order.
Request 3 comes in. Server 0 is busy, so it's assigned to the next available server, which is 1.
Request 4 comes in. It cannot be handled since all servers are busy, so it is dropped.
Servers 0 and 2 handled one request each, while server 1 handled two requests. Hence server 1 is the busiest server.

Example 2:

Input: k = 3, arrival = [1,2,3,4], load = [1,2,1,2]
Output: [0]
Explanation:
The first 3 requests are handled by first 3 servers.
Request 3 comes in. It is handled by server 0 since the server is available.
Server 0 handled two requests, while servers 1 and 2 handled one request each. Hence server 0 is the busiest server.

Example 3:

Input: k = 3, arrival = [1,2,3], load = [10,12,11]
Output: [0,1,2]
Explanation: Each server handles a single request, so they are all considered the busiest.

Example 4:

Input: k = 3, arrival = [1,2,3,4,8,9,10], load = [5,2,10,3,1,2,2]
Output: [1]

Example 5:

Input: k = 1, arrival = [1], load = [1]
Output: [0]

Constraints:

• 1 <= k <= 105
• 1 <= arrival.length, load.length <= 105
• arrival.length == load.length
• 1 <= arrival[i], load[i] <= 109
• arrival is strictly increasing.

Solution: Heap + TreeSet

Use a min heap to store the release time -> server.
Use a treeset to track the current available servers.
For reach request, check whether servers can be released at that time.

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

// Author: Huahua
class Solution {
public:
  vector<int> busiestServers(int k, vector<int>& arrival, vector<int>& load) {
    priority_queue<pair<int, int>, vector<pair<int,int>>, greater<>> q; // {release_time, server}
    set<int> servers;
    vector<int> requests(k);
    
    for (int i = 0; i < k; ++i)
      servers.insert(i);
    
    for (int i = 0; i < arrival.size(); ++i) {
      const int t = arrival[i];
      const int l = load[i];
      
      // Release servers. O(logk) per pop()
      while (!q.empty() && q.top().first <= t) {        
        servers.insert(q.top().second);  
        q.pop();
      }
      
      // Drop the request.
      if (servers.empty()) continue;
      
      // Find first avaiable one O(logk)
      auto it = servers.lower_bound(i % k);
      if (it == servers.end()) it = begin(servers);
      const int idx = *it;
      
      ++requests[idx];
      servers.erase(it);
      q.emplace(t + l, idx);
    }
    const int max_req = *max_element(begin(requests), end(requests));
    vector<int> ans;
    for (int i = 0; i < k; ++i)
      if (requests[i] == max_req) ans.push_back(i);
    return ans;
  }
};

The post 花花酱 LeetCode 1606. Find Servers That Handled Most Number of Requests appeared first on Huahua's Tech Road.

Given an integer array rains where:

• rains[i] > 0 means there will be rains over the rains[i] lake.
• rains[i] == 0 means there are no rains this day and you can choose one lake this day and dry it.

Return an array ans where:

• ans.length == rains.length
• ans[i] == -1 if rains[i] > 0.
• ans[i] is the lake you choose to dry in the ith day if rains[i] == 0.

If there are multiple valid answers return any of them. If it is impossible to avoid flood return an empty array.

Notice that if you chose to dry a full lake, it becomes empty, but if you chose to dry an empty lake, nothing changes. (see example 4)

Example 1:

Input: rains = [1,2,3,4]
Output: [-1,-1,-1,-1]
Explanation: After the first day full lakes are [1]
After the second day full lakes are [1,2]
After the third day full lakes are [1,2,3]
After the fourth day full lakes are [1,2,3,4]
There's no day to dry any lake and there is no flood in any lake.

Example 2:

Input: rains = [1,2,0,0,2,1]
Output: [-1,-1,2,1,-1,-1]
Explanation: After the first day full lakes are [1]
After the second day full lakes are [1,2]
After the third day, we dry lake 2. Full lakes are [1]
After the fourth day, we dry lake 1. There is no full lakes.
After the fifth day, full lakes are [2].
After the sixth day, full lakes are [1,2].
It is easy that this scenario is flood-free. [-1,-1,1,2,-1,-1] is another acceptable scenario.

Example 3:

Input: rains = [1,2,0,1,2]
Output: []
Explanation: After the second day, full lakes are  [1,2]. We have to dry one lake in the third day.
After that, it will rain over lakes [1,2]. It's easy to prove that no matter which lake you choose to dry in the 3rd day, the other one will flood.

Example 4:

Input: rains = [69,0,0,0,69]
Output: [-1,69,1,1,-1]
Explanation: Any solution on one of the forms [-1,69,x,y,-1], [-1,x,69,y,-1] or [-1,x,y,69,-1] is acceptable where 1 <= x,y <= 10^9

Example 5:

Input: rains = [10,20,20]
Output: []
Explanation: It will rain over lake 20 two consecutive days. There is no chance to dry any lake.

Constraints:

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

Solution: Binary Search

Store the days we can dry a lake in a treeset.
Store the last day when a lake becomes full in a hashtable.
Whenever we encounter a full lake, try to find the first available day that we can dry it. If no such day, return no answer.

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

// Author: Huahua
class Solution {
public:
  vector<int> avoidFlood(vector<int>& rains) {   
    const int n = rains.size();
    vector<int> ans(n, -1);
    unordered_map<int, int> full; // lake -> day
    set<int> dry; // days we can dry lakes.
    for (int i = 0; i < n; ++i) {
      const int lake = rains[i];
      if (lake > 0) {
        if (full.count(lake)) {
          // Find the first day we can dry it.
          auto it = dry.upper_bound(full[lake]);
          if (it == end(dry)) return {};
          ans[*it] = lake;
          dry.erase(it);
        }
        full[lake] = i;
      } else {
        dry.insert(i);
        ans[i] = 1;
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1488. Avoid Flood in The City appeared first on Huahua's Tech Road.

Given a list of trips, trip[i] = [num_passengers, start_location, end_location] contains information about the i-th trip: the number of passengers that must be picked up, and the locations to pick them up and drop them off.  The locations are given as the number of kilometers due east from your vehicle’s initial location.

Return true if and only if it is possible to pick up and drop off all passengers for all the given trips. 

Example 1:

Input: trips = [[2,1,5],[3,3,7]], capacity = 4
Output: false

Example 2:

Input: trips = [[2,1,5],[3,3,7]], capacity = 5
Output: true

Example 3:

Input: trips = [[2,1,5],[3,5,7]], capacity = 3
Output: true

Example 4:

Input: trips = [[3,2,7],[3,7,9],[8,3,9]], capacity = 11
Output: true

Solution1: Min heap

Sort events by location

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

// Author: Huahua
class Solution {
public:
  bool carPooling(vector<vector<int>>& trips, int capacity) {
    priority_queue<int> q;
    for (const auto& trip : trips) {
      int pick_up = -((trip[1] << 10) | (1 << 9) | trip[0]);
      int drop_off = -((trip[2] << 10) | trip[0]);
      q.push(pick_up);
      q.push(drop_off);
    }
    while (q.size()) {
      int key = -q.top(); q.pop();
      int sign = ((key >> 9) & 1) ? 1: -1;
      int num = key & 0xFF;
      if ((capacity -= sign * num) < 0)
        return false;
    }
    return true;
  }
};

Solution 2: Preprocessing

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

// Author: Huahua
class Solution {
public:
  bool carPooling(vector<vector<int>>& trips, int capacity) {
    vector<int> d(1001);
    for (const auto& trip : trips) {
      d[trip[1]] -= trip[0];
      d[trip[2]] += trip[0];
    }
    for (const int c : d) 
      if ((capacity += c) < 0) return false;
    return true;
  }
};

The post 花花酱 LeetCode 1094. Car Pooling appeared first on Huahua's Tech Road.

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Example:

Input:
[
  1->4->5,
  1->3->4,
  2->6
]
Output: 1->1->2->3->4->4->5->6

Solution 1: Brute Force

Time complexity: O(nk)

Space complexity: O(1)

// Author: Huahua, 420 ms
class Solution {
public:
  ListNode* mergeKLists(vector<ListNode*>& lists) {
    ListNode dummy(0);
    ListNode *cur = &dummy;
    while (true) {
      ListNode** min_head = nullptr;
      for (auto& head : lists) {          
        if (!head) continue;        
        if (!min_head || head->val < (*min_head)->val)
          min_head = &head;
      }
      if (!min_head) break;
      cur->next = new ListNode((*min_head)->val);
      cur = cur->next;
      *min_head = (*min_head)->next;      
    }
    return dummy.next;
  }
};

Solution 2: Heap / Priority Queue

Time complexity: O(nlogk)

Space complexity: O(k)

// Author: Huahua, 16 ms (<99.88%)
class Solution {
public:
  ListNode* mergeKLists(vector<ListNode*>& lists) {
    ListNode dummy(0);
    ListNode *cur = &dummy;
    
    auto comp = [](ListNode* a, ListNode* b) { return a->val > b->val; };
    priority_queue<ListNode*, vector<ListNode*>, decltype(comp)> q(comp);
    
    for (ListNode* list : lists) 
      if (list) q.push(list);
    
    while (!q.empty()) {
      cur->next = q.top(); q.pop();      
      cur = cur->next;
      if (cur->next) q.push(cur->next);
    }
    return dummy.next;
  }
};

The post 花花酱 LeetCode 23. Merge k Sorted Lists appeared first on Huahua's Tech Road.

Problem

Given an integer array, find three numbers whose product is maximum and output the maximum product.

Example 1:

Input: [1,2,3]
Output: 6

Example 2:

Input: [1,2,3,4]
Output: 24

Note:

1. The length of the given array will be in range [3,10⁴] and all elements are in the range [-1000, 1000].
2. Multiplication of any three numbers in the input won’t exceed the range of 32-bit signed integer.

Idea:

Find the top 3 numbers t1, t2, t3, and bottom 2 numbers, b1, b2.

If all numbers are positives,  answer must be t1 * t2 * t3.

Since the number can go negative, the answer must be either t1*t2*t3 or b1 * b2 * t1, if b1 and b2 are both negatives.

ex. nums: [5, 1, -6, 3, -1]

t1, t2, t3: 5, 3, 1

b1, b2: -6, -1

t1 * t2 * t3 = 15

t1 * b1 * b2 = 30

Solution 1: Manual Tracking

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua
// Running time: 28 ms
class Solution {
public:
  int maximumProduct(vector<int>& nums) {
    int max1 = INT_MIN;
    int max2 = INT_MIN;
    int max3 = INT_MIN;
    int min1 = INT_MAX;
    int min2 = INT_MAX;

    for (const int num: nums) {
      if (num > max1) {
          max3 = max2;
          max2 = max1;
          max1 = num;
      } else if (num > max2) {
          max3 = max2;
          max2 = num;
      } else if (num > max3) {
          max3=num;
      }

      if (num < min1) {
          min2 = min1;
          min1 = num;
      } else if (num < min2) {
          min2=num;
      }
    }

    return max(max1*max2*max3, max1*min1*min2);
  }
};

Solution 2: Sorting

Time complexity: O(nlogn)

Space complexity: O(1)

// Author: Huahua
// Running time: 48 ms
class Solution {
public:
  int maximumProduct(vector<int>& nums) {
    int n = nums.size();
    sort(nums.rbegin(), nums.rend());
    return max(nums[0] * nums[1] * nums[2], nums[0] * nums[n - 1] * nums[n - 2]);
  }
};

Solution 3: Two Heaps (Priority Queues)

Time complexity: O(nlog3)

Space complexity: O(2 + 3)

// Author: Huahua
// Running time: 40 ms
class Solution {
public:
  int maximumProduct(vector<int>& nums) {
    priority_queue<int, vector<int>, less<int>> min_q; // max_heap
    priority_queue<int, vector<int>, greater<int>> max_q; // min_heap
    
    for (int num : nums) {
      max_q.push(num);
      if (max_q.size() > 3) max_q.pop();
      min_q.push(num);
      if (min_q.size() > 2) min_q.pop();
    }
    
    int max3 = max_q.top(); max_q.pop();
    int max2 = max_q.top(); max_q.pop();
    int max1 = max_q.top(); max_q.pop();
    int min2 = min_q.top(); min_q.pop();
    int min1 = min_q.top(); min_q.pop();
    
    return max(max1 * max2 * max3, max1 * min1 * min2); 
  }
};

The post 花花酱 LeetCode 628. Maximum Product of Three Numbers appeared first on Huahua's Tech Road.

Design a class to find the kth largest element in a stream. Note that it is the kth largest element in the sorted order, not the kth distinct element.

Your KthLargest class will have a constructor which accepts an integer k and an integer array nums, which contains initial elements from the stream. For each call to the method KthLargest.add, return the element representing the kth largest element in the stream.

Example:

int k = 3;
int[] arr = [4,5,8,2];
KthLargest kthLargest = new KthLargest(3, arr);
kthLargest.add(3);   // returns 4
kthLargest.add(5);   // returns 5
kthLargest.add(10);  // returns 5
kthLargest.add(9);   // returns 8
kthLargest.add(4);   // returns 8

Note: 
You may assume that nums‘ length ≥ k-1 and k ≥ 1.

Solution: BST / Min Heap

Time complexity: O(nlogk)

Space complexity: O(k)

C++ / BST

// Author: Huahua
// Running time: 32 ms
class KthLargest {
public:
  KthLargest(int k, vector<int> nums): k_(k) {
    for (int num : nums)
      add(num);
  }

  int add(int val) {    
    s_.insert(val);
    if (s_.size() > k_)
      s_.erase(s_.begin());
    return *s_.begin();
  }
private:
  const int k_;  
  multiset<int> s_;
};

C++ / Min Heap

// Author: Huahua
// Running time: 28 ms
class KthLargest {
public:
  KthLargest(int k, vector<int> nums): k_(k) {    
    for (int num : nums)
      add(num);
  }

  int add(int val) {    
    s_.push(val);
    if (s_.size() > k_)
      s_.pop();
    return s_.top();
  }
private:
  const int k_;  
  priority_queue<int, vector<int>, greater<int>> s_; // min heap
};

The post 花花酱 LeetCode 703. Kth Largest Element in a Stream appeared first on Huahua's Tech Road.