My Notes - LeetCode

8/25/2020 My Notes - LeetCode
23. Merge k Sorted Lists 


Given an array of linked-lists lists, each linked list is sorted in ascending order.
Merge all the linked-lists into one sort linked-list and return it.
Example 1:
Input: lists = [[1,4,5],[1,3,4],[2,6]]

Output: [1,1,2,3,4,4,5,6]
Explanation: The linked-lists are:
[
1->4->5,
1->3->4,
2->6
]
merging them into one sorted list:
1->1->2->3->4->4->5->6
Example 2:
Input: lists = []
Output: []
Example 3:
Input: lists = [[]]

Output: []
Constraints:
k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] is sorted in ascending order.
The sum of lists[i].length won't exceed 10^4 .
Given an array of linked-lists lists, each linked list is sorted in ascending order.
Merge all the linked-lists into one sort linked-list and return it.
https://leetcode.com/notes/ 1/31
Example 1:
Input: lists = [[1,4,5],[1,3,4],[2,6]]

Output: [1,1,2,3,4,4,5,6]
Explanation: The linked-lists are:
[
1->4->5,
1->3->4,
2->6
]
merging them into one sorted list:
1->1->2->3->4->4->5->6
struct compare {
bool operator()(const ListNode* l, const ListNode* r) {
return l->val > r->val;
}
};
ListNode *mergeKLists(vector<ListNode *> &lists) {

std::priority_queue<ListNode*, std::vector<ListNode*>, compare > heap;
ListNode head(0);
ListNode *curNode = &head;
int i, k, n = lists.size();
for (i = 0; i < n; i++)
if (lists[i]) heap.push(lists[i]);
while (!heap.empty()){
curNode->next = heap.top();
heap.pop();
curNode = curNode->next;
if (curNode->next) heap.push(curNode->next);
}
return head.next;
}
Here are some example how to use the compare-component-function
-Method 1 -
std::priority_queue<int, std::vector<int>, decltype(&compare)> pq(&compare); The compare can

