Posts tagged as “hard”

花花酱 LeetCode 899. Orderly Queue

By zxi on September 1, 2018

Problem

A string S of lowercase letters is given. Then, we may make any number of moves.

In each move, we choose one of the first K letters (starting from the left), remove it, and place it at the end of the string.

Return the lexicographically smallest string we could have after any number of moves.

Example 1:

Input: S = "cba", K = 1
Output: "acb"
Explanation: 
In the first move, we move the 1st character ("c") to the end, obtaining the string "bac".
In the second move, we move the 1st character ("b") to the end, obtaining the final result "acb".

Example 2:

Input: S = "baaca", K = 3
Output: "aaabc"
Explanation: 
In the first move, we move the 1st character ("b") to the end, obtaining the string "aacab".
In the second move, we move the 3rd character ("c") to the end, obtaining the final result "aaabc".

Note:

1 <= K <= S.length <= 1000
S consists of lowercase letters only.

Solution: Rotation or Sort?

if \(k =1\), we can only rotate the string.

if \(k > 1\), we can bubble sort the string.

Time complexity: O(n^2)

Space complexity: O(n)

C++

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

string orderlyQueue(string S, int K) {

if (K > 1) {

sort(begin(S), end(S));

return S;

}

string ans = S;

for (int i = 1; i < S.size(); ++i)

ans = min(ans, S.substr(i) + S.substr(0, i));

return ans;

}

};

Java

// Author: Huahua

