Posts tagged as “hard”

花花酱 LeetCode 1649. Create Sorted Array through Instructions

By zxi on November 8, 2020

Given an integer array instructions, you are asked to create a sorted array from the elements in instructions. You start with an empty container nums. For each element from left to right in instructions, insert it into nums. The cost of each insertion is the minimum of the following:

The number of elements currently in nums that are strictly less than instructions[i].
The number of elements currently in nums that are strictly greater than instructions[i].

For example, if inserting element 3 into nums = [1,2,3,5], the cost of insertion is min(2, 1) (elements 1 and 2 are less than 3, element 5 is greater than 3) and nums will become [1,2,3,3,5].

Return the total cost to insert all elements from instructions into nums. Since the answer may be large, return it modulo 10⁹ + 7

Example 1:

Input: instructions = [1,5,6,2]
Output: 1
Explanation: Begin with nums = [].
Insert 1 with cost min(0, 0) = 0, now nums = [1].
Insert 5 with cost min(1, 0) = 0, now nums = [1,5].
Insert 6 with cost min(2, 0) = 0, now nums = [1,5,6].
Insert 2 with cost min(1, 2) = 1, now nums = [1,2,5,6].
The total cost is 0 + 0 + 0 + 1 = 1.

Example 2:

Input: instructions = [1,2,3,6,5,4]
Output: 3
Explanation: Begin with nums = [].
Insert 1 with cost min(0, 0) = 0, now nums = [1].
Insert 2 with cost min(1, 0) = 0, now nums = [1,2].
Insert 3 with cost min(2, 0) = 0, now nums = [1,2,3].
Insert 6 with cost min(3, 0) = 0, now nums = [1,2,3,6].
Insert 5 with cost min(3, 1) = 1, now nums = [1,2,3,5,6].
Insert 4 with cost min(3, 2) = 2, now nums = [1,2,3,4,5,6].
The total cost is 0 + 0 + 0 + 0 + 1 + 2 = 3.

Example 3:

Input: instructions = [1,3,3,3,2,4,2,1,2]
Output: 4
Explanation: Begin with nums = [].
Insert 1 with cost min(0, 0) = 0, now nums = [1].
Insert 3 with cost min(1, 0) = 0, now nums = [1,3].
Insert 3 with cost min(1, 0) = 0, now nums = [1,3,3].
Insert 3 with cost min(1, 0) = 0, now nums = [1,3,3,3].
Insert 2 with cost min(1, 3) = 1, now nums = [1,2,3,3,3].
Insert 4 with cost min(5, 0) = 0, now nums = [1,2,3,3,3,4].
Insert 2 with cost min(1, 4) = 1, now nums = [1,2,2,3,3,3,4].
Insert 1 with cost min(0, 6) = 0, now nums = [1,1,2,2,3,3,3,4].
Insert 2 with cost min(2, 4) = 2, now nums = [1,1,2,2,2,3,3,3,4].
The total cost is 0 + 0 + 0 + 0 + 1 + 0 + 1 + 0 + 2 = 4.

Constraints:

1 <= instructions.length <= 10⁵
1 <= instructions[i] <= 10⁵

Solution: Fenwick Tree / Binary Indexed Tree

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

m is the maximum value, n is number of values.

C++

class FenwickTree {

public:

FenwickTree(int n): sums_(n + 1, 0) {}

void update(int i, int delta) {

while (i < sums_.size()) {

sums_[i] += delta;

i += lowbit(i);

}

int query(int i) const {

int sum = 0;

while (i > 0) {

sum += sums_[i];

i -= lowbit(i);

}

return sum;

}

private:

static inline int lowbit(int x) {

return x & (-x);

}

vector<int> sums_;

};

class Solution {

public:

int createSortedArray(vector<int>& instructions) {

const int n = instructions.size();

FenwickTree tree(1e5);

long ans = 0;

for (int i = 0; i < n; ++i) {

int lt = tree.query(instructions[i] - 1);

int gt = i - tree.query(instructions[i]);

ans += min(lt, gt);

tree.update(instructions[i], 1);

}

return ans % 1000000007;

}

};

花花酱 LeetCode 1206. Design Skiplist

By zxi on November 6, 2020

Design a Skiplist without using any built-in libraries.

A Skiplist is a data structure that takes O(log(n)) time to add, erase and search. Comparing with treap and red-black tree which has the same function and performance, the code length of Skiplist can be comparatively short and the idea behind Skiplists are just simple linked lists.

For example: we have a Skiplist containing [30,40,50,60,70,90] and we want to add 80 and 45 into it. The Skiplist works this way:

Artyom Kalinin [CC BY-SA 3.0], via Wikimedia Commons

You can see there are many layers in the Skiplist. Each layer is a sorted linked list. With the help of the top layers, add , erase and search can be faster than O(n). It can be proven that the average time complexity for each operation is O(log(n)) and space complexity is O(n).

To be specific, your design should include these functions:

bool search(int target) : Return whether the target exists in the Skiplist or not.
void add(int num): Insert a value into the SkipList.
bool erase(int num): Remove a value in the Skiplist. If num does not exist in the Skiplist, do nothing and return false. If there exists multiple num values, removing any one of them is fine.

See more about Skiplist : https://en.wikipedia.org/wiki/Skip_list

Note that duplicates may exist in the Skiplist, your code needs to handle this situation.

Example:

Skiplist skiplist = new Skiplist();

skiplist.add(1);

skiplist.add(2);

skiplist.add(3);

skiplist.search(0); // return false.

skiplist.add(4);

skiplist.search(1); // return true.

skiplist.erase(0); // return false, 0 is not in skiplist.

skiplist.erase(1); // return true.

skiplist.search(1); // return false, 1 has already been erased.

Constraints:

0 <= num, target <= 20000
At most 50000 calls will be made to search, add, and erase.

Solution:

C++

// Author: Huahua

class Skiplist {

public:

Skiplist() { head_ = make_shared<Node>(); }

bool search(int target) {

for (auto node = head_; node; node = node->down) {

while (node->next && node->next->val < target)

node = node->next;

if (node->next && node->next->val == target)

return true;

}

return false;

}

void add(int num) {

stack<shared_ptr<Node>> s;

shared_ptr<Node> down;

bool insert = true;

for (auto node = head_; node; node = node->down) {

while (node->next && node->next->val < num)

node = node->next;

s.push(node);

}

while (!s.empty() && insert) {

auto cur = s.top(); s.pop();

cur->next = make_shared<Node>(num, cur->next, down);

down = cur->next;

insert = rand() & 1; // 50% chance

}

if (insert) // create a new layer.

head_ = make_shared<Node>(-1, nullptr, head_);

}

bool erase(int num) {

bool found = false;

for (auto node = head_; node; node = node->down) {

while (node->next && node->next->val < num)

node = node->next;

if (node->next && node->next->val == num) {

found = true;

node->next = node->next->next;

}

return found;

}

private:

struct Node {

Node(int val = -1,

shared_ptr<Node> next = nullptr,

shared_ptr<Node> down = nullptr):

val(val), next(next), down(down) {}

int val;

shared_ptr<Node> next;

shared_ptr<Node> down;

};

shared_ptr<Node> head_;

};

/**

* Your Skiplist object will be instantiated and called as such:

* Skiplist* obj = new Skiplist();

* bool param_1 = obj->search(target);

* obj->add(num);

* bool param_3 = obj->erase(num);

Python3

import random

class Node:

def __init__(self, val=-1, right=None, down=None):

self.val = val

self.right = right

self.down = down

class Skiplist:

def __init__(self):

self.head = Node() # Dummy head

def search(self, target: int) -> bool:

node = self.head

while node:

# Move to the right in the current level

while node.right and node.right.val < target:

node = node.right

if node.right and node.right.val == target:

return True

# Move to the the next level

node = node.down

return False

def add(self, num: int) -> None:

nodes = []

node = self.head

while node:

# Move to the right in the current level

while node.right and node.right.val < num:

node = node.right

nodes.append(node)

# Move to the next level

node = node.down

insert = True

down = None

while insert and nodes:

node = nodes.pop()

node.right = Node(num, node.right, down)

down = node.right

insert = (random.getrandbits(1) == 0)

# Create a new level with a dummy head.

# right = None

# down = current head

if insert:

self.head = Node(-1, None, self.head)

def erase(self, num: int) -> bool:

node = self.head

found = False

while node:

# Move to the right in the current level

while node.right and node.right.val < num:

node = node.right

# Find the target node

if node.right and node.right.val == num:

# Delete by skipping

node.right = node.right.right

found = True

# Move to the next level

node = node.down

return found

# Your Skiplist object will be instantiated and called as such:

# obj = Skiplist()

# param_1 = obj.search(target)

# obj.add(num)

# param_3 = obj.erase(num)

花花酱 LeetCode 1632. Rank Transform of a Matrix

By zxi on October 28, 2020

Given an m x n matrix, return a new matrix answer where answer[row][col] is the rank of matrix[row][col].

The rank is an integer that represents how large an element is compared to other elements. It is calculated using the following rules:

The rank is an integer starting from 1.
If two elements p and q are in the same row or column, then:
- If p < q then rank(p) < rank(q)
- If p == q then rank(p) == rank(q)
- If p > q then rank(p) > rank(q)
The rank should be as small as possible.

It is guaranteed that answer is unique under the given rules.

Example 1:

Input: matrix = [[1,2],[3,4]]
Output: [[1,2],[2,3]]
Explanation:
The rank of matrix[0][0] is 1 because it is the smallest integer in its row and column.
The rank of matrix[0][1] is 2 because matrix[0][1] > matrix[0][0] and matrix[0][0] is rank 1.
The rank of matrix[1][0] is 2 because matrix[1][0] > matrix[0][0] and matrix[0][0] is rank 1.
The rank of matrix[1][1] is 3 because matrix[1][1] > matrix[0][1], matrix[1][1] > matrix[1][0], and both matrix[0][1] and matrix[1][0] are rank 2.

Example 2:

Input: matrix = [[7,7],[7,7]]
Output: [[1,1],[1,1]]

Example 3:

Input: matrix = [[20,-21,14],[-19,4,19],[22,-47,24],[-19,4,19]]
Output: [[4,2,3],[1,3,4],[5,1,6],[1,3,4]]

Example 4:

Input: matrix = [[7,3,6],[1,4,5],[9,8,2]]
Output: [[5,1,4],[1,2,3],[6,3,1]]

Constraints:

m == matrix.length
n == matrix[i].length
1 <= m, n <= 500
-10⁹ <= matrix[row][col] <= 10⁹

Solution: Union Find

Group cells by their values, process groups (cells that have the same value) in ascending order (smaller number has smaller rank).

For cells that are in the same row and same cols union them using union find, they should have the same rank which equals to max(max_rank_x[cols], max_rank_y[rows]) + 1.

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

C++

// Author: Huahua

class DSU {

public:

DSU(int n): p_(n, -1) {}

int find(int x) {

return p_[x] == -1 ? x : p_[x] = find(p_[x]);

}

void merge(int x, int y) {

x = find(x), y = find(y);

if (x != y) p_[x] = y;

}

private:

vector<int> p_;

};

class Solution {

public:

vector<vector<int>> matrixRankTransform(vector<vector<int>>& matrix) {

const int m = matrix.size();

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

vector<vector<int>> ans(m, vector<int>(n));

map<int, vector<pair<int, int>>> mp; // val -> {positions}

for (int y = 0; y < m; ++y)

for (int x = 0; x < n; ++x)

mp[matrix[y][x]].emplace_back(x, y);

vector<int> rx(n), ry(m);

for (const auto& [val, ps]: mp) {

DSU dsu(n + m);

vector<vector<pair<int, int>>> cc(n + m); // val -> {positions}

for (const auto& [x, y]: ps)

dsu.merge(x, y + n);

for (const auto& [x, y]: ps)

cc[dsu.find(x)].emplace_back(x, y);

for (const auto& ps: cc) {

int rank = 1;

for (const auto& [x, y]: ps)

rank = max(rank, max(rx[x], ry[y]) + 1);

for (const auto& [x, y]: ps)

rx[x] = ry[y] = ans[y][x] = rank;

}

return ans;

}

};

花花酱 LeetCode 1627. Graph Connectivity With Threshold

By zxi on October 18, 2020

We have n cities labeled from 1 to n. Two different cities with labels x and y are directly connected by a bidirectional road if and only if x and y share a common divisor strictly greater than some threshold. More formally, cities with labels x and y have a road between them if there exists an integer z such that all of the following are true:

x % z == 0,
y % z == 0, and
z > threshold.

Given the two integers, n and threshold, and an array of queries, you must determine for each queries[i] = [a_i, b_i] if cities a_i and b_i are connected (i.e. there is some path between them).

Return an array answer, where answer.length == queries.length and answer[i] is true if for the i^th query, there is a path between a_i and b_i, or answer[i] is false if there is no path.

Example 1:

Input: n = 6, threshold = 2, queries = [[1,4],[2,5],[3,6]]
Output: [false,false,true]
Explanation: The divisors for each number:
1:   1
2:   1, 2
3:   1, 3
4:   1, 2, 4
5:   1, 5
6:   1, 2, 3, 6
Using the underlined divisors above the threshold, only cities 3 and 6 share a common divisor, so they are the
only ones directly connected. The result of each query:
[1,4]   1 is not connected to 4
[2,5]   2 is not connected to 5
[3,6]   3 is connected to 6 through path 3--6

Example 2:

Input: n = 6, threshold = 0, queries = [[4,5],[3,4],[3,2],[2,6],[1,3]]
Output: [true,true,true,true,true]
Explanation: The divisors for each number are the same as the previous example. However, since the threshold is 0,
all divisors can be used. Since all numbers share 1 as a divisor, all cities are connected.

Example 3:

Input: n = 5, threshold = 1, queries = [[4,5],[4,5],[3,2],[2,3],[3,4]]
Output: [false,false,false,false,false]
Explanation: Only cities 2 and 4 share a common divisor 2 which is strictly greater than the threshold 1, so they are the only ones directly connected.
Please notice that there can be multiple queries for the same pair of nodes [x, y], and that the query [x, y] is equivalent to the query [y, x].

Constraints:

2 <= n <= 10⁴
0 <= threshold <= n
1 <= queries.length <= 10⁵
queries[i].length == 2
1 <= a_i, b_i <= cities
a_i != b_i

Solution: Union Find

For x, merge 2x, 3x, 4x, ..,
If a number is already “merged”, skip it.

Time complexity: O(nlogn? + queries)?
Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

vector<bool> areConnected(int n, int threshold, vector<vector<int>>& queries) {

if (threshold == 0) return vector<bool>(queries.size(), true);

vector<int> ds(n + 1);

iota(begin(ds), end(ds), 0);

function<int(int)> find = [&](int x) {

return ds[x] == x ? x : ds[x] = find(ds[x]);

};

for (int x = threshold + 1; x <= n; ++x)

if (ds[x] == x)

for (int y = 2 * x; y <= n; y += x)

ds[max(find(x), find(y))] = min(find(x), find(y));

vector<bool> ans;

for (const vector<int>& q : queries)

ans.push_back(find(q[0]) == find(q[1]));

return ans;

}

};

Python3

# Author: Huahua

class Solution:

def areConnected(self, n: int, threshold: int,

queries: List[List[int]]) -> List[bool]:

if threshold == 0: return [True] * len(queries)

ds = list(range(n + 1))

def find(x: int) -> int:

if x != ds[x]: ds[x] = find(ds[x])

return ds[x]

for x in range(threshold + 1, n + 1):

if ds[x] == x:

for y in range(2 * x, n + 1, x):

ds[max(find(x), find(y))] = min(find(x), find(y))

return [find(x) == find(y) for x, y in queries]

花花酱 LeetCode 1617. Count Subtrees With Max Distance Between Cities

By zxi on October 11, 2020

There are n cities numbered from 1 to n. You are given an array edges of size n-1, where edges[i] = [u_i, v_i] represents a bidirectional edge between cities u_i and v_i. There exists a unique path between each pair of cities. In other words, the cities form a tree.

A subtree is a subset of cities where every city is reachable from every other city in the subset, where the path between each pair passes through only the cities from the subset. Two subtrees are different if there is a city in one subtree that is not present in the other.

For each d from 1 to n-1, find the number of subtrees in which the maximum distance between any two cities in the subtree is equal to d.

Return an array of size n-1 where the d^thelement (1-indexed) is the number of subtrees in which the maximum distance between any two cities is equal to d.

Notice that the distance between the two cities is the number of edges in the path between them.

Example 1:

Input: n = 4, edges = [[1,2],[2,3],[2,4]]
Output: [3,4,0]
Explanation:
The subtrees with subsets {1,2}, {2,3} and {2,4} have a max distance of 1.
The subtrees with subsets {1,2,3}, {1,2,4}, {2,3,4} and {1,2,3,4} have a max distance of 2.
No subtree has two nodes where the max distance between them is 3.

Example 2:

Input: n = 2, edges = [[1,2]]
Output: [1]

Example 3:

Input: n = 3, edges = [[1,2],[2,3]]
Output: [2,1]

Constraints:

2 <= n <= 15
edges.length == n-1
edges[i].length == 2
1 <= u_i, v_i <= n
All pairs (u_i, v_i) are distinct.

Solution1: Brute Force + Diameter of tree

Try all subtrees and find the diameter of that subtree (longest distance between any node)

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

C++

// Author: Huahua

class Solution {

public:

vector<int> countSubgraphsForEachDiameter(int n, vector<vector<int>>& edges, int last = -1) {

vector<vector<int>> g(n);

for (const auto& e : edges)

g[e[0] - 1].push_back(e[1] - 1), g[e[1] - 1].push_back(e[0] - 1);

vector<int> seen(n, -1), seen2;

queue<int> q;

auto bfs = [&](int start, vector<int>& seen) -> pair<int, int> {

q.push(start);

seen[start] = 1;

int count = 0, dist = -1;

while (!q.empty()) {

int s = q.size();

while (s--) {

last = q.front(); q.pop();

++count;

for (int v : g[last])

if (seen[v] != -1 && !seen[v]++) q.push(v);

}

++dist;

}

return {dist, count};

};

vector<int> ans(n - 1);

for (int s = 0; s < 1 << n; ++s) {

if (__builtin_popcount(s) <= 1) continue;

fill(begin(seen), end(seen), -1);

for (int i = 0; i < n; ++i) if (s & (1 << i)) seen[i] = 0;

seen2 = seen;

const int start = 31 - __builtin_clz(s & (s - 1));

if (bfs(start, seen).second != __builtin_popcount(s)) continue;

++ans[bfs(last, seen2).first - 1];

}

return ans;

}

};

Solution 2: DP on Trees

dp[i][k][d] := # of subtrees rooted at i with tree diameter of d and the distance from i to the farthest node is k.

Time complexity: O(n^5)
Space complexity: O(n^3)

C++

// Author: Huahua, 4ms, 8.8MB

class Solution {

public:

vector<int> countSubgraphsForEachDiameter(int n, vector<vector<int>>& edges) {

vector<vector<int>> g(n);

for (const auto& e : edges) {

g[e[0] - 1].push_back(e[1] - 1);

g[e[1] - 1].push_back(e[0] - 1);

}

vector<vector<vector<int>>> dp(n);

vector<int> sizes(n);

function<void(int, int)> dfs = [&](int u, int p) {

if (!dp[u].empty()) return;

dp[u] = vector<vector<int>>(n, vector<int>(n));

dp[u][0][0] = 1;

sizes[u] = 1;

for (int v : g[u]) {

if (v == p) continue;

dfs(v, u);

vector<vector<int>> dpu(dp[u]);

for (int d1 = 0; d1 < sizes[u]; ++d1)

for (int k1 = 0; k1 <= d1; ++k1) {

if (!dp[u][k1][d1]) continue;

for (int d2 = 0; d2 < sizes[v]; ++d2)

for (int k2 = 0; k2 <= d2; ++k2) {

const int d = max({d1, d2, k1 + k2 + 1});

const int k = max(k1, k2 + 1);

dpu[k][d] += dp[u][k1][d1] * dp[v][k2][d2];

}

swap(dpu, dp[u]);

sizes[u] += sizes[v];

}

};

vector<int> ans(n - 1);

dfs(0, -1);

for (int i = 0; i < n; ++i)

for (int k = 0; k < n; ++k)

for (int d = 1; d < n; ++d)

ans[d - 1] += dp[i][k][d];

return ans;

}

};