Posts published in October 2018

花花酱 LeetCode 920. Number of Music Playlists

By zxi on October 6, 2018

Problem

Your music player contains N different songs and she wants to listen to L (not necessarily different) songs during your trip. You create a playlist so that:

Every song is played at least once
A song can only be played again only if K other songs have been played

Return the number of possible playlists. As the answer can be very large, return it modulo 10^9 + 7.

Example 1:

Input: N = 3, L = 3, K = 1
Output: 6
Explanation: There are 6 possible playlists. [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].

Example 2:

Input: N = 2, L = 3, K = 0
Output: 6
Explanation: There are 6 possible playlists. [1, 1, 2], [1, 2, 1], [2, 1, 1], [2, 2, 1], [2, 1, 2], [1, 2, 2]

Example 3:

Input: N = 2, L = 3, K = 1
Output: 2
Explanation: There are 2 possible playlists. [1, 2, 1], [2, 1, 2]

Note:

0 <= K < N <= L <= 100

Solution: DP

dp[i][j] := # of playlists of length i using j different songs.

dp[i][j] = dp[i – 1][j – 1] * (N – (j – 1)) + // Adding a new song. j – 1 used, choose any one from (N – (j – 1)) unused.
dp[i -1][j] * max(j – K, 0) // Reuse an existing song.

Time complexity: O(LN)

Space complexity: O(LN) -> O(N)

C++/O(LN)

// Author: Huahua

class Solution {

public:

int numMusicPlaylists(int N, int L, int K) {

constexpr long kMod = 1e9 + 7;

vector<vector<long>> dp(L + 1, vector<long>(N + 1, 0));

dp[0][0] = 1;

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

for (int j = 1; j <= min(i, N); ++j)

dp[i][j] = (dp[i - 1][j - 1] * (N - (j - 1)) +

dp[i - 1][j] * max(j - K, 0)) % kMod;

return dp[L][N];

}

};

C++/O(N)

// Author: Huahua, 0 ms

class Solution {

public:

int numMusicPlaylists(int N, int L, int K) {

constexpr long kMod = 1e9 + 7;

vector<long> dp(N + 1, 0);

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

dp[0] = i == 1;

for (int j = min(i, N); j >= 1; --j)

dp[j] = (dp[j - 1] * (N - (j - 1)) +

dp[j] * max(j - K, 0)) % kMod;

}

return dp[N];

}

};

花花酱 LeetCode 919. Complete Binary Tree Inserter

By zxi on October 6, 2018

Problem

A complete binary tree is a binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible.

Write a data structure CBTInserter that is initialized with a complete binary tree and supports the following operations:

CBTInserter(TreeNode root) initializes the data structure on a given tree with head node root;
CBTInserter.insert(int v) will insert a TreeNode into the tree with value node.val = v so that the tree remains complete, and returns the value of the parent of the inserted TreeNode;
CBTInserter.get_root() will return the head node of the tree.

Example 1:

Input: inputs = ["CBTInserter","insert","get_root"], inputs = [[[1]],[2],[]]
Output: [null,1,[1,2]]

Example 2:

Input: inputs = ["CBTInserter","insert","insert","get_root"], inputs = [[[1,2,3,4,5,6]],[7],[8],[]]
Output: [null,3,4,[1,2,3,4,5,6,7,8]]

Note:

The initial given tree is complete and contains between 1 and 1000 nodes.
CBTInserter.insert is called at most 10000 times per test case.
Every value of a given or inserted node is between 0 and 5000.

Solution 2: Deque

Using a deck to keep track of insertable nodes (potential parents) in order.

Time complexity: O(1) / O(n) first call

Space complexity: O(n)

C++

// Author: Huahua

