Posts tagged as “set”

花花酱 LeetCode 2242. Maximum Score of a Node Sequence

By zxi on April 16, 2022

There is an undirected graph with n nodes, numbered from 0 to n - 1.

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] = [a_i, b_i] denotes that there exists an undirected edge connecting nodes a_i and b_i.

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 * 10⁴
1 <= scores[i] <= 10⁸
0 <= edges.length <= 5 * 10⁴
edges[i].length == 2
0 <= a_i, b_i <= n - 1
a_i != b_i
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)

C++

// 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;

}

};

花花酱 LeetCode 2102. Sequentially Ordinal Rank Tracker

By zxi on December 12, 2021

A scenic location is represented by its name and attractiveness score, where name is a unique string among all locations and score is an integer. Locations can be ranked from the best to the worst. The higher the score, the better the location. If the scores of two locations are equal, then the location with the lexicographically smaller name is better.

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 i^th 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 4^th time, it returns the 4^th 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 i^th best location, where i is the number of times this method has been invoked (including this invocation).

Example 1:

Input

["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], [], []]

Output

[null, null, null, "branford", null, "alps", null, "bradford", null, "bradford", null, "bradford", "orland"]

Explanation

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 higher score (3 > 2).

// This is the 1st 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 lexicographically smaller than "bradford".

// Return the 2nd best location "alps", as it is the 2nd 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 3rd 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".

Constraints:

name consists of lowercase English letters, and is unique among all locations.
1 <= name.length <= 10
1 <= score <= 10⁵
At any time, the number of calls to get does not exceed the number of calls to add.
At most 4 * 10⁴ 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)

C++

// 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);

};

花花酱 LeetCode 1418. Display Table of Food Orders in a Restaurant

By zxi on April 20, 2020

Given the array orders, which represents the orders that customers have done in a restaurant. More specifically orders[i]=[customerName_i,tableNumber_i,foodItem_i] where customerName_i is the name of the customer, tableNumber_i is the table customer sit at, and foodItem_i is the item customer orders.

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 <= customerName_i.length, foodItem_i.length <= 20
customerName_i and foodItem_i consist of lowercase and uppercase English letters and the space character.
tableNumber_i is a valid integer between 1 and 500.

Solution: TreeMap/Set + HashTable

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

C++

// 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;

}

};

花花酱 LeetCode 1353. Maximum Number of Events That Can Be Attended

By zxi on February 16, 2020

Given an array of events where events[i] = [startDay_i, endDay_i]. Every event i starts at startDay_iand ends at endDay_i.

You can attend an event i at any day d where startTime_i <= d <= endTime_i. 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)

C++

// 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;

}

};

C++

// 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;

}

};

Python

// 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)

C++

// 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;

}

};

花花酱 LeetCode 987. Vertical Order Traversal of a Binary Tree

By zxi on February 2, 2019

Given a binary tree, return the vertical order traversal of its nodes values.

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:

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

Solution: Ordered Map+ Ordered Set

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

C++

// 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);

}

};

Python3

# 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