Posts tagged as “medium”

花花酱 LeetCode 1578. Minimum Deletion Cost to Avoid Repeating Letters

By zxi on September 5, 2020

Given a string s and an array of integers cost where cost[i] is the cost of deleting the character i in s.

Return the minimum cost of deletions such that there are no two identical letters next to each other.

Notice that you will delete the chosen characters at the same time, in other words, after deleting a character, the costs of deleting other characters will not change.

Example 1:

Input: s = "abaac", cost = [1,2,3,4,5]
Output: 3
Explanation: Delete the letter "a" with cost 3 to get "abac" (String without two identical letters next to each other).

Example 2:

Input: s = "abc", cost = [1,2,3]
Output: 0
Explanation: You don't need to delete any character because there are no identical letters next to each other.

Example 3:

Input: s = "aabaa", cost = [1,2,3,4,1]
Output: 2
Explanation: Delete the first and the last character, getting the string ("aba").

Constraints:

s.length == cost.length
1 <= s.length, cost.length <= 10^5
1 <= cost[i] <= 10^4
s contains only lowercase English letters.

Solution: Group by group

For a group of same letters, delete all expect the one with the highest cost.

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

C++

class Solution {

public:

int minCost(string s, vector<int>& cost) {

int t = cost[0];

int m = cost[0];

int ans = 0;

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

if (s[i] != s[i - 1]) {

ans += t - m;

t = m = 0;

}

t += cost[i];

m = max(m, cost[i]);

}

return ans + (t - m);

}

};

python3

class Solution:

def minCost(self, s: str, cost: List[int]) -> int:

s = '*' + s + '*'

cost = [0] + cost + [0]

ans = t = m = 0

for i in range(1, len(s)):

if s[i] != s[i - 1]:

ans += t - m

t = m = 0

t += cost[i]

m = max(m, cost[i])

return ans

花花酱 LeetCode 1577. Number of Ways Where Square of Number Is Equal to Product of Two Numbers

By zxi on September 5, 2020

Given two arrays of integers nums1 and nums2, return the number of triplets formed (type 1 and type 2) under the following rules:

Type 1: Triplet (i, j, k) if nums1[i]² == nums2[j] * nums2[k] where 0 <= i < nums1.length and 0 <= j < k < nums2.length.
Type 2: Triplet (i, j, k) if nums2[i]² == nums1[j] * nums1[k] where 0 <= i < nums2.length and 0 <= j < k < nums1.length.

Example 1:

Input: nums1 = [7,4], nums2 = [5,2,8,9]
Output: 1
Explanation: Type 1: (1,1,2), nums1[1]^2 = nums2[1] * nums2[2]. (4^2 = 2 * 8).

Example 2:

Input: nums1 = [1,1], nums2 = [1,1,1]
Output: 9
Explanation: All Triplets are valid, because 1^2 = 1 * 1.
Type 1: (0,0,1), (0,0,2), (0,1,2), (1,0,1), (1,0,2), (1,1,2).  nums1[i]^2 = nums2[j] * nums2[k].
Type 2: (0,0,1), (1,0,1), (2,0,1). nums2[i]^2 = nums1[j] * nums1[k].

Example 3:

Input: nums1 = [7,7,8,3], nums2 = [1,2,9,7]
Output: 2
Explanation: There are 2 valid triplets.
Type 1: (3,0,2).  nums1[3]^2 = nums2[0] * nums2[2].
Type 2: (3,0,1).  nums2[3]^2 = nums1[0] * nums1[1].

Example 4:

Input: nums1 = [4,7,9,11,23], nums2 = [3,5,1024,12,18]
Output: 0
Explanation: There are no valid triplets.

Constraints:

1 <= nums1.length, nums2.length <= 1000
1 <= nums1[i], nums2[i] <= 10^5

Solution: Hashtable

For each number y in the second array, count its frequency.

For each number x in the first, if x * x % y == 0, let r = x * x / y
if r == y: ans += f[y] * f[y-1]
else ans += f[y] * f[r]

Final ans /= 2

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

C++

// Author: Huahua

class Solution {

public:

int numTriplets(vector<int>& nums1, vector<int>& nums2) {

return solve(nums1, nums2) + solve(nums2, nums1);

}

private:

int solve(vector<int>& nums1, vector<int>& nums2) {

int ans = 0;

unordered_map<int, int> f;

for (int y : nums2) ++f[y];

for (long x : nums1)

for (const auto& [y, c] : f) {

long r = x * x / y;

if (x * x % y || !f.count(r)) continue;

if (r == y) ans += c * (c - 1);

else ans += c * f[r];

}

return ans / 2;

}

};

花花酱 LeetCode 1568. Minimum Number of Days to Disconnect Island

By zxi on August 30, 2020

Given a 2D grid consisting of 1s (land) and 0s (water). An island is a maximal 4-directionally (horizontal or vertical) connected group of 1s.

The grid is said to be connected if we have exactly one island, otherwise is said disconnected.

In one day, we are allowed to change any single land cell (1) into a water cell (0).

Return the minimum number of days to disconnect the grid.

Example 1:

Input: grid = [[0,1,1,0],[0,1,1,0],[0,0,0,0]]
Output: 2
Explanation: We need at least 2 days to get a disconnected grid.
Change land grid[1][1] and grid[0][2] to water and get 2 disconnected island.

Example 2:

Input: grid = [[1,1]]
Output: 2
Explanation: Grid of full water is also disconnected ([[1,1]] -> [[0,0]]), 0 islands.

Example 3:

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

Example 4:

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

Example 5:

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

Constraints:

1 <= grid.length, grid[i].length <= 30
grid[i][j] is 0 or 1.

Solution: Brute Force

We need at most two days to disconnect an island.
1. check if we have more than one islands. (0 days)
2. For each 1 cell, change it to 0 and check how many islands do we have. (1 days)
3. Otherwise, 2 days

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

C++

class Solution {

public:

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

const int n = grid.size();

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

const vector<int> dirs{0, 1, 0, -1, 0};

vector<int> seen(n * m);

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

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

if (grid[y][x] == 0) return;

if (seen[y * m + x]++) return;

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

dfs(x + dirs[i], y + dirs[i + 1]);

};

function<bool()> disconnected = [&]() {

int count = 0;

fill(begin(seen), end(seen), 0);

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

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

if (grid[y][x] && !seen[y * m + x]) {

dfs(x, y);

if (++count > 1) return true;

}

return false;

};

if (disconnected()) return 0;

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

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

if (!grid[y][x]) continue;

grid[y][x] = 0;

if (disconnected()) return 1;

grid[y][x] = 1;

}

return 2;

}

};

花花酱 LeetCode 1567. Maximum Length of Subarray With Positive Product

By zxi on August 29, 2020

Given an array of integers nums, find the maximum length of a subarray where the product of all its elements is positive.

A subarray of an array is a consecutive sequence of zero or more values taken out of that array.

Return the maximum length of a subarray with positive product.

Example 1:

Input: nums = [1,-2,-3,4]
Output: 4
Explanation: The array nums already has a positive product of 24.

Example 2:

Input: nums = [0,1,-2,-3,-4]
Output: 3
Explanation: The longest subarray with positive product is [1,-2,-3] which has a product of 6.
Notice that we cannot include 0 in the subarray since that'll make the product 0 which is not positive.

Example 3:

Input: nums = [-1,-2,-3,0,1]
Output: 2
Explanation: The longest subarray with positive product is [-1,-2] or [-2,-3].

Example 4:

Input: nums = [-1,2]
Output: 1

Example 5:

Input: nums = [1,2,3,5,-6,4,0,10]
Output: 4

Constraints:

1 <= nums.length <= 10^5
-10^9 <= nums[i] <= 10^9

Solution: DP

p[i] := max length of positive products ends with arr[i]
n[i] := max length of negtive products ends with arr[i]

if arr[i] > 0: p[i] = p[i – 1] + 1, n[i] = n[i] + 1 if n[i] else 0
if arr[i] < 0: p[i] = n[i – 1] + 1 if n[i – 1] else 0, n[i] = p[i – 1] + 1
if arr[i] == 0: p[i] = n[i] = 0
ans = max(p[i])

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

C++

class Solution {

public:

int getMaxLen(vector<int>& nums) {

int p = 0;

int n = 0;

int ans = 0;

for (int x : nums) {

if (x > 0) {

++p;

if (n) ++n;

} else if (x < 0) {

int tp = p;

p = n ? n + 1 : 0;

n = tp + 1;

} else {

p = n = 0;

}

ans = max(ans, p);

}

return ans;

}

};

花花酱 LeetCode 1562. Find Latest Group of Size M

By zxi on August 23, 2020

Given an array arr that represents a permutation of numbers from 1 to n. You have a binary string of size n that initially has all its bits set to zero.

At each step i (assuming both the binary string and arr are 1-indexed) from 1 to n, the bit at position arr[i] is set to 1. You are given an integer m and you need to find the latest step at which there exists a group of ones of length m. A group of ones is a contiguous substring of 1s such that it cannot be extended in either direction.

Return the latest step at which there exists a group of ones of length exactly m. If no such group exists, return -1.

Example 1:

Input: arr = [3,5,1,2,4], m = 1
Output: 4
Explanation:
Step 1: "00100", groups: ["1"]
Step 2: "00101", groups: ["1", "1"]
Step 3: "10101", groups: ["1", "1", "1"]
Step 4: "11101", groups: ["111", "1"]
Step 5: "11111", groups: ["11111"]
The latest step at which there exists a group of size 1 is step 4.

Example 2:

Input: arr = [3,1,5,4,2], m = 2
Output: -1
Explanation:
Step 1: "00100", groups: ["1"]
Step 2: "10100", groups: ["1", "1"]
Step 3: "10101", groups: ["1", "1", "1"]
Step 4: "10111", groups: ["1", "111"]
Step 5: "11111", groups: ["11111"]
No group of size 2 exists during any step.

Example 3:

Input: arr = [1], m = 1
Output: 1

Example 4:

Input: arr = [2,1], m = 2
Output: 2

Constraints:

n == arr.length
1 <= n <= 10^5
1 <= arr[i] <= n
All integers in arr are distinct.
1 <= m <= arr.length

Solution: Hashtable

Similar to LC 128

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

C++

// Author: Huahua

class Solution {

public:

int findLatestStep(vector<int>& arr, int m) {

const int n = arr.size();

vector<int> len(n + 2);

vector<int> counts(n + 2);

int ans = -1;

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

const int x = arr[i];

const int l = len[x - 1];

const int r = len[x + 1];

const int t = 1 + l + r;

len[x - l] = len[x + r] = t;

--counts[l];

--counts[r];

++counts[t];

if (counts[m]) ans = i + 1;

}

return ans;

}

};