be any your defined function
-Method 2-
You can use the default less function
std::priority_queue<int, std::vector<int>, std::less<int> > pq; -Method 3-
You can use the lamda-expression
auto comp = [] (int &a, int &b) -> bool { return a < b; };
std::priority_queue<int,std::vector<int>, decltype(comp) > pq (comp);
31. Next Permutation 


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 (http://en.wikipedia.org/wiki/In-place_algorithm) 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
According to Wikipedia, a man named Narayana Pandita presented the following simple algorithm to
solve this problem in the 14th century.
ALGORITHM :
* Find the largest index k such that nums[k] < nums[k + 1]. If no such index exists, jus
t reverse nums and done.
* Find the largest index l > k such that nums[k] < nums[l].
* Swap nums[k] and nums[l].
* Reverse the sub-array nums[k + 1:].
class Solution {
public:
void nextPermutation(vector<int>& nums) {
int n = nums.size(), k, l;
for (k = n - 2; k >= 0; k--) {
if (nums[k] < nums[k + 1]) {
break;
}
}
if (k < 0) {
reverse(nums.begin(), nums.end());
} else {
for (l = n - 1; l > k; l--) {
if (nums[l] > nums[k]) {
break;
}
}
swap(nums[k], nums[l]);
reverse(nums.begin() + k + 1, nums.end());
}
}
};
The above algorithm can also handle duplicates and thus can be further used to solve Permutations and
Permutations II.
76. Minimum Window Substring 


Given a string S and a string T, find the minimum window in S which will contain all the characters in T in
complexity O(n).
Example:
Input: S = "ADOBECODEBANC", T = "ABC"

Output: "BANC"
Note:
If there is no such window in S that covers all characters in T, return the empty string "" .
If there is such window, you are guaranteed that there will always be only one unique minimum
window in S.
Given a string S and a string T, find the minimum window in S which will contain all the characters in T in
complexity O(n).
Example:
Input: S = "ADOBECODEBANC", T = "ABC"

Output: "BANC"
class Solution:
def minWindow(self, s: str, t: str) -> str:
#stores t char frequency
dict_t = Counter(t)
#current state
state = Counter()
#number of characters required
req = len(dict_t)
#two pointers
i=j=0
#currently formed
formed=0
#ans that contains length and starting index
ans = float('inf'),None
while j<len(s):
char = s[j]
#if current character we can include
if(char in dict_t):
#update current state
state[char]+=1
#if frequency of current character is equal to frequency in t .. increme
nt Formed
if(state[char]==dict_t[char]):
formed+=1
#while current window is valid
while i<=j and req == formed:
char = s[i]
if(j-i+1<ans[0]):
ans = j-i+1,i
# Try to shrink window
if(char in dict_t):
state[char]-=1
# if removal of current character doesn't satisy constraint then decreme
nt formed
if(state[char]==dict_t[char]-1):
formed-=1
i+=1
j+=1
return "" if ans[0]==float('inf') else s[ans[1]:ans[1]+ans[0]]
87. Scramble String 


Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings
recursively.
Below is one possible representation of s1 = "great" :
great
/ \
gr eat
/ \ / \
g r e at
/ \
a t
To scramble the string, we may choose any non-leaf node and swap its two children.
For example, if we choose the node "gr" and swap its two children, it produces a scrambled string
"rgeat" .
rgeat
/ \
rg eat
/ \ / \
r g e at
/ \
a t
We say that "rgeat" is a scrambled string of "great" .
Similarly, if we continue to swap the children of nodes "eat" and "at" , it produces a scrambled string
"rgtae" .
rgtae
/ \
rg tae
/ \ / \
r g ta e
/ \
t a
We say that "rgtae" is a scrambled string of "great" .
Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.
Example 1:
Input: s1 = "great", s2 = "rgeat"

Output: true
Example 2:
Input: s1 = "abcde", s2 = "caebd"

Output: false
It is exponential solution acc. to big O notation but its quite fast due to pruning.
class Solution:
def isScramble(self, s1: str, s2: str) -> bool:
n,m = len(s1),len(s2)
if n!=m or sorted(s1)!=sorted(s2):
return False
if n<4 or s1==s2:
return True
f = self.isScramble
for i in range(1,n):
if((f(s1[:i],s2[:i]) and f(s1[i:],s2[i:])) or (f(s1[:i],s2[-i:]) and f(s1
[i:],s2[:-i]))):
return True
return False
94. Binary Tree Inorder Traversal 


Given a binary tree, return the inorder traversal of its nodes' values.
Example:
Input: [1,null,2,3]
1
\
2
/
3
Output: [1,3,2]
Follow up: Recursive solution is trivial, could you do it iteratively?
Here there are 3 states in a stack where 0 means preorder 1 means inorder and 2 means postorder
traversal.
if state is 0 : then update its state to 1 and push left child to stack if state is 1 : then make its state to 2 and
push right child to stack if state is 2 : just pop the element
We can modify this code to get pre and post order as well by simply changing order of appending result to
ans.
def inorderTraversal(self, root: TreeNode) -> List[int]:

if root ==None:
return []
st = [[root,0]]
ans =[]
while(len(st)>0):
curr = st[-1]
if curr[1]==0:
curr[1] =1
if curr[0].left!=None:
st.append([curr[0].left,0])
elif curr[1]==1:
ans.append(curr[0].val)
if(curr[0].right):
st.append([curr[0].right,0])
curr[1]=2
else:
st.pop()
return ans
97. Interleaving String 


Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.
Example 1:
Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"

Output: true
Example 2:
Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"

Output: false
BFS Approach: If we expand the two strings s1 and s2 into a chessboard, then this problem can be
transferred into a path seeking problem from the top-left corner to the bottom-right corner. The key is,
each cell (y, x) in the board corresponds to an interval between y-th character in s1 and x-th character in
s2. And adjacent cells are connected with like a grid. A BFS can then be efficiently performed to find the
path.
Better to illustrate with an example here:
Say s1 = "aab" and s2 = "abc". s3 = "aaabcb". Then the board looks like
o--a--o--b--o--c--o
| | | |
a a a a
| | | |
o--a--o--b--o--c--o
| | | |
a a a a
| | | |
o--a--o--b--o--c--o
| | | |
b b b b
| | | |
o--a--o--b--o--c--o
class Solution {
public:
bool isInterleave(string s1, string s2, string s3) {
// BFS version
int l1 = s1.size(), l2 = s2.size(), l3 = s3.size();
if (l1 + l2 != l3) return false;
vector<vector<bool>> visited(l1 + 1, vector<bool>(l2 + 1, false));

queue<pair<int, int>> myqueue;
myqueue.push(pair<int, int>(0, 0));
while(!myqueue.empty()) {
auto p = myqueue.front();
myqueue.pop();
if (p.first == l1 && p.second == l2) {
return true;
}
if (visited[p.first][p.second]) continue;
if (p.first < l1 && s1[p.first] == s3[p.first + p.second]) {
myqueue.push(pair<int, int>(p.first + 1, p.second));
}
if (p.second < l2 && s2[p.second] == s3[p.first + p.second]) {
myqueue.push(pair<int, int>(p.first, p.second + 1));
}
visited[p.first][p.second] = true;
}
return false;
}
};
DP Solution :
bool isInterleave(string s1, string s2, string s3) {
if(s3.length() != s1.length() + s2.length())

return false;
bool table[s1.length()+1][s2.length()+1];
for(int i=0; i<s1.length()+1; i++)

for(int j=0; j< s2.length()+1; j++){
if(i==0 && j==0)
table[i][j] = true;
else if(i == 0)
table[i][j] = ( table[i][j-1] && s2[j-1] == s3[i+j-1]);
else if(j == 0)
table[i][j] = ( table[i-1][j] && s1[i-1] == s3[i+j-1]);
else
table[i][j] = (table[i-1][j] && s1[i-1] == s3[i+j-1] ) || (table[i][j-1]
&& s2[j-1] == s3[i+j-1] );
}
return table[s1.length()][s2.length()];
}
115. Distinct Subsequences 


Given a string S and a string T, count the number of distinct subsequences of S which equals T.
A subsequence of a string is a new string which is formed from the original string by deleting some (can
be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ACE"
is a subsequence of "ABCDE" while "AEC" is not).
It's guaranteed the answer fits on a 32-bit signed integer.
Example 1:
Input: S = "rabbbit", T = "rabbit"

Output: 3
Explanation:
As shown below, there are 3 ways you can generate "rabbit" from S.
(The caret symbol ^ means the chosen letters)
rabbbit
^^^^ ^^
rabbbit
^^ ^^^^
rabbbit
^^^ ^^^
Example 2:
Input: S = "babgbag", T = "bag"

Output: 5
Explanation:
As shown below, there are 5 ways you can generate "bag" from S.
(The caret symbol ^ means the chosen letters)
babgbag
^^ ^
babgbag
^^ ^
babgbag
^ ^^
babgbag
^ ^^
babgbag
^^^
Well, a dynamic programming problem. Let's first define its state dp[i][j] to be the number of distinct
subsequences of t[0..i - 1] in s[0..j - 1]. Then we have the following state equations:
General case 1: dp[i][j] = dp[i][j - 1] if t[i - 1] != s[j - 1];
General case 2: dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1] if t[i - 1] == s[j - 1];
Boundary case 1: dp[0][j] = 1 for all j;
Boundary case 2: dp[i][0] = 0 for all positive i.
Now let's give brief explanations to the four equations above.
If t[i - 1] != s[j - 1], the distinct subsequences will not include s[j - 1] and thus all the number of distinct
subsequences will simply be those in s[0..j - 2], which corresponds to dp[i][j - 1];
If t[i - 1] == s[j - 1], the number of distinct subsequences include two parts: those with s[j - 1] and those
without; An empty string will have exactly one subsequence in any string :-) Non-empty string will have no
subsequences in an empty string. Putting these together, we will have the following simple codes (just like
translation :-)):
class Solution {
public:
int numDistinct(string s, string t) {
int m = t.length(), n = s.length();
vector<vector<int>> dp(m + 1, vector<int> (n + 1, 0));
for (int j = 0; j <= n; j++) dp[0][j] = 1;
for (int j = 1; j <= n; j++)
for (int i = 1; i <= m; i++)
dp[i][j] = dp[i][j - 1] + (t[i - 1] == s[j - 1] ? dp[i - 1][j - 1] : 0);
return dp[m][n];
}
};
Notice that we keep the whole m*n matrix simply for dp[i - 1][j - 1]. So we can simply store that
value in a single variable and further optimize the space complexity. The final code is as follows.
int numDistinct(string s, string t) {

int n = s.length(), m = t.length();
vector<int> dp(m+1, 0);
dp[0] = 1;
for (int j = 1; j <= n; j++){
for (int i = m; i >= 1; i--){
dp[i] += s[j-1] == t[i-1] ? dp[i-1] : 0;
}
}
return dp[m];
}
};
131. Palindrome Partitioning 