class Solution {

public String orderlyQueue(String S, int K) {

if (K > 1) {

char[] chars = S.toCharArray();

Arrays.sort(chars);

return new String(chars);

}

String ans = S;

for (int i = 1; i < S.length(); ++i) {

String tmp = S.substring(i) + S.substring(0, i);

if (tmp.compareTo(ans) < 0) ans = tmp;

}

return ans;

}

Python3 SC O(n^2)

# Author: Huahua 48 ms

class Solution:

def orderlyQueue(self, S, K):

if K > 1: return ''.join(sorted(S))

return min([S[i:] + S[0:i] for i in range(0, len(S))])

Python3 SC O(n)

# Author: Huahua 36 ms

class Solution:

def orderlyQueue(self, S, K):

if K > 1: return ''.join(sorted(S))

ans = S

for i in range(0, len(S)):

ans = min(ans, S[i:] + S[0:i])

return ans

花花酱 LeetCode 895. Maximum Frequency Stack

By zxi on August 26, 2018

Problem

Implement FreqStack, a class which simulates the operation of a stack-like data structure.

FreqStack has two functions:

push(int x), which pushes an integer x onto the stack.
pop(), which removes and returns the most frequent element in the stack.
- If there is a tie for most frequent element, the element closest to the top of the stack is removed and returned.

Example 1:

Input: 
["FreqStack","push","push","push","push","push","push","pop","pop","pop","pop"],
[[],[5],[7],[5],[7],[4],[5],[],[],[],[]]
Output: [null,null,null,null,null,null,null,5,7,5,4]
Explanation:
After making six .push operations, the stack is [5,7,5,7,4,5] from bottom to top.  Then:

pop() -> returns 5, as 5 is the most frequent.
The stack becomes [5,7,5,7,4].

pop() -> returns 7, as 5 and 7 is the most frequent, but 7 is closest to the top.
The stack becomes [5,7,5,4].

pop() -> returns 5.
The stack becomes [5,7,4].

pop() -> returns 4.
The stack becomes [5,7].

Note:

Calls to FreqStack.push(int x) will be such that 0 <= x <= 10^9.
It is guaranteed that FreqStack.pop() won’t be called if the stack has zero elements.
The total number of FreqStack.push calls will not exceed 10000 in a single test case.
The total number of FreqStack.pop calls will not exceed 10000 in a single test case.
The total number of FreqStack.push and FreqStack.pop calls will not exceed 150000 across all test cases.

Solution 1: Buckets

We have n stacks. The i-th stack has the of elements with freq i when pushed.

We keep tracking the freq of each element.

push(x): stacks[++freq(x)].push(x) # inc x’s freq and push it onto freq-th stack

pop(): x = stacks[max_freq].pop(), –freq(x); # pop element x from the max_freq stack and dec it’s freq.

Time complexity: O(1) push / pop

Space complexity: O(n)

C++

// Author: Huahua

// Running time: 144 ms

class FreqStack {

public:

FreqStack() {}

void push(int x) {

auto it = freq_.find(x);

if (it == freq_.end())

it = freq_.emplace(x, 0).first;

int freq = ++it->second;

if (stacks_.size() < freq) stacks_.push_back({});

stacks_[freq - 1].push(x);

}

int pop() {

int x = stacks_.back().top();

stacks_.back().pop();

if (stacks_.back().empty())

stacks_.pop_back();

auto it = freq_.find(x);

if (!(--it->second))

freq_.erase(it);

return x;

}

private:

vector<stack<int>> stacks_;

unordered_map<int, int> freq_;

};

Solution2: Priority Queue

Use a max heap with key: (freq, seq), the max freq and closest to the top of stack element will be extracted first.

Time complexity: O(logn)

Space complexity: O(n)

C++

// Author: Huahua

// Running time: 132 ms

class FreqStack {

public:

FreqStack() {}

void push(int x) {

int key = (++f_[x] << 16) | (++seq_);

q_.emplace(key, x);

}

int pop() {

int x = q_.top().second; q_.pop();

if (--f_[x] == 0)

f_.erase(x);

return x;

}

private:

int seq_ = 0;

unordered_map<int, int> f_; // {x -> freq}

priority_queue<pair<int, int>> q_; // {freq | seq_, x}

};

Problem

The demons had captured the princess (P) and imprisoned her in the bottom-right corner of a dungeon. The dungeon consists of M x N rooms laid out in a 2D grid. Our valiant knight (K) was initially positioned in the top-left room and must fight his way through the dungeon to rescue the princess.

The knight has an initial health point represented by a positive integer. If at any point his health point drops to 0 or below, he dies immediately.

Some of the rooms are guarded by demons, so the knight loses health (negative integers) upon entering these rooms; other rooms are either empty (0’s) or contain magic orbs that increase the knight’s health (positive integers).

In order to reach the princess as quickly as possible, the knight decides to move only rightward or downward in each step.

Write a function to determine the knight’s minimum initial health so that he is able to rescue the princess.

For example, given the dungeon below, the initial health of the knight must be at least 7 if he follows the optimal path RIGHT-> RIGHT -> DOWN -> DOWN.

-2 (K)	-3	3
-5	-10	1
10	30	-5 (P)

Note:

The knight’s health has no upper bound.
Any room can contain threats or power-ups, even the first room the knight enters and the bottom-right room where the princess is imprisoned.

Solution: DP

Time complexity: O(mn)

Space complexity: O(mn) -> O(n)

C++

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

int calculateMinimumHP(vector<vector<int>>& dungeon) {

const int m = dungeon.size();

const int n = dungeon[0].size();

// hp[y][x]: min hp required to reach bottom right (P).

vector<vector<int>> hp(m + 1, vector<int>(n + 1, INT_MAX));

hp[m][n - 1] = hp[m - 1][n] = 1;

for (int y = m - 1; y >= 0; --y)

for (int x = n - 1; x >= 0; --x)

hp[y][x] = max(1, min(hp[y + 1][x], hp[y][x + 1]) - dungeon[y][x]);

return hp[0][0];

}

};

O(n) space

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

int calculateMinimumHP(vector<vector<int>>& dungeon) {

const int m = dungeon.size();

const int n = dungeon[0].size();

// hp[y][x]: min hp required to reach bottom right (P).

vector<int> hp(n + 1, INT_MAX);

hp[n - 1] = 1;

for (int y = m - 1; y >= 0; --y)

for (int x = n - 1; x >= 0; --x)

hp[x] = max(1, min(hp[x], hp[x + 1]) - dungeon[y][x]);

return hp[0];

}

};