class CBTInserter {

public:

CBTInserter(TreeNode* root): root_(root), d_({root}) {}

int insert(int v) {

while (!d_.empty()) {

TreeNode* r = d_.front();

if (r->left && r->right) {

d_.push_back(r->left);

d_.push_back(r->right);

d_.pop_front();

} else if (r->left) {

r->right = new TreeNode(v);

return r->val;

} else {

r->left = new TreeNode(v);

return r->val;

}

TreeNode* get_root() { return root_; }

private:

std::deque<TreeNode*> d_;

TreeNode* root_;

};

花花酱 LeetCode 917. Reverse Only Letters

By zxi on October 6, 2018

Problem

Given a string S, return the “reversed” string where all characters that are not a letter stay in the same place, and all letters reverse their positions.

Example 1:

Input: "ab-cd"
Output: "dc-ba"

Example 2:

Input: "a-bC-dEf-ghIj"
Output: "j-Ih-gfE-dCba"

Example 3:

Input: "Test1ng-Leet=code-Q!"
Output: "Qedo1ct-eeLg=ntse-T!"

Note:

S.length <= 100
33 <= S[i].ASCIIcode <= 122
S doesn’t contain \ or "

Solution: Two Pointers

Time complexity: O(n)

Space complexity: O(1) – in place

C++/index

// Author: Huahua

class Solution {

public:

string reverseOnlyLetters(string S) {

int i = 0;

int j = S.length() - 1;

while (i < j) {

if (isalpha(S[i]) && isalpha(S[j])) {

swap(S[i++], S[j--]);

} else {

if (!isalpha(S[i])) ++i;

if (!isalpha(S[j])) --j;

}

return S;

}

};

C++/iter

// Author: Huahua

class Solution {

public:

string reverseOnlyLetters(string S) {

auto it1 = begin(S);

auto it2 = prev(end(S));

while (it1 < it2) {

if (isalpha(*it1) && isalpha(*it2)) {

swap(*it1++, *it2--);

} else {

if (!isalpha(*it1)) ++it1;

if (!isalpha(*it2)) --it2;

}

return S;

}

};

花花酱 LeetCode 32. Longest Valid Parentheses

By zxi on October 3, 2018

Problem

Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.

Example 1:

Input: "(()"
Output: 2
Explanation: The longest valid parentheses substring is "()"

Example 2:

Input: ")()())" Output: 4 Explanation: The longest valid parentheses substring is "()()"

Solution: Stack

Use a stack to track the index of all unmatched open parentheses.

Time complexity: O(n)

Space complexity: O(n)

C++

// Author: Huahua

class Solution {

public:

int longestValidParentheses(string s) {

stack<int> q;

int start = 0;

int ans = 0;

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

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

q.push(i);

} else {

if (q.empty()) {

start = i + 1;

} else {

int index = q.top(); q.pop();

ans = max(ans, q.empty() ? i - start + 1 : i - q.top());

}

return ans;

}

};

Python3

# Author: Huahua

class Solution:

def longestValidParentheses(self, s):

q = []

start, ans = 0, 0

for i in range(len(s)):

if s[i] == '(':

q.append(i)

continue

if not q:

start = i + 1

else:

q.pop()

ans = max(ans, i - q[-1] if q else i - start + 1)

return ans

Problem

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place and use only constant extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.

1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

Solution

Find the last acceding element x, swap with the smallest number y, y is after x that and y is greater than x.

Reverse the elements after x.

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua, 8 ms

class Solution {

public:

void nextPermutation(vector<int>& nums) {

int i = nums.size() - 2;

while (i >= 0 && nums[i + 1] <= nums[i]) --i;

if (i >= 0) {

int j = nums.size() - 1;

while (j >= 0 && nums[j] <= nums[i]) --j;

swap(nums[i], nums[j]);

}

reverse(begin(nums) + i + 1, end(nums));

}

};

Python3

# Author: Huahua, 48 ms

class Solution:

def nextPermutation(self, nums):

n = len(nums)

i = n - 2

while i >= 0 and nums[i] >= nums[i + 1]: i -= 1

if i >= 0:

j = n - 1

while j >= 0 and nums[j] <= nums[i]: j -= 1

nums[i], nums[j] = nums[j], nums[i]

nums[i + 1:] = nums[i+1:][::-1]

Posts published in October 2018

花花酱 LeetCode 920. Number of Music Playlists

Problem

Solution: DP

C++/O(LN)

C++/O(N)

花花酱 LeetCode 919. Complete Binary Tree Inserter

Problem

Solution 2: Deque

C++

花花酱 LeetCode 917. Reverse Only Letters

Problem

Solution: Two Pointers

C++/index

C++/iter

花花酱 LeetCode 32. Longest Valid Parentheses

Problem

Solution: Stack

C++

Python3

Related Problems

花花酱 LeetCode 31. Next Permutation

Problem

Solution

C++

Python3