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.

You are building a system that tracks the ranking of locations with the system initially starting with no locations. It supports:

• Adding scenic locations, one at a time.
• Querying the ith best location of all locations already added, where i is the number of times the system has been queried (including the current query).
  • For example, when the system is queried for the 4th time, it returns the 4th best location of all locations already added.

Note that the test data are generated so that at any time, the number of queries does not exceed the number of locations added to the system.

Implement the SORTracker class:

• SORTracker() Initializes the tracker system.
• void add(string name, int score) Adds a scenic location with name and score to the system.
• string get() Queries and returns the ith best location, where i is the number of times this method has been invoked (including this invocation).

Example 1:

<strong>Input</strong>
["SORTracker", "add", "add", "get", "add", "get", "add", "get", "add", "get", "add", "get", "get"]
[[], ["bradford", 2], ["branford", 3], [], ["alps", 2], [], ["orland", 2], [], ["orlando", 3], [], ["alpine", 2], [], []]
<strong>Output</strong>
[null, null, null, "branford", null, "alps", null, "bradford", null, "bradford", null, "bradford", "orland"]
<p><strong>Explanation</strong> 
SORTracker tracker = new SORTracker(); // Initialize the tracker system.
tracker.add("bradford", 2);            // Add location with name="bradford" and score=2 to the system.
tracker.add("branford", 3);            // Add location with name="branford" and score=3 to the system.
tracker.get();                         // The sorted locations, from best to worst, are: branford, bradford. 
                                       // Note that branford precedes bradford due to its <strong>higher score</strong> (3 &gt; 2). 
                                       // This is the 1<sup>st</sup> time get() is called, so return the best location: "branford". 
tracker.add("alps", 2);                // Add location with name="alps" and score=2 to the system.
tracker.get();                         // Sorted locations: branford, alps, bradford. 
                                       // Note that alps precedes bradford even though they have the same score (2). 
                                       // This is because "alps" is <strong>lexicographically smaller</strong> than "bradford". 
                                       // Return the 2<sup>nd</sup> best location "alps", as it is the 2<sup>nd</sup> time get() is called.
tracker.add("orland", 2);              // Add location with name="orland" and score=2 to the system.
tracker.get();                         // Sorted locations: branford, alps, bradford, orland. 
                                       // Return "bradford", as it is the 3<sup>rd</sup> time get() is called. 
tracker.add("orlando", 3);             // Add location with name="orlando" and score=3 to the system.
tracker.get();                         // Sorted locations: branford, orlando, alps, bradford, orland. 
                                       // Return "bradford". 
tracker.add("alpine", 2);              // Add location with name="alpine" and score=2 to the system.
tracker.get();                         // Sorted locations: branford, orlando, alpine, alps, bradford, orland. 
                                       // Return "bradford". 
tracker.get();                         // Sorted locations: branford, orlando, alpine, alps, bradford, orland. 
                                       // Return "orland".
</p>

Constraints:

• name consists of lowercase English letters, and is unique among all locations.
• 1 <= name.length <= 10
• 1 <= score <= 105
• At any time, the number of calls to get does not exceed the number of calls to add.
• At most 4 * 104 calls in total will be made to add and get.

Solution: TreeSet w/ Iterator

Use a treeset to store all the entries and use a iterator that points to the entry to return. When inserting a new entry into the tree, if it’s higher than the current element then let the iterator go backward one step.

Time complexity: add O(logn) / get O(1)

// Author: Huahua
class SORTracker {
public:
  SORTracker() {}

  void add(string name, int score) {    
    if (*s.emplace(-score, name).first < *cit) --cit;
  }

  string get() {
    return (cit++)->second;
  }
private:
  set<pair<int, string>> s;
  // Note: cit points to begin(s) after first insertion.
  set<pair<int, string>>::const_iterator cit = end(s);
};

The post 花花酱 LeetCode 2102. Sequentially Ordinal Rank Tracker appeared first on Huahua's Tech Road.

Return the restaurant’s “display table”. The “display table” is a table whose row entries denote how many of each food item each table ordered. The first column is the table number and the remaining columns correspond to each food item in alphabetical order. The first row should be a header whose first column is “Table”, followed by the names of the food items. Note that the customer names are not part of the table. Additionally, the rows should be sorted in numerically increasing order.

Example 1:

Input: orders = [["David","3","Ceviche"],["Corina","10","Beef Burrito"],["David","3","Fried Chicken"],["Carla","5","Water"],["Carla","5","Ceviche"],["Rous","3","Ceviche"]]
Output: [["Table","Beef Burrito","Ceviche","Fried Chicken","Water"],["3","0","2","1","0"],["5","0","1","0","1"],["10","1","0","0","0"]] 
Explanation:
The displaying table looks like:
Table,Beef Burrito,Ceviche,Fried Chicken,Water
3    ,0           ,2      ,1            ,0
5    ,0           ,1      ,0            ,1
10   ,1           ,0      ,0            ,0
For the table 3: David orders "Ceviche" and "Fried Chicken", and Rous orders "Ceviche".
For the table 5: Carla orders "Water" and "Ceviche".
For the table 10: Corina orders "Beef Burrito". 