花花酱 LeetCode 882. Reachable Nodes In Subdivided Graph

By zxi on August 4, 2018

Problem

Starting with an undirected graph (the “original graph”) with nodes from 0 to N-1, subdivisions are made to some of the edges.

The graph is given as follows: edges[k] is a list of integer pairs (i, j, n) such that (i, j) is an edge of the original graph,

and n is the total number of new nodes on that edge.

Then, the edge (i, j) is deleted from the original graph, n new nodes (x_1, x_2, ..., x_n) are added to the original graph,

and n+1 new edges (i, x_1), (x_1, x_2), (x_2, x_3), ..., (x_{n-1}, x_n), (x_n, j) are added to the original graph.

Now, you start at node 0 from the original graph, and in each move, you travel along one edge.

Return how many nodes you can reach in at most M moves.

Example 1:

Input: edge = [[0,1,10],[0,2,1],[1,2,2]], M = 6, N = 3 
Output: 13 
Explanation:  The nodes that are reachable in the final graph after M = 6 moves are indicated below.

Example 2:

Input: edges = [[0,1,4],[1,2,6],[0,2,8],[1,3,1]], M = 10, N = 4 
Output: 23

Note:

0 <= edges.length <= 10000
0 <= edges[i][0] < edges[i][1] < N
There does not exist any i != j for which edges[i][0] == edges[j][0] and edges[i][1] == edges[j][1].
The original graph has no parallel edges.
0 <= edges[i][2] <= 10000
0 <= M <= 10^9
1 <= N <= 3000

Solution: Dijkstra Shortest Path

Compute the shortest from 0 to rest of the nodes. Use HP to mark the maximum moves left to reach each node.

HP[u] = a, HP[v] = b, new_nodes[u][v] = c

nodes covered between a<->b = min(c, a + b)

Time complexity: O(ElogE)

Space complexity: O(E)

C++

// Author: Huahua

// Running time: 88 ms