Given a string s, partition s such that every substring of the partition is a palindrome.
Return all possible palindrome partitioning of s.
Example:
Input: "aab"
Output:
[
["aa","b"],
["a","a","b"]
]
39. Combination Sum

https://leetcode.com/problems/combination-sum/ (https://leetcode.com/problems/combination-sum/) Given
a set of candidate numbers (candidates) (without duplicates) and a target number (target), find all unique
combinations in candidates where the candidate numbers sums to target
Input: candidates = [2,3,6,7], target = 7,

A solution set is:
[
[7],
[2,2,3]
]
def combinationSum(self, candidates, target):

def backtrack(tmp, start, end, target):
if target == 0:
ans.append(tmp[:])
elif target > 0:
for i in range(start, end):
tmp.append(candidates[i])
backtrack(tmp, i, end, target - candidates[i])
tmp.pop()
ans = []
candidates.sort(reverse= True)
backtrack([], 0, len(candidates), target)
return ans
40. Combination Sum II

https://leetcode.com/problems/combination-sum-ii/ (https://leetcode.com/problems/combination-sum-ii/)
Given a collection of candidate numbers (candidates) and a target number (target), find all unique
combinations in candidates where the candidate numbers sums to target.
Each number in candidates may only be used once in the combination.
Input: candidates = [10,1,2,7,6,1,5], target = 8,

