Posts tagged as “medium”

花花酱 LeetCode 1593. Split a String Into the Max Number of Unique Substrings

By zxi on September 21, 2020

Given a string s, return the maximum number of unique substrings that the given string can be split into.

You can split string s into any list of non-empty substrings, where the concatenation of the substrings forms the original string. However, you must split the substrings such that all of them are unique.

A substring is a contiguous sequence of characters within a string.

Example 1:

Input: s = "ababccc"
Output: 5
Explanation: One way to split maximally is ['a', 'b', 'ab', 'c', 'cc']. Splitting like ['a', 'b', 'a', 'b', 'c', 'cc'] is not valid as you have 'a' and 'b' multiple times.

Example 2:

Input: s = "aba"
Output: 2
Explanation: One way to split maximally is ['a', 'ba'].

Example 3:

Input: s = "aa"
Output: 1
Explanation: It is impossible to split the string any further.

Constraints:

1 <= s.length <= 16
s contains only lower case English letters.

Solution: Brute Force

Try all combinations.
Time complexity: O(2^n)
Space complexity: O(n)

Iterative/C++

// Author: Huahua

class Solution {

public:

int maxUniqueSplit(string_view s) {

const int n = s.length();

if (n == 1) return 1;

size_t ans = 1;

unordered_set<string_view> seen;

for (int m = 1; m < 1 << (n - 1); ++m) {

if (__builtin_popcount(m) < ans) continue; // 956 ms -> 52 ms

bool valid = true;

int p = 0;

for (int i = 1; i <= n && valid; ++i) {

if (m & (1 << (i - 1)) || i == n) {

valid &= seen.insert(s.substr(p, i - p)).second;

p = i;

}

if (valid) ans = max(ans, seen.size());

seen.clear();

}

return ans;

}

};

DFS/C++

// Author: Huahua

class Solution {

public:

int maxUniqueSplit(string_view s) {

size_t ans = 1;

const int n = s.length();

unordered_set<string_view> seen;

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

if (p == n) {

ans = max(ans, seen.size());

return;

}

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

string_view ss = s.substr(p, i - p + 1);

if (!seen.insert(ss).second) continue;

dfs(i + 1);

seen.erase(ss);

}

};

dfs(0);

return ans;

}

};

花花酱 LeetCode 1590. Make Sum Divisible by P

By zxi on September 20, 2020

Given an array of positive integers nums, remove the smallest subarray (possibly empty) such that the sum of the remaining elements is divisible by p. It is not allowed to remove the whole array.

Return the length of the smallest subarray that you need to remove, or -1 if it’s impossible.

A subarray is defined as a contiguous block of elements in the array.

Example 1:

Input: nums = [3,1,4,2], p = 6
Output: 1
Explanation: The sum of the elements in nums is 10, which is not divisible by 6. We can remove the subarray [4], and the sum of the remaining elements is 6, which is divisible by 6.

Example 2:

Input: nums = [6,3,5,2], p = 9
Output: 2
Explanation: We cannot remove a single element to get a sum divisible by 9. The best way is to remove the subarray [5,2], leaving us with [6,3] with sum 9.

Example 3:

Input: nums = [1,2,3], p = 3
Output: 0
Explanation: Here the sum is 6. which is already divisible by 3. Thus we do not need to remove anything.

Example 4:

Input: nums = [1,2,3], p = 7
Output: -1
Explanation: There is no way to remove a subarray in order to get a sum divisible by 7.

Example 5:

Input: nums = [1000000000,1000000000,1000000000], p = 3
Output: 0

Constraints:

1 <= nums.length <= 10⁵
1 <= nums[i] <= 10⁹
1 <= p <= 10⁹

Solution: HashTable + Prefix Sum

Very similar to subarray target sum.

Basically, we are trying to find a shortest subarray that has sum % p equals to r = sum(arr) % p.

We use a hashtable to store the last index of the prefix sum % p and check whether (prefix_sum + p – r) % p exists or not.

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

C++

class Solution {

public:

int minSubarray(vector<int>& nums, int p) {

const int n = nums.size();

int r = accumulate(begin(nums), end(nums), 0LL) % p;

if (r == 0) return 0;

unordered_map<int, int> m{{0, -1}}; // {prefix_sum % p -> last_index}

int s = 0;

int ans = n;

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

s = (s + nums[i]) % p;

auto it = m.find((s + p - r) % p);

if (it != m.end())

ans = min(ans, i - it->second);

m[s] = i;

}

return ans == n ? -1 : ans;

}

};

Python3

class Solution:

def minSubarray(self, nums: List[int], p: int) -> int:

r = sum(nums) % p

if r == 0: return 0

m = {0: -1}

ans = len(nums)

s = 0

for i, x in enumerate(nums):

s = (s + x) % p

t = (s + p - r) % p

if t in m:

ans = min(ans, i - m[t])

m[s] = i

return -1 if ans == len(nums) else ans

花花酱 LeetCode 1589. Maximum Sum Obtained of Any Permutation

By zxi on September 19, 2020

We have an array of integers, nums, and an array of requests where requests[i] = [start_i, end_i]. The i^th request asks for the sum of nums[start_i] + nums[start_i + 1] + ... + nums[end_i - 1] + nums[end_i]. Both start_i and end_i are 0-indexed.

Return the maximum total sum of all requests among all permutations of nums.

Since the answer may be too large, return it modulo 10⁹ + 7.

Example 1:

Input: nums = [1,2,3,4,5], requests = [[1,3],[0,1]]
Output: 19
Explanation: One permutation of nums is [2,1,3,4,5] with the following result: 
requests[0] -> nums[1] + nums[2] + nums[3] = 1 + 3 + 4 = 8
requests[1] -> nums[0] + nums[1] = 2 + 1 = 3
Total sum: 8 + 3 = 11.
A permutation with a higher total sum is [3,5,4,2,1] with the following result:
requests[0] -> nums[1] + nums[2] + nums[3] = 5 + 4 + 2 = 11
requests[1] -> nums[0] + nums[1] = 3 + 5  = 8
Total sum: 11 + 8 = 19, which is the best that you can do.

Example 2:

Input: nums = [1,2,3,4,5,6], requests = [[0,1]]
Output: 11
Explanation: A permutation with the max total sum is [6,5,4,3,2,1] with request sums [11].

Example 3:

Input: nums = [1,2,3,4,5,10], requests = [[0,2],[1,3],[1,1]]
Output: 47
Explanation: A permutation with the max total sum is [4,10,5,3,2,1] with request sums [19,18,10].

Constraints:

n == nums.length
1 <= n <= 10⁵
0 <= nums[i] <= 10⁵
1 <= requests.length <= 10⁵
requests[i].length == 2
0 <= start_i <= end_i < n

Solution: Greedy + Sweep line

Sort the numbers, and sort the frequency of each index, it’s easy to show largest number with largest frequency gives us max sum.

ans = sum(nums[i] * freq[i])

We can use sweep line to compute the frequency of each index in O(n) time and space.

For each request [start, end] : ++freq[start], –freq[end + 1]

Then the prefix sum of freq array is the frequency for each index.

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

C++

class Solution {

public:

int maxSumRangeQuery(vector<int>& nums, vector<vector<int>>& requests) {

constexpr int kMod = 1e9 + 7;

const int n = nums.size();

vector<long> freq(n);

for (const auto& r : requests) {

++freq[r[0]];

if (r[1] + 1 < n) --freq[r[1] + 1];

}

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

freq[i] += freq[i - 1];

sort(begin(freq), end(freq));

sort(begin(nums), end(nums));

long ans = 0;

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

ans += freq[i] * nums[i];

return ans % kMod;

}

};

花花酱 LeetCode 1584. Min Cost to Connect All Points

By zxi on September 13, 2020

You are given an array points representing integer coordinates of some points on a 2D-plane, where points[i] = [x_i, y_i].

Return the minimum cost to make all points connected. All points are connected if there is exactly one simple path between any two points.

Example 1:

Input: points = [[0,0],[2,2],[3,10],[5,2],[7,0]]
Output: 20
Explanation:

We can connect the points as shown above to get the minimum cost of 20.
Notice that there is a unique path between every pair of points.

Example 2:

Input: points = [[3,12],[-2,5],[-4,1]]
Output: 18

Example 3:

Input: points = [[0,0],[1,1],[1,0],[-1,1]]
Output: 4

Example 4:

Input: points = [[-1000000,-1000000],[1000000,1000000]]
Output: 4000000

Example 5:

Input: points = [[0,0]]
Output: 0

Constraints:

1 <= points.length <= 1000
-10⁶ <= x_i, y_i <= 10⁶
All pairs (x_i, y_i) are distinct.

Solution: Minimum Spanning Tree

Kruskal’s algorithm
Time complexity: O(n^2logn)
Space complexity: O(n^2)
using vector of vector, array, pair of pair, or tuple might lead to TLE…

C++

struct Edge {

int cost;

int x;

int y;

bool operator<(const Edge& e) const { return cost < e.cost; }

};

class Solution {

public:

int minCostConnectPoints(vector<vector<int>>& points) {

const int n = points.size();

vector<Edge> edges(n * (n - 1) / 2); // {cost, i, j}

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

for (int j = i + 1; j < n; ++j)

edges[idx++] = {abs(points[i][0] - points[j][0]) +

abs(points[i][1] - points[j][1]), i, j};

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

vector<int> p(n);

std::iota(begin(p), end(p), 0);

vector<int> rank(n, 0);

int ans = 0;

int count = 0;

for (const auto& e : edges) {

int rx = find(p, e.x);

int ry = find(p, e.y);

if (rx == ry) continue;

ans += e.cost;

if (rank[rx] < rank[ry]) swap(rx, ry);

p[rx] = ry;

rank[ry] += rank[rx] == rank[ry];

if (++count == n - 1) break;

}

return ans;

}

private:

int find(vector<int>& p, int x) const {

while (p[x] != x) {

int tp = p[x];

p[x] = p[p[x]];

x = tp;

}

return x;

}

};

Prim’s Algorithm
ds[i] := min distance from i to ANY nodes in the tree.

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

C++

class Solution {

public:

int minCostConnectPoints(vector<vector<int>>& points) {

const int n = points.size();

auto dist = [](const vector<int>& pi, const vector<int>& pj) {

return abs(pi[0] - pj[0]) + abs(pi[1] - pj[1]);

};

vector<int> ds(n, INT_MAX);

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

ds[i] = dist(points[0], points[i]);

int ans = 0;

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

auto it = min_element(begin(ds), end(ds));

const int v = distance(begin(ds), it);

ans += ds[v];

ds[v] = INT_MAX; // done

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

if (ds[i] == INT_MAX) continue;

ds[i] = min(ds[i], dist(points[i], points[v]));

}

return ans;

}

};

花花酱 LeetCode 1583. Count Unhappy Friends

By zxi on September 12, 2020

You are given a list of preferences for n friends, where n is always even.

For each person i, preferences[i] contains a list of friends sorted in the order of preference. In other words, a friend earlier in the list is more preferred than a friend later in the list. Friends in each list are denoted by integers from 0 to n-1.

All the friends are divided into pairs. The pairings are given in a list pairs, where pairs[i] = [x_i, y_i] denotes x_i is paired with y_i and y_i is paired with x_i.

However, this pairing may cause some of the friends to be unhappy. A friend x is unhappy if x is paired with y and there exists a friend u who is paired with v but:

x prefers u over y, and
u prefers x over v.

Return the number of unhappy friends.

Example 1:

Input: n = 4, preferences = [[1, 2, 3], [3, 2, 0], [3, 1, 0], [1, 2, 0]], pairs = [[0, 1], [2, 3]]
Output: 2
Explanation:
Friend 1 is unhappy because:
- 1 is paired with 0 but prefers 3 over 0, and
- 3 prefers 1 over 2.
Friend 3 is unhappy because:
- 3 is paired with 2 but prefers 1 over 2, and
- 1 prefers 3 over 0.
Friends 0 and 2 are happy.

Example 2:

Input: n = 2, preferences = [[1], [0]], pairs = [[1, 0]]
Output: 0
Explanation: Both friends 0 and 1 are happy.

Example 3:

Input: n = 4, preferences = [[1, 3, 2], [2, 3, 0], [1, 3, 0], [0, 2, 1]], pairs = [[1, 3], [0, 2]]
Output: 4

Constraints:

2 <= n <= 500
n is even.
preferences.length == n
preferences[i].length == n - 1
0 <= preferences[i][j] <= n - 1
preferences[i] does not contain i.
All values in preferences[i] are unique.
pairs.length == n/2
pairs[i].length == 2
x_i != y_i
0 <= x_i, y_i <= n - 1
Each person is contained in exactly one pair.

Solution: HashTable

Put the order in a map {x -> {y, order}}, since this is dense, we use can 2D array instead of hasthable which is much faster.

Then for each pair, we just need to check every other pair and compare their orders.

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

C++

class Solution {

public:

int unhappyFriends(int n, vector<vector<int>>& preferences, vector<vector<int>>& pairs) {

vector<int> p(n);

for (const auto& pair : pairs) {

p[pair[0]] = pair[1];

p[pair[1]] = pair[0];

}

vector<vector<int>> orders(n, vector<int>(n));

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

for (int i = 0; i < preferences[x].size(); ++i)

orders[x][preferences[x][i]] = i;

int ans = 0;

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

const int y = p[x];

bool found = false;

for (int u = 0; u < n && !found; ++u) {

if (u == x || u == y) continue;

const int v = p[u];

found |= orders[x][u] < orders[x][y] && orders[u][x] < orders[u][v];

}

if (found) ++ans;

}

return ans;

}

};