class Solution {

public:

int reachableNodes(vector<vector<int>>& edges, int M, int N) {

unordered_map<int, unordered_map<int, int>> g;

for (const auto& e : edges)

g[e[0]][e[1]] = g[e[1]][e[0]] = e[2];

priority_queue<pair<int, int>> q; // {hp, node}, sort by HP desc

unordered_map<int, int> HP; // node -> max HP left

q.push({M, 0});

while (!q.empty()) {

int hp = q.top().first;

int cur = q.top().second;

q.pop();

if (HP.count(cur)) continue;

HP[cur] = hp;

for (const auto& pair : g[cur]) {

int nxt = pair.first;

int nxt_hp = hp - pair.second - 1;

if (HP.count(nxt) || nxt_hp < 0) continue;

q.push({nxt_hp, nxt});

}

int ans = HP.size(); // Original nodes covered.

for (const auto& e : edges) {

int uv = HP.count(e[0]) ? HP[e[0]] : 0;

int vu = HP.count(e[1]) ? HP[e[1]] : 0;

ans += min(e[2], uv + vu);

}

return ans;

}

};

Optimized Dijkstra (replace hashmap with vector)

// Author: Huahua

// Running time: 56 ms (beats 88%)

class Solution {

public:

int reachableNodes(vector<vector<int>>& edges, int M, int N) {

vector<vector<pair<int, int>>> g(N);

for (const auto& e : edges) {

g[e[0]].emplace_back(e[1], e[2]);

g[e[1]].emplace_back(e[0], e[2]);

}

set<pair<int, int>> q; // {hp, node}, sort by HP asc

vector<int> HP(N, INT_MIN); // node -> HP left

q.insert({M, 0});

int ans = 0;

while (!q.empty()) {

auto last_it = prev(end(q));

int hp = last_it->first;

int cur = last_it->second;

q.erase(last_it);

if (HP[cur] != INT_MIN) continue;

HP[cur] = hp;

++ans;

for (const auto& pair : g[cur]) {

int nxt = pair.first;

int nxt_hp = hp - pair.second - 1;

if (nxt_hp < 0 || HP[nxt] != INT_MIN) continue;

q.insert({nxt_hp, nxt});

}

for (const auto& e : edges) {

const int uv = HP[e[0]] == INT_MIN ? 0 : HP[e[0]];

const int vu = HP[e[1]] == INT_MIN ? 0 : HP[e[1]];

ans += min(e[2], uv + vu);

}

return ans;

}

};

Using SPFA

// Author: Huahua

// Running time: 56 ms (beats 88%)

class Solution {

public:

int reachableNodes(vector<vector<int>>& edges, int M, int N) {

vector<vector<pair<int, int>>> g(N);

for (const auto& e : edges) {

g[e[0]].emplace_back(e[1], e[2]);

g[e[1]].emplace_back(e[0], e[2]);

}

queue<int> q;

vector<int> HP(N, INT_MIN);

vector<bool> in_q(N);

HP[0] = M;

q.push(0);

in_q[0] = true;

// SPFA (Shortest Path Faster Algorithm).

while (!q.empty()) {

int u = q.front(); q.pop();

in_q[u] = false;

for (const auto& pair : g[u]) {

int v = pair.first;

int new_hp = HP[u] - pair.second - 1;

if (new_hp < 0 || new_hp <= HP[v]) continue;

HP[v] = new_hp;

if (in_q[v]) continue;

q.push(v);

in_q[v] = true;

}

int ans = 0;

for (int i = 0; i < N; ++i) ans += HP[i] >= 0;

for (const auto& e : edges) {

const int uv = HP[e[0]] == INT_MIN ? 0 : HP[e[0]];

const int vu = HP[e[1]] == INT_MIN ? 0 : HP[e[1]];

ans += min(e[2], uv + vu);

}

return ans;

}

};

BFS

// Author: Huahua

// Running time: 108 ms

class Solution {

public:

int reachableNodes(vector<vector<int>>& edges, int M, int N) {

unordered_map<int, unordered_map<int, int>> g;

for (const auto& e : edges)

g[e[0]][e[1]] = g[e[1]][e[0]] = e[2];

queue<pair<int, int>> q; // {hp, node}

unordered_map<int, int> HP; // node -> max HP left

q.push({M, 0});

while (!q.empty()) {

int hp = q.front().first;

int cur = q.front().second;

q.pop();

if (HP.count(cur) && HP[cur] > hp) continue;

HP[cur] = hp;

for (const auto& pair : g[cur]) {

int nxt = pair.first;

int nxt_hp = hp - pair.second - 1;

if (nxt_hp < 0 || (HP.count(nxt) && HP[nxt] > nxt_hp)) continue;

q.push({nxt_hp, nxt});

}

int ans = HP.size(); // Original nodes covered.

for (const auto& e : edges) {

int uv = HP.count(e[0]) ? HP[e[0]] : 0;

int vu = HP.count(e[1]) ? HP[e[1]] : 0;

ans += min(e[2], uv + vu);

}

return ans;

}

};

花花酱 LeetCode 502. IPO

By zxi on August 4, 2018

Problem

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:

You may assume all numbers in the input are non-negative integers.
The length of Profits array and Capital array will not exceed 50,000.
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;

}

};

Posts tagged as “hard”

花花酱 LeetCode 899. Orderly Queue

Problem

Solution: Rotation or Sort?

C++

Java

Python3 SC O(n^2)

Python3 SC O(n)

花花酱 LeetCode 895. Maximum Frequency Stack

Problem

Solution 1: Buckets

C++

Solution2: Priority Queue

C++

Related Problems

花花酱 LeetCode 174. Dungeon Game

Problem

Solution: DP

花花酱 LeetCode 882. Reachable Nodes In Subdivided Graph

Problem

Solution: Dijkstra Shortest Path

花花酱 LeetCode 502. IPO

Problem

Solution: Greedy