A solution set is:
[
[1, 7],
[1, 2, 5],
[2, 6],
[1, 1, 6]
]
def combinationSum2(self, candidates, target):

def backtrack(start, end, tmp, target):
if target == 0:
ans.append(tmp[:])
elif target > 0:
if i > start and candidates[i] == candidates[i-1]:
continue
tmp.append(candidates[i])
backtrack(i+1, end, tmp, target - candidates[i])
tmp.pop()
ans = []
candidates.sort(reverse= True)
backtrack(0, len(candidates), [], target)
return ans
78. Subsets
https://leetcode.com/problems/subsets/ (https://leetcode.com/problems/subsets/)
Given a set of distinct integers, nums, return all possible subsets (the power set).
Note: The solution set must not contain duplicate subsets.
Input: nums = [1,2,3]

Output:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]
def subsets(self, nums):

def backtrack(start, end, tmp):
ans.append(tmp[:])
tmp.append(nums[i])
backtrack(i+1, end, tmp)
tmp.pop()
ans = []
backtrack(0, len(nums), [])
return ans
90. Subsets II
https://leetcode.com/problems/subsets-ii/ (https://leetcode.com/problems/subsets-ii/)
Given a collection of integers that might contain duplicates, nums, return all possible subsets (the power
set).
Note: The solution set must not contain duplicate subsets.
Example:
Input: [1,2,2]
Output:
[
[2],
[1],
[1,2,2],
[2,2],
[1,2],
[]
]
def subsetsWithDup(self, nums):

ans.append(tmp[:])
if i > start and nums[i] == nums[i-1]:
continue
tmp.append(nums[i])
tmp.pop()
ans = []
nums.sort()
backtrack(0, len(nums), [])
return ans
46. Permutations
https://leetcode.com/problems/permutations/ (https://leetcode.com/problems/permutations/)
Given a collection of distinct integers, return all possible permutations.
Example:
Input: [1,2,3]
Output:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
def permute(self, nums):

def backtrack(start, end):
if start == end:
ans.append(nums[:])
nums[start], nums[i] = nums[i], nums[start]
backtrack(start+1, end)
nums[start], nums[i] = nums[i], nums[start]
ans = []
backtrack(0, len(nums))
return ans
47. Permutations II
https://leetcode.com/problems/permutations-ii/ (https://leetcode.com/problems/permutations-ii/)
Given a collection of numbers that might contain duplicates, return all possible unique permutations.
Example:
Input: [1,1,2]
Output:
[
[1,1,2],
[1,2,1],
[2,1,1]
]
def permuteUnique(self, nums):

def backtrack(tmp, size):
if len(tmp) == size:
ans.append(tmp[:])
else:
for i in range(size):
if visited[i] or (i > 0 and nums[i-1] == nums[i] and not
visited[i-1]):
continue
visited[i] = True
tmp.append(nums[i])
backtrack(tmp, size)
tmp.pop()
visited[i] = False
ans = []
visited = [False] * len(nums)
nums.sort()
backtrack([], len(nums))
return ans
60. Permutation Sequence

https://leetcode.com/problems/permutation-sequence/ (https://leetcode.com/problems/permutation-
sequence/)
The set [1,2,3,...,n] contains a total of n! unique permutations.
By listing and labeling all of the permutations in order, we get the following sequence for n = 3:
"123"
"132"
"213"
"231"
"312"
"321" Given n and k, return the kth permutation sequence.
Input: n = 4, k = 9
Output: "2314"
def getPermutation(self, n, k):

nums = [str(i) for i in range(1, n+1)]
fact = [1] * n
for i in range(1,n):
fact[i] = i*fact[i-1]
k -= 1
ans = []
for i in range(n, 0, -1):
id = k / fact[i-1]
k %= fact[i-1]
ans.append(nums[id])
nums.pop(id)
return ''.join(ans)
131. Palindrome Partitioning

https://leetcode.com/problems/palindrome-partitioning/ (https://leetcode.com/problems/palindrome-
partitioning/)
Given a string s, partition s such that every substring of the partition is a palindrome.
Return all possible palindrome partitioning of s.
Example:
Input: "aab"
Output:
[
["aa","b"],
["a","a","b"]
]
def partition(self, s):

if start == end:
ans.append(tmp[:])
cur = s[start:i+1]
if cur == cur[::-1]:
tmp.append(cur)
tmp.pop()
ans = []
backtrack(0, len(s), [])
return ans
267. Palindrome Permutation II https://leetcode.com/problems/palindrome-permutation-ii/

