Posts tagged as “medium”

花花酱 LeetCode 1268. Search Suggestions System

By zxi on November 24, 2019

Given an array of strings products and a string searchWord. We want to design a system that suggests at most three product names from products after each character of searchWord is typed. Suggested products should have common prefix with the searchWord. If there are more than three products with a common prefix return the three lexicographically minimums products.

Return list of lists of the suggested products after each character of searchWord is typed.

Example 1:

Input: products = ["mobile","mouse","moneypot","monitor","mousepad"], searchWord = "mouse"
Output: [
["mobile","moneypot","monitor"],
["mobile","moneypot","monitor"],
["mouse","mousepad"],
["mouse","mousepad"],
["mouse","mousepad"]
]
Explanation: products sorted lexicographically = ["mobile","moneypot","monitor","mouse","mousepad"]
After typing m and mo all products match and we show user ["mobile","moneypot","monitor"]
After typing mou, mous and mouse the system suggests ["mouse","mousepad"]

Example 2:

Input: products = ["havana"], searchWord = "havana"
Output: [["havana"],["havana"],["havana"],["havana"],["havana"],["havana"]]

Example 3:

Input: products = ["bags","baggage","banner","box","cloths"], searchWord = "bags"
Output: [["baggage","bags","banner"],["baggage","bags","banner"],["baggage","bags"],["bags"]]

Example 4:

Input: products = ["havana"], searchWord = "tatiana"
Output: [[],[],[],[],[],[],[]]

Constraints:

1 <= products.length <= 1000
1 <= Σ products[i].length <= 2 * 10^4
All characters of products[i] are lower-case English letters.
1 <= searchWord.length <= 1000
All characters of searchWord are lower-case English letters.

Solution 1: Binary Search

Sort the input array and do two binary searches.
One for prefix of the search word as lower bound, another for prefix + ‘~’ as upper bound.
‘~’ > ‘z’

Time complexity: O(nlogn + l * logn)
Space complexity: O(1)

C++

// Author: Huahua, 36ms, 35MB

class Solution {

public:

vector<vector<string>> suggestedProducts(vector<string>& products, string searchWord) {

vector<vector<string>> ans;

std::sort(begin(products), end(products));

string key;

for (char c : searchWord) {

key += c;

auto l = lower_bound(begin(products), end(products), key);

auto r = upper_bound(begin(products), end(products), key += '~');

if (l == r) break; // early return

key.pop_back();

ans.emplace_back(l, min(l + 3, r));

}

while (ans.size() != searchWord.length()) ans.push_back({});

return ans;

}

};

Solution 2: Trie

Initialization: Sum(len(products[i]))
Query: O(len(searchWord))

C++

// Author: Huahua, 148 ms, 98.8 MB

