253. (Locked)Meeting Rooms II

Difficulty: Medium

Frequency: N/A

Given an array of meeting time intervals consisting of start and end times `[[s1,e1],[s2,e2],...]` (si < ei), find the minimum number of conference rooms required.

For example,
Given `[[0, 30],[5, 10],[15, 20]]`,
return `2`.

My solution:
Data structure:
Steps:
Complexity:
Runtime:
Space:
Test cases:
Corner cases:
Code:
```bool myComp(const Interval &amp;a, const Interval &amp;b){
return (a.start&lt;b.start);
}
class Solution {
public:
int minMeetingRooms(vector<interval> intervals) {
map<int, int> changes;
for (auto i : intervals) {
changes[i.start] += 1;
changes[i.end] -= 1;
}
int rooms = 0, maxRooms = 0;
for (auto change : changes) {
maxRooms = max(maxRooms, rooms += change.second);
}
return maxRooms;
}
};
```

Another solution:
Data structure:
steps:
Complexity:
Runtime:
Space:
Code:

Things to learn:

023. Merge k Sorted Lists

Difficulty: Hard

Frequency: N/A

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

My solution:
Data structure:
Steps:
Complexity:
Runtime:
Space:
Test cases:
Corner cases:
Code:
```/**
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
private:
struct compare {
bool operator() (const ListNode* l, const ListNode* r) {
return l->val > r->val;
}
};
public:
ListNode* mergeKLists(vector<ListNode*>& lists) {
priority_queue<ListNode*, vector<ListNode*>, compare> pq;
for (ListNode* l : lists) if (l) pq.push(l);
while (!pq.empty()) {
cur->next = pq.top();
pq.pop();
cur = cur->next;
if (cur->next) pq.push(cur->next);
}
}
};
```

Another solution:
Data structure:
steps:
Complexity:
Runtime:
Space:
Code:

Things to learn:

215. Kth Largest Element in an Array

Difficulty: Medium

Frequency: N/A

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.

For example,
Given `[3,2,1,5,6,4]` and k = 2, return 5.

Note:
You may assume k is always valid, 1 ≤ k ≤ array’s length.

My solution:
Data structure:
Steps:
Complexity:
Runtime:
Space:
Test cases:
Corner cases:
Code:
```class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
priority_queue<int> q;
for (int n : nums) q.push(n);
for (int i = 1; i < k; i++) q.pop();
return q.top();
}
};
```

Another solution:
Data structure:
steps:
Complexity:
Runtime:
Space:
Code:

Things to learn:

295. Find Median from Data Stream

Difficulty: Hard

Frequency: N/A

Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.

Examples:
`[2,3,4]` , the median is `3`

`[2,3]`, the median is `(2 + 3) / 2 = 2.5`

Design a data structure that supports the following two operations:

• void addNum(int num) – Add a integer number from the data stream to the data structure.
• double findMedian() – Return the median of all elements so far.

For example:

```add(1)
findMedian() -> 1.5
findMedian() -> 2```

My solution:
Data structure:
Steps:
Complexity:
Runtime:
Space:
Test cases:
Corner cases:
Code:
```class MedianFinder {
private:
priority_queue<int> small, large;
public:

// Adds a number into the data structure.
small.push(num);
large.push(-small.top());
small.pop();
if (small.size() < large.size()) {
small.push(-large.top());
large.pop();
}
}

// Returns the median of current data stream
double findMedian() {
if (small.size() > large.size()) return small.top();
else return (small.top() - large.top()) / 2.0;
}
};

// Your MedianFinder object will be instantiated and called as such:
// MedianFinder mf;