(https://leetcode.com/problems/palindrome-permutation-ii/) Related to this two:
268. Next Permutation: https://leetcode.com/problems/next-permutation/

(https://leetcode.com/problems/next-permutation/)
269. Palindrome Permutation: https://leetcode.com/problems/palindrome-permutation/

(https://leetcode.com/problems/palindrome-permutation/)
def generatePalindromes(self, s):

kv = collections.Counter(s)
mid = [k for k, v in kv.iteritems() if v%2]
if len(mid) > 1:
return []
mid = '' if mid == [] else mid[0]
half = ''.join([k * (v/2) for k, v in kv.iteritems()])
half = [c for c in half]
def backtrack(end, tmp):

if len(tmp) == end:
cur = ''.join(tmp)
ans.append(cur + mid + cur[::-1])
else:
for i in range(end):
if visited[i] or (i>0 and half[i] == half[i-1] and not visited[i-
1]):
continue
visited[i] = True
tmp.append(half[i])
backtrack(end, tmp)
visited[i] = False
tmp.pop()
ans = []
visited = [False] * len(half)
backtrack(len(half), [])
return ans
139. Word Break 


Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if
s can be segmented into a space-separated sequence of one or more dictionary words.
Note:
The same word in the dictionary may be reused multiple times in the segmentation.
You may assume the dictionary does not contain duplicate words.
Example 1:
Input: s = "leetcode", wordDict = ["leet", "code"]

Output: true
Explanation: Return true because "leetcode" can be segmented as "leet code".
Example 2:
Input: s = "applepenapple", wordDict = ["apple", "pen"]

Output: true
Explanation: Return true because "applepenapple" can be segmented as "apple pen apple".
Note that you are allowed to reuse a dictionary word.
Example 3:
Input: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]

Output: false
Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s
can be segmented into a space-separated sequence of one or more dictionary words.
Input: s = "leetcode", wordDict = ["leet", "code"]

Output: true
Explanation: Return true because "leetcode" can be segmented as "leet code".
class Solution:
def wordBreak(self, A: str, B: List[str]) -> bool:
B = set(B)
n = len(A)
dp = [False]*(n+1)
dp[0] = True
for i in range(1,n+1):
for j in range(i-1,-1,-1):
if dp[j]:
if A[j:i] in B:
dp[i] = True
break
return dp[n]
We use a boolean vector dp[]. dp[i] is set to true if a valid word (word sequence) ends there. The
optimization is to look from current position i back and only substring and do dictionary look up in case the
preceding position j with dp[j] == true is found.
300. Longest Increasing Subsequence 


Given an unsorted array of integers, find the length of longest increasing subsequence.
Example:
Input: [10,9,2,5,3,7,101,18]
Output: 4
Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is
4.
Note:
There may be more than one LIS combination, it is only necessary for you to return the length.
Your algorithm should run in O(n2) complexity.
Follow up: Could you improve it to O(n log n) time complexity?
Here ans contains longest increasing subsequence.When the curr element is greater than all element
just append it to ans otherwise replace its lower bound to ans.
from bisect import bisect_left

class Solution:
def lengthOfLIS(self, nums: List[int]) -> int:
n = len(nums)
if n==0:
return 0
ans = []
for i in range(n):
if len(ans)==0:
ans.append(nums[i])
else:
ind = bisect_left(ans,nums[i])
if ind ==len(ans):
ans.append(nums[i])
else:
ans[ind] = nums[i]
return len(ans)
399. Evaluate Division 


Equations are given in the format A / B = k , where A and B are variables represented as strings, and
k is a real number (floating point number). Given some queries, return the answers. If the answer does
not exist, return -1.0 .
Example:
Given a / b = 2.0, b / c = 3.0.
queries are: a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ? .
return [6.0, 0.5, -1.0, 1.0, -1.0 ].
The input is: vector<pair<string, string>> equations, vector<double>& values,

vector<pair<string, string>> queries , where equations.size() == values.size() , and the values
are positive. This represents the equations. Return vector<double> .
According to the example above:
equations = [ ["a", "b"], ["b", "c"] ],

values = [2.0, 3.0],
queries = [ ["a", "c"], ["b", "a"], ["a", "e"], ["a", "a"], ["x", "x"] ].
The input is always valid. You may assume that evaluating the queries will result in no division by zero
and there is no contradiction.
Although this looks like a math problem, we can easily model it with graph.
For example: Given: a/b = 2.0, b/c = 3.0 We can build a directed graph: a -- 2.0 --> b -- 3.0 --> c If we
were asked to find a/c, we have: a/c = a/b * b/c = 2.0 * 3.0 In the graph, it is the product of costs of edges.
Do notice that, 2 edges need to added into the graph with one given equation, because with a/b we also
get result of b/a, which is the reciprocal of a/b.
class Solution(object):
def calcEquation(self, equations, values, queries):
graph = {}
def build_graph(equations, values):

def add_edge(f, t, value):
if f in graph:
graph[f].append((t, value))
else:
graph[f] = [(t, value)]
for vertices, value in zip(equations, values):

f, t = vertices
add_edge(f, t, value)
add_edge(t, f, 1/value)
def find_path(query):
b, e = query
if b not in graph or e not in graph:

return -1.0
q = collections.deque([(b, 1.0)])
visited = set()
while q:
front, cur_product = q.popleft()
if front == e:
return cur_product
visited.add(front)
for neighbor, value in graph[front]:
if neighbor not in visited:
q.append((neighbor, cur_product*value))
return -1.0
build_graph(equations, values)
return [find_path(q) for q in queries]
653. Two Sum IV - Input is a BST 


Given a Binary Search Tree and a target number, return true if there exist two elements in the BST such
that their sum is equal to the given target.
Example 1:
Input:
5
/ \
3 6
/ \ \
2 4 7
Target = 9
Output: True
Example 2:
Input:
5
/ \
3 6
/ \ \
2 4 7
Target = 28
Output: False
Using Binary Search Tree Iterator:

We have used two stacks one for inorder in forward direction(For traversing in increasing order) and
other for inorder in backward direction(in decreasing order). Idea is same as finding two sum in a sorted
array.
int get_next_left(stack<int>&st)
{
if(st.size()>0)
{
TreeNode* curr = st.top();
st.pop();
pushAll_left(curr->right,st);
return curr->val;
}else
{
return -1;
}
}
int get_next_right(stack<int>&st)
{
if(st.size()>0)
{
TreeNode* curr = st.top();
st.pop();
pushAll_right(curr->left,st);
return curr->val;
}else
{
return -1;
}
}
void pushAll_left(TreeNode* root,stack<int>&st)
{
while(root !=NULL)
{
st.push(root);
root = root->left;
}
}
void pushAll_right(TreeNode* root,stack<int>&st)
{
while(root !=NULL)
{
st.push(root);
root = root->right;
}
}
bool solve(TreeNode* root,int tar)
{
stack<TreeNode*>ls;
stack<TreeNode*>rs;
pushAll_left(root,ls);
pushAll_right(root,rs);
int left = get_next_left(ls);
int right = get_next_right(rs);
while(left<right)
{
if(left+right==tar)
{
return true;
}else if(left+right<tar)
{
left = get_next_left(ls);
}else
{
right = get_next_right(rs);
}
}
return false;
}
int Solution::t2Sum(TreeNode* A, int B) {
return solve(A,B);
}
714. Best Time to Buy and Sell Stock with

Transaction Fee 

Your are given an array of integers prices , for which the i -th element is the price of a given stock on
day i ; and a non-negative integer fee representing a transaction fee.
You may complete as many transactions as you like, but you need to pay the transaction fee for each
transaction. You may not buy more than 1 share of a stock at a time (ie. you must sell the stock share
before you buy again.)
Return the maximum profit you can make.
Example 1:
Input: prices = [1, 3, 2, 8, 4, 9], fee = 2

Output: 8
Explanation: The maximum profit can be achieved by:
Buying at prices[0] = 1
Selling at prices[3] = 8
Buying at prices[4] = 4
Selling at prices[5] = 9
The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
Note:
0 < prices.length <= 50000 .

0 < prices[i] < 50000 .
0 <= fee < 50000 .
Buy and sell stock Variations

definition of T[i][k] should really be split into two: T[i][k][0] and T[i][k][1], where the former
denotes the maximum profit at the end of the i-th day with at most k transactions and with 0 stock in our
hand AFTER taking the action, while the latter denotes the maximum profit at the end of the i-th day with
at most k transactions and with 1 stock in our hand AFTER taking the action. Now the base cases and the
recurrence relations can be written as: Base cases:
T[-1][k][0] = 0, T[-1][k][1] = -Infinity

T[i][0][0] = 0, T[i][0][1] = -Infinity
Recurrence relations:
T[i][k][0] = max(T[i-1][k][0], T[i-1][k][1] + prices[i])

T[i][k][1] = max(T[i-1][k][1], T[i-1][k-1][0] - prices[i])
For One transaction

public int maxProfit(int[] prices) {
int T_i10 = 0, T_i11 = Integer.MIN_VALUE;
for (int price : prices) {

T_i10 = Math.max(T_i10, T_i11 + price);
T_i11 = Math.max(T_i11, -price);
}
return T_i10;
}
For 2 Transactions :

T_i21 = Math.max(T_i21, T_i10 - price);
T_i11 = Math.max(T_i11, -price);
}
return T_i20;
}
For Infinite Transactions