struct Trie {

Trie(): nodes(26) {}

~Trie() {

for (auto* node : nodes)

delete node;

}

vector<Trie*> nodes;

vector<const string*> words;

static void addWord(Trie* root, const string& word) {

for (char c : word) {

if (root->nodes[c - 'a'] == nullptr) root->nodes[c - 'a'] = new Trie();

root = root->nodes[c - 'a'];

if (root->words.size() < 3)

root->words.push_back(&word);

}

static vector<vector<string>> getWords(Trie* root, const string& prefix) {

vector<vector<string>> ans(prefix.size());

for (int i = 0; i < prefix.size(); ++i) {

char c = prefix[i];

root = root->nodes[c - 'a'];

if (root == nullptr) break;

for (auto* word : root->words)

ans[i].push_back(*word);

}

return ans;

}

};

class Solution {

public:

vector<vector<string>> suggestedProducts(vector<string>& products, string searchWord) {

std::sort(begin(products), end(products));

Trie root;

for (const auto& product : products)

Trie::addWord(&root, product);

return Trie::getWords(&root, searchWord);

}

};

花花酱 LeetCode 1267. Count Servers that Communicate

By zxi on November 23, 2019

You are given a map of a server center, represented as a m * n integer matrix grid, where 1 means that on that cell there is a server and 0 means that it is no server. Two servers are said to communicate if they are on the same row or on the same column.

Return the number of servers that communicate with any other server.

Example 1:

Input: grid = [[1,0],[0,1]]
Output: 0
Explanation: No servers can communicate with others.

Example 2:

Input: grid = [[1,0],[1,1]]
Output: 3
Explanation: All three servers can communicate with at least one other server.

Example 3:

Input: grid = [[1,1,0,0],[0,0,1,0],[0,0,1,0],[0,0,0,1]]
Output: 4
Explanation: The two servers in the first row can communicate with each other. The two servers in the third column can communicate with each other. The server at right bottom corner can't communicate with any other server.

Constraints:

m == grid.length
n == grid[i].length
1 <= m <= 250
1 <= n <= 250
grid[i][j] == 0 or 1

Solution: Counting

Two passes:
First pass, count number of computers for each row and each column.
Second pass, count grid[i][j] if rows[i] or cols[j] has more than 1 computer.

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

C++

// Author: Huahua

class Solution {

public:

int countServers(vector<vector<int>>& grid) {

const size_t m = grid.size();

const size_t n = grid[0].size();

vector<int> rows(m);

vector<int> cols(n);

for (size_t i = 0; i < m; ++i)

for (size_t j = 0; j < n; ++j) {

rows[i] += grid[i][j];

cols[j] += grid[i][j];

}

int ans = 0;

for (size_t i = 0; i < m; ++i)

for (size_t j = 0; j < n; ++j)

ans += (rows[i] > 1 || cols[j] > 1) ? grid[i][j] : 0;

return ans;

}

};

花花酱 LeetCode 1253. Reconstruct a 2-Row Binary Matrix

By zxi on November 9, 2019

Given the following details of a matrix with n columns and 2 rows :

The matrix is a binary matrix, which means each element in the matrix can be 0 or 1.
The sum of elements of the 0-th(upper) row is given as upper.
The sum of elements of the 1-st(lower) row is given as lower.
The sum of elements in the i-th column(0-indexed) is colsum[i], where colsum is given as an integer array with length n.

Your task is to reconstruct the matrix with upper, lower and colsum.

Return it as a 2-D integer array.

If there are more than one valid solution, any of them will be accepted.

If no valid solution exists, return an empty 2-D array.

Example 1:

Input: upper = 2, lower = 1, colsum = [1,1,1]
Output: [[1,1,0],[0,0,1]]
Explanation: [[1,0,1],[0,1,0]], and [[0,1,1],[1,0,0]] are also correct answers.

Example 2:

Input: upper = 2, lower = 3, colsum = [2,2,1,1]
Output: []

Example 3:

Input: upper = 5, lower = 5, colsum = [2,1,2,0,1,0,1,2,0,1]
Output: [[1,1,1,0,1,0,0,1,0,0],[1,0,1,0,0,0,1,1,0,1]]

Constraints:

1 <= colsum.length <= 10^5
0 <= upper, lower <= colsum.length
0 <= colsum[i] <= 2

Solution: Greedy?

Two passes:
first pass, only process sum = 2, upper = 1, lower = 1
second pass, only process sum = 1, whoever has more leftover, assign 1 to that row.

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

C++

// Author: Huahua

class Solution {

public:

vector<vector<int>> reconstructMatrix(int upper, int lower, vector<int>& colsum) {

const int n = colsum.size();

vector<vector<int>> a(2, vector<int>(n));

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

if (colsum[i] == 2) {

a[0][i] = a[1][i] = 1;

--upper;

--lower;

}

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

if (colsum[i] == 1)

if (upper > lower) {

a[0][i] = 1;

--upper;

} else {

a[1][i] = 1;

--lower;

}

if (upper != 0 || lower != 0) return {};

return a;

}

};

花花酱 LeetCode 1254. Number of Closed Islands

By zxi on November 9, 2019

Given a 2D grid consists of 0s (land) and 1s (water). An island is a maximal 4-directionally connected group of 0s and a closed island is an island totally (all left, top, right, bottom) surrounded by 1s.

Return the number of closed islands.

Example 1:

Input: grid = [[1,1,1,1,1,1,1,0],[1,0,0,0,0,1,1,0],[1,0,1,0,1,1,1,0],[1,0,0,0,0,1,0,1],[1,1,1,1,1,1,1,0]]
Output: 2
Explanation: 
Islands in gray are closed because they are completely surrounded by water (group of 1s).

Example 2:

Input: grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]
Output: 1

Example 3:

Input: grid = [[1,1,1,1,1,1,1],
               [1,0,0,0,0,0,1],
               [1,0,1,1,1,0,1],
               [1,0,1,0,1,0,1],
               [1,0,1,1,1,0,1],
               [1,0,0,0,0,0,1],
               [1,1,1,1,1,1,1]]
Output: 2

Constraints:

1 <= grid.length, grid[0].length <= 100
0 <= grid[i][j] <=1

Solution: DFS/Backtracking

For each connected component, if it can reach the boundary then it’s not a closed island.

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

C++

// Author: Huahua

class Solution {

public:

int closedIsland(vector<vector<int>>& grid) {

const int n = grid.size();

const int m = grid[0].size();

function<int(int, int)> dfs = [&](int x, int y) {

if (x < 0 || y < 0 || x >= m || y >= n) return 0;

if (grid[y][x]++) return 1;

return dfs(x + 1, y) & dfs(x - 1, y) & dfs(x, y + 1) & dfs(x, y - 1);

};

int ans = 0;

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

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

if (!grid[i][j]) ans += dfs(j, i);

return ans;

}

};

花花酱 1249. Minimum Remove to Make Valid Parentheses

By zxi on November 9, 2019

Given a string s of '(' , ')' and lowercase English characters.

Your task is to remove the minimum number of parentheses ( '(' or ')', in any positions ) so that the resulting parentheses string is valid and return any valid string.

Formally, a parentheses string is valid if and only if:

It is the empty string, contains only lowercase characters, or
It can be written as AB (A concatenated with B), where A and B are valid strings, or
It can be written as (A), where A is a valid string.

Example 1:

Input: s = "lee(t(c)o)de)"
Output: "lee(t(c)o)de"
Explanation: "lee(t(co)de)" , "lee(t(c)ode)" would also be accepted.

Example 2:

Input: s = "a)b(c)d"
Output: "ab(c)d"

Example 3:

Input: s = "))(("
Output: ""
Explanation: An empty string is also valid.

Example 4:

Input: s = "(a(b(c)d)"
Output: "a(b(c)d)"

Constraints:

1 <= s.length <= 10^5
s[i] is one of '(' , ')' and lowercase English letters.

Solution: Couting

Count how many “(” are open and how many “)” left.

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

C++

// Author: Huahua

class Solution {

public:

string minRemoveToMakeValid(string s) {

int close = count(begin(s), end(s), ')');

int open = 0;

string ans;

for (char c : s) {

if (c == '(') {

if (open == close) continue;

++open;

} else if (c == ')') {

--close;

if (open == 0) continue;

--open;

}

ans += c;

}

return ans;

}

};