Posts tagged as “hard”

花花酱 LeetCode 1335. Minimum Difficulty of a Job Schedule

By zxi on January 27, 2020

You want to schedule a list of jobs in d days. Jobs are dependent (i.e To work on the i-th job, you have to finish all the jobs j where 0 <= j < i).

You have to finish at least one task every day. The difficulty of a job schedule is the sum of difficulties of each day of the d days. The difficulty of a day is the maximum difficulty of a job done in that day.

Given an array of integers jobDifficulty and an integer d. The difficulty of the i-th job is jobDifficulty[i].

Return the minimum difficulty of a job schedule. If you cannot find a schedule for the jobs return -1.

Example 1:

Input: jobDifficulty = [6,5,4,3,2,1], d = 2
Output: 7
Explanation: First day you can finish the first 5 jobs, total difficulty = 6.
Second day you can finish the last job, total difficulty = 1.
The difficulty of the schedule = 6 + 1 = 7

Example 2:

Input: jobDifficulty = [9,9,9], d = 4
Output: -1
Explanation: If you finish a job per day you will still have a free day. you cannot find a schedule for the given jobs.

Example 3:

Input: jobDifficulty = [1,1,1], d = 3
Output: 3
Explanation: The schedule is one job per day. total difficulty will be 3.

Example 4:

Input: jobDifficulty = [7,1,7,1,7,1], d = 3
Output: 15

Example 5:

Input: jobDifficulty = [11,111,22,222,33,333,44,444], d = 6
Output: 843

Constraints:

1 <= jobDifficulty.length <= 300
0 <= jobDifficulty[i] <= 1000
1 <= d <= 10

Solution: DP

dp[i][k] := min difficulties to schedule jobs 1~i in k days.

Schedule 1 ~ j in k – 1 days and schedule j + 1 ~ i in 1 day.