int T_ik0 = 0, T_ik1 = Integer.MIN_VALUE;

int T_ik0_old = T_ik0;
T_ik0 = Math.max(T_ik0, T_ik1 + price);
T_ik1 = Math.max(T_ik1, T_ik0_old - price);
}
return T_ik0;
}
If number of transactions are arbitrary

public int maxProfit(int k, int[] prices) {
if (k >= prices.length >>> 1) {

}
return T_ik0;
}
int[] T_ik0 = new int[k + 1];

int[] T_ik1 = new int[k + 1];
Arrays.fill(T_ik1, Integer.MIN_VALUE);

for (int j = k; j > 0; j--) {
T_ik0[j] = Math.max(T_ik0[j], T_ik1[j] + price);
T_ik1[j] = Math.max(T_ik1[j], T_ik0[j - 1] - price);
}
}
return T_ik0[k];
}
With cooldown
int T_ik0_pre = 0, T_ik0 = 0, T_ik1 = Integer.MIN_VALUE;

T_ik1 = Math.max(T_ik1, T_ik0_pre - price);
T_ik0_pre = T_ik0_old;
}
return T_ik0;
}
With Transactions Fee

*Solution I *-- pay the fee when buying the stock:
public int maxProfit(int[] prices, int fee) {


T_ik1 = Math.max(T_ik1, T_ik0_old - price - fee);
}
return T_ik0;
}
*Solution II *-- pay the fee when selling the stock:
public int maxProfit(int[] prices, int fee) {

long T_ik0 = 0, T_ik1 = Integer.MIN_VALUE;

long T_ik0_old = T_ik0;
T_ik0 = Math.max(T_ik0, T_ik1 + price - fee);
}
return (int)T_ik0;
}
```ff
904. Fruit Into Baskets 


In a row of trees, the i -th tree produces fruit with type tree[i] .
You start at any tree of your choice, then repeatedly perform the following steps:
1. Add one piece of fruit from this tree to your baskets. If you cannot, stop.
2. Move to the next tree to the right of the current tree. If there is no tree to the right, stop.
Note that you do not have any choice after the initial choice of starting tree: you must perform step 1, then
step 2, then back to step 1, then step 2, and so on until you stop.
You have two baskets, and each basket can carry any quantity of fruit, but you want each basket to only
carry one type of fruit each.
What is the total amount of fruit you can collect with this procedure?
Example 1:
Input: [1,2,1]
Output: 3
Explanation: We can collect [1,2,1].
Example 2:
Input: [0,1,2,2]
Output: 3
Explanation: We can collect [1,2,2].
If we started at the first tree, we would only collect [0, 1].
Example 3:
Input: [1,2,3,2,2]
Output: 4
Explanation: We can collect [2,3,2,2].
If we started at the first tree, we would only collect [1, 2].
Example 4:
Input: [3,3,3,1,2,1,1,2,3,3,4]
Output: 5
Explanation: We can collect [1,2,1,1,2].
If we started at the first tree or the eighth tree, we would only collect 4 fruits.
Note:
1. 1 <= tree.length <= 40000

2. 0 <= tree[i] < tree.length
By using flexible sliding window :
class Solution:
def totalFruit(self, tree: List[int]) -> int:
d = {}
i,j =0,0
ans =0
while j<len(tree):
if tree[j] in d:
d[tree[j]]+=1
else:
d[tree[j]] =1
while(len(d)>2):
d[tree[i]]-=1
if d[tree[i]]==0:
del d[tree[i]]
i+=1
ans = max(ans,j-i+1)
j+=1
return ans
930. Binary Subarrays With Sum 


In an array A of 0 s and 1 s, how many non-empty subarrays have sum S ?
Example 1:
Input: A = [1,0,1,0,1], S = 2
Output: 4
Explanation:
The 4 subarrays are bolded below:
[1,0,1,0,1]
[1,0,1,0,1]
[1,0,1,0,1]
[1,0,1,0,1]
Note:
1. A.length <= 30000

2. 0 <= S <= A.length
3. A[i] is either 0 or 1 .
class Solution {
public int numSubarraysWithSum(int[] A, int S) {
// calculate all subarrays less and equal to sum S minus all subarrays less and
equal to sum S - 1
return numSubarraysLessAndEqualToSum(A, S) - numSubarraysLessAndEqualToSum(A, S
- 1);
}
private int numSubarraysLessAndEqualToSum(int[] A, int S) {

int lo = 0;
int hi = 0;
int sum = 0;
int num = 0; // to calculate all legit subarrays end with hi
while (hi < A.length) {
sum += A[hi];
while (lo <= hi && sum > S) {
/* currently subarray end with hi is not valid, we need to forward lo*/
sum -= A[lo++];
}
num += hi - lo + 1;
hi++;
}
return num;
}
}
1248. Count Number of Nice Subarrays 


Given an array of integers nums and an integer k . A subarray is called nice if there are k odd numbers
on it.
Return the number of nice sub-arrays.
Example 1:
Input: nums = [1,1,2,1,1], k = 3

Output: 2
Explanation: The only sub-arrays with 3 odd numbers are [1,1,2,1] and [1,2,1,1].
Example 2:
Input: nums = [2,4,6], k = 1

Output: 0
Explanation: There is no odd numbers in the array.
Example 3:
Input: nums = [2,2,2,1,2,2,1,2,2,2], k = 2

Output: 16
Constraints:
1 <= nums.length <= 50000

1 <= nums[i] <= 10^5
1 <= k <= nums.length
Given an array of integers nums and an integer k. A subarray is called nice if there are k odd numbers on
it.
Return the number of nice sub-arrays.
Example 1:
Input: nums = [1,1,2,1,1], k = 3

Output: 2
Explanation: The only sub-arrays with 3 odd numbers are [1,1,2,1] and [1,2,1,1].
exactly K times = at most K times - at most K - 1 times
def numberOfSubarrays(self, A, k):

def atMost(k):
res = i = 0
for j in xrange(len(A)):
k -= A[j] % 2
while k < 0:
k += A[i] % 2
i += 1
res += j - i + 1
return res
return atMost(k) - atMost(k - 1)
Solution II: One pass

Actually it's same as three pointers. Though we use count to count the number of even numebers.
def numberOfSubarrays(self, A, k):

i = count = res = 0
for j in xrange(len(A)):
if A[j] & 1:
k -= 1
count = 0
while k == 0:
k += A[i] & 1
i += 1
count += 1
res += count
return res

My Notes - LeetCode

Uploaded by

Copyright:

Available Formats

You might also like

My Notes - LeetCode

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

My Notes - LeetCode

Uploaded by

Copyright:

Available Formats

8/25/2020 My Notes - LeetCode

23. Merge k Sorted Lists 

Input: lists = [[1,4,5],[1,3,4],[2,6]]

Input: lists = [[]]

Input: lists = [[1,4,5],[1,3,4],[2,6]]

ListNode *mergeKLists(vector<ListNode *> &lists) {

Here are some example how to use the compare-component-function

std::priority_queue<int, std::vector<int>, decltype(&compare)> pq(&compare); The compare can

You can use the default less function

std::priority_queue<int, std::vector<int>, std::less<int> > pq; -Method 3-

You can use the lamda-expression

31. Next Permutation 

The replacement must be in-place (http://en.wikipedia.org/wiki/In-place_algorithm) and use only

76. Minimum Window Substring 

Input: S = "ADOBECODEBANC", T = "ABC"

Input: S = "ADOBECODEBANC", T = "ABC"

87. Scramble String 

Below is one possible representation of s1 = "great" :

We say that "rgeat" is a scrambled string of "great" .

We say that "rgtae" is a scrambled string of "great" .

Input: s1 = "great", s2 = "rgeat"

Input: s1 = "abcde", s2 = "caebd"

94. Binary Tree Inorder Traversal 

Follow up: Recursive solution is trivial, could you do it iteratively?

def inorderTraversal(self, root: TreeNode) -> List[int]:

97. Interleaving String 

Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"

Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"

Better to illustrate with an example here:

vector<vector<bool>> visited(l1 + 1, vector<bool>(l2 + 1, false));

bool isInterleave(string s1, string s2, string s3) {

if(s3.length() != s1.length() + s2.length())

for(int i=0; i<s1.length()+1; i++)

115. Distinct Subsequences 

It's guaranteed the answer fits on a 32-bit signed integer.

Input: S = "rabbbit", T = "rabbit"

Input: S = "babgbag", T = "bag"

General case 1: dp[i][j] = dp[i][j - 1] if t[i - 1] != s[j - 1];

General case 2: dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1] if t[i - 1] == s[j - 1];

Boundary case 1: dp[0][j] = 1 for all j;

Boundary case 2: dp[i][0] = 0 for all positive i.

Now let's give brief explanations to the four equations above.

int numDistinct(string s, string t) {

131. Palindrome Partitioning 

Return all possible palindrome partitioning of s.

39. Combination Sum

Input: candidates = [2,3,6,7], target = 7,

def combinationSum(self, candidates, target):

40. Combination Sum II

Each number in candidates may only be used once in the combination.

Input: candidates = [10,1,2,7,6,1,5], target = 8,

def combinationSum2(self, candidates, target):

Note: The solution set must not contain duplicate subsets.

Input: nums = [1,2,3]

def subsets(self, nums):

Note: The solution set must not contain duplicate subsets.

def subsetsWithDup(self, nums):

Given a collection of distinct integers, return all possible permutations.

ListNode mergeKLists(vector<ListNode > &lists) {

Solution II -- pay the fee when selling the stock: