Posts tagged as “greedy”

花花酱 LeetCode 1353. Maximum Number of Events That Can Be Attended

By zxi on February 16, 2020

Given an array of events where events[i] = [startDay_i, endDay_i]. Every event i starts at startDay_iand ends at endDay_i.

You can attend an event i at any day d where startTime_i <= d <= endTime_i. Notice that you can only attend one event at any time d.

Return the maximum number of events you can attend.

Example 1:

Input: events = [[1,2],[2,3],[3,4]]
Output: 3
Explanation: You can attend all the three events.
One way to attend them all is as shown.
Attend the first event on day 1.
Attend the second event on day 2.
Attend the third event on day 3.

Example 2:

Input: events= [[1,2],[2,3],[3,4],[1,2]]
Output: 4

Example 3:

Input: events = [[1,4],[4,4],[2,2],[3,4],[1,1]]
Output: 4

Example 4:

Input: events = [[1,100000]]
Output: 1

Example 5:

Input: events = [[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7]]
Output: 7

Constraints:

1 <= events.length <= 10^5
events[i].length == 2
1 <= events[i][0] <= events[i][1] <= 10^5

Solution: Greedy

Sort events by end time, for each event find the first available day to attend.

Time complexity: O(sum(endtime – starttime)) = O(10^10)
Space complexity: O(max(endtime – starttime) = O(10^5)

C++

// Author: Huahua, 216 ms, 45.7 MB

class Solution {

public:

int maxEvents(vector<vector<int>>& events) {

sort(begin(events), end(events), [](const auto& a, const auto& b){

return a[1] < b[1];

});

int ans = 0;

int seen[100001] = {0};

for (const auto& e : events) {

for (int i = e[0]; i <= e[1]; ++i) {

if (seen[i]) continue;

++seen[i];

++ans;

break;

}

return ans;

}

};

C++

// Author: Huahua, 216 ms, 45.6 MB

class Solution {

public:

int maxEvents(vector<vector<int>>& events) {

sort(begin(events), end(events), [](const auto& a, const auto& b){

return a[1] < b[1];

});

int ans = 0;

unsigned char seen[100000 / 8 + 1] = {0};

for (const auto& e : events) {

for (int i = e[0]; i <= e[1]; ++i) {

if (seen[i >> 3] & (1 << (i % 8))) continue;

seen[i >> 3] |= 1 << (i % 8);

++ans;

break;

}

return ans;

}

};

Python

// Author: Huahua, 824 ms

class Solution:

def maxEvents(self, events: List[List[int]]) -> int:

lo = min(e[0] for e in events)

hi = max(e[1] for e in events)

seen = [0] * (hi - lo + 1)

for s, t in sorted(events, key=lambda e:e[1]):

for i in range(s, t + 1):

if seen[i - lo]: continue

seen[i - lo] = 1

break

return sum(seen)

We can use a TreeSet to maintain the open days and do a binary search to find the first available day.

Time complexity: O(nlogd)
Space complexity: O(d)

C++

// Author: Huahua, 416 ms, 46.1MB

class Solution {

public:

int maxEvents(vector<vector<int>>& events) {

sort(begin(events), end(events), [](const auto& a, const auto& b){

return a[1] < b[1];

});

int min_d = INT_MAX;

int max_d = INT_MIN;

for (const auto& e : events) {

min_d = min(min_d, e[0]);

max_d = max(max_d, e[1]);

}

vector<int> days(max_d - min_d + 1);

iota(begin(days), end(days), min_d);

set<int> s(begin(days), end(days)); // O(n)

int ans = 0;

for (const auto& e : events) {

auto it = s.lower_bound(e[0]);

if (it == end(s) || *it > e[1]) continue;

s.erase(it);

++ans;

}

return ans;

}

};

花花酱 LeetCode 1330. Reverse Subarray To Maximize Array Value

By zxi on January 26, 2020

You are given an integer array nums. The value of this array is defined as the sum of |nums[i]-nums[i+1]| for all 0 <= i < nums.length-1.

You are allowed to select any subarray of the given array and reverse it. You can perform this operation only once.

Find maximum possible value of the final array.

Example 1:

Input: nums = [2,3,1,5,4]
Output: 10
Explanation: By reversing the subarray [3,1,5] the array becomes [2,5,1,3,4] whose value is 10.

Example 2:

Input: nums = [2,4,9,24,2,1,10]
Output: 68

Constraints:

1 <= nums.length <= 3*10^4
-10^5 <= nums[i] <= 10^5

Solution: Greedy

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

C++

// Author: Huahua

class Solution {

public:

int maxValueAfterReverse(vector<int>& nums) {

const int n = nums.size();

int sum = 0;

int gain = 0;

int hi = INT_MIN;

int lo = INT_MAX;

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

int n1 = nums[i];

int n2 = nums[i + 1];

sum += abs(n1 - n2);

gain = max({gain,

abs(nums[0] - n2) - abs(n1 - n2),

abs(nums[n - 1] - n1) - abs(n1 - n2)});

hi = max(hi, min(n1, n2));

lo = min(lo, max(n1, n2));

}

return sum + max(gain, (hi - lo) * 2);

}

};

花花酱 LeetCode 1328. Break a Palindrome

By zxi on January 26, 2020

Given a palindromic string palindrome, replace exactly one character by any lowercase English letter so that the string becomes the lexicographically smallest possible string that isn’t a palindrome.

After doing so, return the final string. If there is no way to do so, return the empty string.

Example 1:

Input: palindrome = "abccba"
Output: "aaccba"

Example 2:

Input: palindrome = "a"
Output: ""

Constraints:

1 <= palindrome.length <= 1000
palindrome consists of only lowercase English letters.

Solution: Greedy

For the first half of the string, replace the first non ‘a’ character to ‘a’.

e.g. abcdcba => aacdcba

If not found which means the the entire string is ‘a’ expect the middle one if the length is odd, like aa or aba, replace the last character to ‘b’.

aa => ab
aba => abb

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

C++

// Author: Huahua

class Solution {

public:

string breakPalindrome(string palindrome) {

const int n = palindrome.length();

if (n == 1) return "";

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

if (palindrome[i] != 'a') {

palindrome[i] = 'a';

return palindrome;

}

palindrome.back() = 'b';

return palindrome;

}

};

花花酱 LeetCode 1323. Maximum 69 Number

By zxi on January 20, 2020

Given a positive integer num consisting only of digits 6 and 9.

Return the maximum number you can get by changing at most one digit (6 becomes 9, and 9 becomes 6).

Example 1:

Input: num = 9669
Output: 9969
Explanation: 
Changing the first digit results in 6669.
Changing the second digit results in 9969.
Changing the third digit results in 9699.
Changing the fourth digit results in 9666. 
The maximum number is 9969.

Example 2:

Input: num = 9996
Output: 9999
Explanation: Changing the last digit 6 to 9 results in the maximum number.

Example 3:

Input: num = 9999
Output: 9999
Explanation: It is better not to apply any change.

Constraints:

1 <= num <= 10^4
num‘s digits are 6 or 9.

Solution: Greedy

Replace the highest 6 to 9, if no 6, return the original number.

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

C++

// Author: Huahua

class Solution {

public:

int maximum69Number (int num) {

string s = to_string(num);

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

if (s[i] == '6') {

s[i] = '9';

return stoi(s);

}

return num;

}

};

花花酱 LeetCode 1326. Minimum Number of Taps to Open to Water a Garden

By zxi on January 19, 2020

There is a one-dimensional garden on the x-axis. The garden starts at the point 0 and ends at the point n. (i.e The length of the garden is n).

There are n + 1 taps located at points [0, 1, ..., n] in the garden.

Given an integer n and an integer array ranges of length n + 1 where ranges[i] (0-indexed) means the i-th tap can water the area [i - ranges[i], i + ranges[i]] if it was open.

Return the minimum number of taps that should be open to water the whole garden, If the garden cannot be watered return -1.

Example 1:

Input: n = 5, ranges = [3,4,1,1,0,0]
Output: 1
Explanation: The tap at point 0 can cover the interval [-3,3]
The tap at point 1 can cover the interval [-3,5]
The tap at point 2 can cover the interval [1,3]
The tap at point 3 can cover the interval [2,4]
The tap at point 4 can cover the interval [4,4]
The tap at point 5 can cover the interval [5,5]
Opening Only the second tap will water the whole garden [0,5]

Example 2:

Input: n = 3, ranges = [0,0,0,0]
Output: -1
Explanation: Even if you activate all the four taps you cannot water the whole garden.

Example 3:

Input: n = 7, ranges = [1,2,1,0,2,1,0,1]
Output: 3

Example 4:

Input: n = 8, ranges = [4,0,0,0,0,0,0,0,4]
Output: 2

Example 5:

Input: n = 8, ranges = [4,0,0,0,4,0,0,0,4]
Output: 1

Constraints:

1 <= n <= 10^4
ranges.length == n + 1
0 <= ranges[i] <= 100

Solution 1: Greedy

Reduce to 1024. Video Stitching

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

C++

// Author: Huahua

class Solution {

public:

int minTaps(int n, vector<int>& ranges) {

vector<pair<int, int>> t;

// O(n) reduction

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

t.emplace_back(max(0, i - ranges[i]),

min(i + ranges[i], n));

// 1024. Video Stiching

sort(begin(t), end(t));

int ans = 0;

int i = 0;

int l = 0;

int e = 0;

while (e < n) {

// Extend to the right most w.r.t t[i].first <= l

while (i <= n && t[i].first <= l)

e = max(e, t[i++].second);

if (l == e) return -1; // Can not extend

l = e;

++ans;

}

return ans;

}

};

Solution 2: Greedy

Reduce to 45. Jump Game II

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

C++

// Author: Huahua

class Solution {

public:

int minTaps(int n, vector<int>& ranges) {

vector<int> nums(ranges.size());

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

int s = max(0, i - ranges[i]);

nums[s] = max(nums[s], i + ranges[i]);

}

// 45. Jump Game II

int steps = 0;

int l = 0;

int e = 0;

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

if (i > e) return -1;

if (i > l) { ++steps; l = e; }

e = max(e, nums[i]);

}

return steps;

}

};