Init: dp[0][0] = 0
Transition: dp[i][k] := min(dp[j][k -1] + max(jobs[j + 1 ~ i]), k – 1 <= j < i
Answer: dp[n][d]

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

C++

// Author: Huahua

class Solution {

public:

int minDifficulty(vector<int>& jobs, int d) {

const int n = jobs.size();

if (d > n) return -1;

vector<vector<int>> dp(n + 1, vector<int>(d + 1, INT_MAX / 2));

dp[0][0] = 0;

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

for (int j = i - 1, md = 0; j >= 0; --j) {

md = max(md, jobs[j]);

for (int k = 1; k <= min(i, d); ++k)

dp[i][k] = min(dp[i][k], dp[j][k - 1] + md);

}

return dp[n][d];

}

};

花花酱 LeetCode 42. Trapping Rain Water

By zxi on January 15, 2020

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!

Example:

Input: [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6

Solution 1: Brute Force

r[i] = min(max(h[0:i+1]), max(h[i:n]))
ans = sum(r[i])

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

C++

// Author: Huahua

class Solution {

public:

int trap(vector<int>& height) {

const int n = height.size();

int ans = 0;

auto sit = cbegin(height);

auto eit = cend(height);

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

int l = *max_element(sit, sit + i + 1);

int r = *max_element(sit + i, eit);

ans += min(l, r) - height[i];

}

return ans;

}

};

Solution 2: DP

l[i] := max(h[0:i+1])
r[i] := max(h[i:n])
ans = sum(min(l[i], r[i]) – h[i])

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

C++

// Author: Huahua

class Solution {

public:

int trap(vector<int>& height) {

const int n = height.size();

vector<int> l(n);

vector<int> r(n);

int ans = 0;

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

l[i] = i == 0 ? height[i] : max(l[i - 1], height[i]);

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

r[i] = i == n - 1 ? height[i] : max(r[i + 1], height[i]);

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

ans += min(l[i], r[i]) - height[i];

return ans;

}

};

Solution 3: Two Pointers

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

C++

// Author: Huahua, 4 ms, 9.1 MB

class Solution {

public:

int trap(vector<int>& height) {

const int n = height.size();

if (n == 0) return 0;

int l = 0;

int r = n - 1;

int max_l = height[l];

int max_r = height[r];

int ans = 0;

while (l < r) {

if (max_l < max_r) {

ans += max_l - height[l];

max_l = max(max_l, height[++l]);

} else {

ans += max_r - height[r];

max_r = max(max_r, height[--r]);

}

return ans;

}

};

花花酱 LeetCode 1320. Minimum Distance to Type a Word Using Two Fingers

By zxi on January 12, 2020

You have a keyboard layout as shown above in the XY plane, where each English uppercase letter is located at some coordinate, for example, the letter A is located at coordinate (0,0), the letter B is located at coordinate (0,1), the letter P is located at coordinate (2,3) and the letter Z is located at coordinate (4,1).

Given the string word, return the minimum total distance to type such string using only two fingers. The distance between coordinates (x₁,y₁) and (x₂,y₂) is |x₁ – x₂| + |y₁ – y₂|.

Note that the initial positions of your two fingers are considered free so don’t count towards your total distance, also your two fingers do not have to start at the first letter or the first two letters.

Example 1:

Input: word = "CAKE"
Output: 3
Explanation: 
Using two fingers, one optimal way to type "CAKE" is: 
Finger 1 on letter 'C' -> cost = 0 
Finger 1 on letter 'A' -> cost = Distance from letter 'C' to letter 'A' = 2 
Finger 2 on letter 'K' -> cost = 0 
Finger 2 on letter 'E' -> cost = Distance from letter 'K' to letter 'E' = 1 
Total distance = 3

Example 2:

Input: word = "HAPPY"
Output: 6
Explanation: 
Using two fingers, one optimal way to type "HAPPY" is:
Finger 1 on letter 'H' -> cost = 0
Finger 1 on letter 'A' -> cost = Distance from letter 'H' to letter 'A' = 2
Finger 2 on letter 'P' -> cost = 0
Finger 2 on letter 'P' -> cost = Distance from letter 'P' to letter 'P' = 0
Finger 1 on letter 'Y' -> cost = Distance from letter 'A' to letter 'Y' = 4
Total distance = 6

Example 3:

Input: word = "NEW"
Output: 3

Example 4:

Input: word = "YEAR"
Output: 7

Constraints:

2 <= word.length <= 300
Each word[i] is an English uppercase letter.

Solution: DP

Top down: O(n*27^2)

C++

// Author: Huahua, 64 ms, 46.6 MB

class Solution {

public:

int minimumDistance(string word) {

constexpr int kRest = 26;

const int n = word.length();

vector<vector<vector<int>>> mem(n, vector<vector<int>>(27, vector<int>(27, -1)));

auto cost = [](int c1, int c2) {

if (c1 == kRest) return 0;

return abs(c1 / 6 - c2 / 6) + abs(c1 % 6 - c2 % 6);

};

// min cost to type word[i:n]. l, r are the last finger positions.

function<int(int, int, int)> dp = [&](int i, int l, int r) {

if (i == n) return 0;

if (mem[i][l][r] >= 0) return mem[i][l][r];

int c = word[i] - 'A';

return mem[i][l][r] = min(dp(i + 1, c, r) + cost(l, c),

dp(i + 1, l, c) + cost(r, c));

};

return dp(0, kRest, kRest);

}

};

C++

// Author: Huahua, 12 ms, 10.1 MB

class Solution {

public:

int minimumDistance(string word) {

constexpr int kRest = 26;

const int n = word.length();

vector<vector<int>> mem(n, vector<int>(27));

auto cost = [](int c1, int c2) {

if (c1 == kRest) return 0;

return abs(c1 / 6 - c2 / 6) + abs(c1 % 6 - c2 % 6);

};

// min cost to type word[i:n]. o is the last position of the other finger.

// the current finger is at word[i - 1].

function<int(int, int)> dp = [&](int i, int o) {

if (i == n) return 0;

if (mem[i][o]) return mem[i][o];

int p = i == 0 ? kRest : word[i - 1] - 'A';

int c = word[i] - 'A';

return mem[i][o] = min(dp(i + 1, o) + cost(p, c), // same finger

dp(i + 1, p) + cost(o, c)); // other finger

};

return dp(0, kRest);

}

};

C++

// Author: Huahua, 8 ms, 10.1 MB

class Solution {

public:

int minimumDistance(string word) {

constexpr int kRest = 26;

const int n = word.length();

// dp[i][j] : min cost to type word[0:i]

// one finger is at word[i - 1], another finger is at j.

vector<vector<int>> dp(n + 1, vector<int>(27, INT_MAX / 2));

dp[0][kRest] = 0;

auto cost = [](int c1, int c2) {

if (c1 == kRest) return 0;

return abs(c1 / 6 - c2 / 6) + abs(c1 % 6 - c2 % 6);

};

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

int p = i == 0 ? kRest : word[i - 1] - 'A';

int c = word[i] - 'A';

for (int j = 0; j <= 26; ++j) {

dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + cost(p, c)); // same finger

dp[i + 1][p] = min(dp[i + 1][p], dp[i][j] + cost(j, c)); // other finger

}

return *min_element(begin(dp[n]), end(dp[n]));

}

};

花花酱 LeetCode 1316. Distinct Echo Substrings

By zxi on January 11, 2020

Return the number of distinct non-empty substrings of text that can be written as the concatenation of some string with itself.

Example 1:

Input: text = "abcabcabc"
Output: 3
Explanation: The 3 substrings are "abcabc", "bcabca" and "cabcab".

Example 2:

Input: text = "leetcodeleetcode"
Output: 2
Explanation: The 2 substrings are "ee" and "leetcodeleetcode".

Constraints:

1 <= text.length <= 2000
text has only lowercase English letters.

Solution 1: Brute Force + HashSet

Try all possible substrings

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

C++

// Author: Huahua

class Solution {

public:

int distinctEchoSubstrings(string text) {

const int n = text.length();

string_view t(text);

unordered_set<string_view> s;

for (int k = 1; k <= n / 2; ++k)

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

if (t.substr(i, k) == t.substr(i + k, k))

s.insert(t.substr(i, 2 * k));

return s.size();

}

};

花花酱 LeetCode 1312. Minimum Insertion Steps to Make a String Palindrome

By zxi on January 4, 2020

Given a string s. In one step you can insert any character at any index of the string.

Return the minimum number of steps to make s palindrome.

A Palindrome String is one that reads the same backward as well as forward.

Example 1:

Input: s = "zzazz"
Output: 0
Explanation: The string "zzazz" is already palindrome we don't need any insertions.

Example 2:

Input: s = "mbadm"
Output: 2
Explanation: String can be "mbdadbm" or "mdbabdm".

Example 3:

Input: s = "leetcode"
Output: 5
Explanation: Inserting 5 characters the string becomes "leetcodocteel".

Example 4:

Input: s = "g"
Output: 0

Example 5:

Input: s = "no"
Output: 1

Constraints:

1 <= s.length <= 500
All characters of s are lower case English letters.

Solution: DP

dp[i][j] := min chars to insert
dp[j][j] = dp[i-1][j+1] if s[i] == s[j] else min(dp[i+1][j] , dp[i][j-1]) + 1
base case: dp[i][i] = 0
ans: dp[0][n-1]

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

C++

// Author: Huahua

class Solution {

public:

int minInsertions(string s) {

const int n = s.length();

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

for (int l = 2; l <= n; ++l)

for (int i = 0, j = l - 1; j < n; ++i, ++j)

dp[i][j] = s[i] == s[j] ? dp[i + 1][j - 1] : min(dp[i + 1][j], dp[i][j - 1]) + 1;

return dp[0][n - 1];

}

};