Example 2:

Input: orders = [["James","12","Fried Chicken"],["Ratesh","12","Fried Chicken"],["Amadeus","12","Fried Chicken"],["Adam","1","Canadian Waffles"],["Brianna","1","Canadian Waffles"]]
Output: [["Table","Canadian Waffles","Fried Chicken"],["1","2","0"],["12","0","3"]] 
Explanation: 
For the table 1: Adam and Brianna order "Canadian Waffles".
For the table 12: James, Ratesh and Amadeus order "Fried Chicken".

Example 3:

Input: orders = [["Laura","2","Bean Burrito"],["Jhon","2","Beef Burrito"],["Melissa","2","Soda"]]
Output: [["Table","Bean Burrito","Beef Burrito","Soda"],["2","1","1","1"]]

Constraints:

• 1 <= orders.length <= 5 * 10^4
• orders[i].length == 3
• 1 <= customerNamei.length, foodItemi.length <= 20
• customerNamei and foodItemi consist of lowercase and uppercase English letters and the space character.
• tableNumberi is a valid integer between 1 and 500.

Solution: TreeMap/Set + HashTable

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

// Author: Huahua
class Solution {
public:
  vector<vector<string>> displayTable(vector<vector<string>>& orders) {
    map<int, unordered_map<string, int>> tables;
    set<string> foods;
    for (const auto& order : orders) {
      ++tables[stoi(order[1])][order[2]];
      foods.insert(order[2]);
    }
    vector<vector<string>> ans;
    ans.push_back({{"Table"}});    
    ans.back().insert(end(ans.back()), begin(foods), end(foods));
    for (auto& [table, m] : tables) {
      vector<string> line{to_string(table)};
      for (const auto& food : foods)
        line.push_back(to_string(m[food]));
      ans.push_back(move(line));
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1418. Display Table of Food Orders in a Restaurant appeared first on Huahua's Tech Road.

Given an array of events where events[i] = [startDayi, endDayi]. Every event i starts at startDayiand ends at endDayi.

You can attend an event i at any day d where startTimei <= d <= endTimei. Notice that you can only attend one event at any time d.

Return the maximum number of events you can attend.

Example 1:

Input: events = [[1,2],[2,3],[3,4]]
Output: 3
Explanation: You can attend all the three events.
One way to attend them all is as shown.
Attend the first event on day 1.
Attend the second event on day 2.
Attend the third event on day 3.

Example 2:

Input: events= [[1,2],[2,3],[3,4],[1,2]]
Output: 4

Example 3:

Input: events = [[1,4],[4,4],[2,2],[3,4],[1,1]]
Output: 4

Example 4:

Input: events = [[1,100000]]
Output: 1

Example 5:

Input: events = [[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7]]
Output: 7

Constraints:

• 1 <= events.length <= 10^5
• events[i].length == 2
• 1 <= events[i][0] <= events[i][1] <= 10^5

Solution: Greedy

Sort events by end time, for each event find the first available day to attend.

Time complexity: O(sum(endtime – starttime)) = O(10^10)
Space complexity: O(max(endtime – starttime) = O(10^5)

// Author: Huahua, 216 ms, 45.7 MB
class Solution {
public:
  int maxEvents(vector<vector<int>>& events) {
    sort(begin(events), end(events), [](const auto& a, const auto& b){      
      return a[1] < b[1];      
    });
    int ans = 0;
    int seen[100001] = {0};
    for (const auto& e : events) {
      for (int i = e[0]; i <= e[1]; ++i) {
        if (seen[i]) continue;
        ++seen[i];
        ++ans;
        break;
      }
    }
    return ans;
  }
};

// Author: Huahua, 216 ms, 45.6 MB
class Solution {
public:
  int maxEvents(vector<vector<int>>& events) {
    sort(begin(events), end(events), [](const auto& a, const auto& b){      
      return a[1] < b[1];      
    });
    int ans = 0;
    unsigned char seen[100000 / 8 + 1] = {0};
    for (const auto& e : events) {
      for (int i = e[0]; i <= e[1]; ++i) {
        if (seen[i >> 3] & (1 << (i % 8))) continue;
        seen[i >> 3] |= 1 << (i % 8);
        ++ans;
        break;
      }
    }
    return ans;
  }
};

// Author: Huahua, 824 ms
class Solution:
  def maxEvents(self, events: List[List[int]]) -> int:
    lo = min(e[0] for e in events)
    hi = max(e[1] for e in events)
    seen = [0] * (hi - lo + 1)
    for s, t in sorted(events, key=lambda e:e[1]):
      for i in range(s, t + 1):
        if seen[i - lo]: continue
        seen[i - lo] = 1
        break
    return sum(seen)

We can use a TreeSet to maintain the open days and do a binary search to find the first available day.

Time complexity: O(nlogd)
Space complexity: O(d)

// Author: Huahua, 416 ms, 46.1MB
class Solution {
public:
  int maxEvents(vector<vector<int>>& events) {    
    sort(begin(events), end(events), [](const auto& a, const auto& b){      
      return a[1] < b[1];
    });    
    int min_d = INT_MAX;
    int max_d = INT_MIN;
    for (const auto& e : events) {
      min_d = min(min_d, e[0]);
      max_d = max(max_d, e[1]);
    }
    vector<int> days(max_d - min_d + 1);
    iota(begin(days), end(days), min_d);
    set<int> s(begin(days), end(days)); // O(n)
    
    int ans = 0;
    for (const auto& e : events) {
      auto it = s.lower_bound(e[0]);
      if (it == end(s) || *it > e[1]) continue;
      s.erase(it);
      ++ans;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1353. Maximum Number of Events That Can Be Attended appeared first on Huahua's Tech Road.

For each node at position (X, Y), its left and right children respectively will be at positions (X-1, Y-1) and (X+1, Y-1).

Running a vertical line from X = -infinity to X = +infinity, whenever the vertical line touches some nodes, we report the values of the nodes in order from top to bottom (decreasing Y coordinates).

If two nodes have the same position, then the value of the node that is reported first is the value that is smaller.

Return an list of non-empty reports in order of X coordinate.  Every report will have a list of values of nodes.

Example 1:

Input: [3,9,20,null,null,15,7]
Output: [[9],[3,15],[20],[7]]
Explanation: 
Without loss of generality, we can assume the root node is at position (0, 0):
Then, the node with value 9 occurs at position (-1, -1);
The nodes with values 3 and 15 occur at positions (0, 0) and (0, -2);
The node with value 20 occurs at position (1, -1);
The node with value 7 occurs at position (2, -2).

Example 2:

Input: [1,2,3,4,5,6,7]
Output: [[4],[2],[1,5,6],[3],[7]]
Explanation: 
The node with value 5 and the node with value 6 have the same position according to the given scheme.
However, in the report "[1,5,6]", the node value of 5 comes first since 5 is smaller than 6.

Note:

1. The tree will have between 1 and 1000 nodes.
2. Each node’s value will be between 0 and 1000.

Solution: Ordered Map+ Ordered Set

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

// Author: Huahua, running time: 0 ms, 921.6 KB 
class Solution {
public:
  vector<vector<int>> verticalTraversal(TreeNode* root) {
    if (!root) return {};
    int min_x = INT_MAX;
    int max_x = INT_MIN;
    map<pair<int, int>, multiset<int>> h; // {y, x} -> {vals}
    traverse(root, 0, 0, h, min_x, max_x);
    vector<vector<int>> ans(max_x - min_x + 1);
    for (const auto& m : h) {      
      int x = m.first.second - min_x;
      ans[x].insert(end(ans[x]), begin(m.second), end(m.second));
    }
    return ans;
  }
private:
  void traverse(TreeNode* root, int x, int y, 
                map<pair<int, int>, multiset<int>>& h,
                int& min_x,
                int& max_x) {
    if (!root) return;
    min_x = min(min_x, x);
    max_x = max(max_x, x);    
    h[{y, x}].insert(root->val);
    traverse(root->left, x - 1, y + 1, h, min_x, max_x);
    traverse(root->right, x + 1, y + 1, h, min_x, max_x);
  }
};

# Author: Huahua, 36 ms, 6.8 MB
class Solution:
  def verticalTraversal(self, root: 'TreeNode') -> 'List[List[int]]':
    if not root: return []    
    vals = []
    def preorder(root, x, y):
      if not root: return
      vals.append((x, y, root.val))
      preorder(root.left, x - 1, y + 1)
      preorder(root.right, x + 1, y + 1)
    preorder(root, 0, 0)    
    ans = []
    last_x = -1000
    for x, y, val in sorted(vals):
      if x != last_x:
        ans.append([])
        last_x = x
      ans[-1].append(val)
    return ans

The post 花花酱 LeetCode 987. Vertical Order Traversal of a Binary Tree appeared first on Huahua's Tech Road.

In an exam room, there are N seats in a single row, numbered 0, 1, 2, ..., N-1.

When a student enters the room, they must sit in the seat that maximizes the distance to the closest person.  If there are multiple such seats, they sit in the seat with the lowest number.  (Also, if no one is in the room, then the student sits at seat number 0.)

Return a class ExamRoom(int N) that exposes two functions: ExamRoom.seat() returning an int representing what seat the student sat in, and ExamRoom.leave(int p) representing that the student in seat number p now leaves the room.  It is guaranteed that any calls to ExamRoom.leave(p) have a student sitting in seat p.

Example 1:

Input: ["ExamRoom","seat","seat","seat","seat","leave","seat"], [[10],[],[],[],[],[4],[]]
Output: [null,0,9,4,2,null,5]
Explanation:
ExamRoom(10) -> null
seat() -> 0, no one is in the room, then the student sits at seat number 0.
seat() -> 9, the student sits at the last seat number 9.
seat() -> 4, the student sits at the last seat number 4.
seat() -> 2, the student sits at the last seat number 2.
leave(4) -> null
seat() -> 5, the student​​​​​​​ sits at the last seat number 5.

​​​​Note:

1. 1 <= N <= 10^9
2. ExamRoom.seat() and ExamRoom.leave() will be called at most 10^4 times across all test cases.
3. Calls to ExamRoom.leave(p) are guaranteed to have a student currently sitting in seat number p.

Solution: BST

Use a BST (ordered set) to track the current seatings.

Time Complexity:

init: O(1)

seat: O(P)

leave: O(logP)

Space complexity: O(P)

// Author: Huahua
// Running time: 24 ms
class ExamRoom {
public:
  ExamRoom(int N): N_(N) {}

  int seat() {
    int p = 0;
    int max_dist = s_.empty() ? 0 : *s_.begin();
    auto left = s_.begin();    
    auto right = left;
    while (left != s_.end()) {
      ++right;
      int l = *left;
      int r = right != s_.end() ? *right : (2 * (N_ - 1) - *left);      
      int d = (r - l) / 2;      
      if (d > max_dist) {
        max_dist = d;
        p = l + d;
      }
      left = right;
    }    
    s_.insert(p);
    return p;
  }

  void leave(int p) {
    s_.erase(p);
  }

private:
  const int N_;
  set<int> s_;
};

The post 花花酱 LeetCode 855. Exam Room appeared first on Huahua's Tech Road.

https://leetcode.com/problems/third-maximum-number/description/

Given a non-empty array of integers, return the third maximum number in this array. If it does not exist, return the maximum number. The time complexity must be in O(n).

Example 1:

Input: [3, 2, 1]

Output: 1

Explanation: The third maximum is 1.

Example 2:

Input: [1, 2]

Output: 2

Explanation: The third maximum does not exist, so the maximum (2) is returned instead.

Example 3:

Input: [2, 2, 3, 1]

Output: 1

Explanation: Note that the third maximum here means the third maximum distinct number.
Both numbers with value 2 are both considered as second maximum.

Solution: Set

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 9 ms
class Solution {
public:
  int thirdMax(vector<int>& nums) {
    set<int> s;
    for (int num : nums) {
      s.insert(num);
      if (s.size() > 3) s.erase(s.begin());
    }
    return s.size() != 3 ? *s.rbegin() : *s.begin();
  }
};

Python3

"""
Author: Huahua
Running time: 52 ms
"""
class Solution:
  def thirdMax(self, nums):
    s = set()
    for num in nums:
      s.add(num)
      if len(s) > 3: s.remove(min(s))
    return min(s) if len(s) == 3 else max(s)

The post 花花酱 LeetCode 414. Third Maximum Number appeared first on Huahua's Tech Road.

Problem:

https://leetcode.com/problems/intersection-of-two-arrays/description/

Given two arrays, write a function to compute their intersection.

Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].

Note:

• Each element in the result must be unique.
• The result can be in any order.

C++ using std::set_intersection

// Author: Huahua
// Running time: 8 ms
class Solution {
public:
  vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    vector<int> intersection(max(nums1.size(), nums2.size()));
    std::sort(nums1.begin(), nums1.end());
    std::sort(nums2.begin(), nums2.end());
    // Inputs must be in ascending order
    auto it = std::set_intersection(nums1.begin(), nums1.end(), nums2.begin(), nums2.end(), intersection.begin());
    intersection.resize(it - intersection.begin());
    std::set<int> s(intersection.begin(), intersection.end());
    return vector<int>(s.begin(), s.end());
  }
};

C++ hashtable

// Author: Huahua
// Running time: 7 ms
class Solution {
public:
  vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    unordered_set<int> m(nums1.begin(), nums1.end());
    vector<int> ans;
    for (int num : nums2) {
      if (!m.count(num)) continue;
      ans.push_back(num);
      m.erase(num);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 349. Intersection of Two Arrays appeared first on Huahua's Tech Road.