Leetcode-Explained on Rahat Zaman

Leetcode Problem - Alien Dictionary

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/alien-dictionary/
Difficulty: Hard
Category: Graph

Step 1: Grasping the Problem

This is a popular hard problem where you are provided a group of letters (like dictionaries) and you have to determine the order of the characters the dictionary’s words are sorted by.

In one sentence, we need to sort characters given a group of words. So first we need to detect which characters will come first. Of course the first letter in the first word will come first in lexicographic order. But after that, we will need to keep a relationship between character of who comes before who depending on the order of the words.

So, keeping a relationship between objects tells us that this problem could be solved by graph. And we need to make an order of characters where each character comes first when no other character is above that one in the words list. In other words, a character will be picked only when there are no other characters which depend on it. This is the perfect problem to be solved by topological sorting.

Step 2: Build the graph

To solve the problem with topological sorting, we need a graph first. In this graph, the nodes will be characters and the edges will be the relationship stating “this character must come before the other character”.

While building the graph, we will use a built-in datatype called defaultdict. In python, defaultdict is a dictionary where each non-existent key access will return a default value without raising an exception.

We will use a commonly used built-in generator function named zip. What zip does is it zips two container data structures so that one can easily loop through both of that at the same time. Without zip we would have to do something like this:

1
2
3


for word_ind in range(len(words)-1):
 word1 = words[word_ind]
 word2 = words[word_ind + 1]

But with the help of zip, we can just loop over these without taking extra index variable word_ind:

1

for word1, word2 in zip(words, words[1:]):

So first we create a graph of defaultdict type, loop through the array or words, then loop through the characters of that word, and create an edge for each consecutive words.

1
2
3
4
5
6
7
8


# Build graph
graph = defaultdict(set)
for word1, word2 in zip(words, words[1:]):
 for char1, char2 in zip(word1, word2):
 if char1 != char2:
 if char2 not in graph[char1]:
 graph[char1].add(char2)
 break

While building the graph, an optimization can be done for a corner case. What if multiple words are prefixes of one another. Then there will be no way of sorting them in lexicographic order. We can check then only if the char1 != char2 is always False. And then, the for loop will never hit the break statement. We could use a flag to check if the break is hit or not.

Or, we can use another cool python feature of python named for/else. Yes, else block can be used after a for block in python and it does exactly what is written above. After checking this with else, we can return null string if we cannot sort the characters. So the code will be:

1
2
3
4


# Check that second word isn't a prefix of first word.
else:
 if len(word2) < len(word1):
 return ""

Step 3: Build an `in_degree` dict for topological sorting

According to wikipedia:

For a vertex, the number of head ends adjacent to a vertex is called the indegree of the vertex

Now we need to get to know the in_degree of each node in the graph. Because topological sorting starts (and uses) with the nodes which has in-degrees’ of zero.

First we initialize in_degree with all the characters of words with 0 (this should be done before building the graph so that we can use it while creating the graph)

1
2
3
4
5


# initialize in degree of graph
in_degree = {}
for word in words:
 for char in word:
 in_degree[char] = 0

Finally, we increment a character’s in_degree when we create an edge while building the graph.

1
2
3


if char2 not in graph[char1]:
 graph[char1].add(char2)
 in_degree[char2] += 1 # new line for in_degree

The codes might be looking out of order to you and difficult to understand, so please see the full program given at the end to make sure you understand the order of code snippets used above.

Step 4: Topological Sorting

Topological Sorting is like BFS (Breadth First Search) or DFS (Depth First Search) where instead of starting from a source node, we start from all the nodes that have in_degree[node] == 0. For bfs, we need to use a queue data structure. Python has built-in deque which can be used as a queue with same time and space complexity. Then we push all the nodes that has in_degree[node] == 0 to the queue.

1
2
3
4
5


# Identify vertices that has in_degree = 0
queue = deque()
for char in in_degree:
 if in_degree[char] == 0:
 queue.append(char)

After that, we keep getting nodes from the queue and update all it’s neighboring nodes in_degree. At the same time when popping nodes from the queue, we will append that with out resulting string aliendict.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# Do the topological sort
aliendict = ""
while queue:
 node = queue.popleft()
 aliendict += node
 # Loop through neighbors set
 for char in graph[node]:
 in_degree[char] -= 1
 if in_degree[char] == 0:
 queue.append(char)

Finally we will need to check if all the characters are inside the aliendict. If they are not inside the aliendict, then we are sure that at some stage, there was a cycle in topological sorting. So there is no single way of sorting the characters given the words. At that time, we will return a null string.

1
2
3
4


if len(aliendict) < len(in_degree):
 return ""

return aliendict

This is the final solution of the program. Topological sorting takes O(|V| + |E|) time and O(|V|) space complexity where V is the list of vertices (characters for word in words in this problem), and E is the list of edges in the graph (|words| * (characters in each word) in this problem). The complete solution is given below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


from collections import defaultdict, deque

class Solution:
 def alienOrder(self, words: [str]) -> str:
 # initialize in degree of graph
 in_degree = {}
 for word in words:
 for char in word:
 in_degree[char] = 0

 # Build graph
 graph = defaultdict(set)
 for word1, word2 in zip(words, words[1:]):
 for char1, char2 in zip(word1, word2):
 if char1 != char2:
 if char2 not in graph[char1]:
 graph[char1].add(char2)
 in_degree[char2] += 1
 break
 # Check that second word isn't a prefix of first word.
 else:
 if len(word2) < len(word1):
 return ""

 # Identify vertices that has in_degree = 0
 queue = deque()
 for char in in_degree:
 if in_degree[char] == 0:
 queue.append(char)

 # Do the topological sort
 aliendict = ""
 while queue:
 node = queue.popleft()
 aliendict += node
 # Loop through neighbors set
 for char in graph[node]:
 in_degree[char] -= 1
 if in_degree[char] == 0:
 queue.append(char)

 if len(aliendict) < len(in_degree):
 return ""

 return aliendict

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59


class Solution {
public:
 string alienOrder(vector<string> &words) {
 // initialize in degree of graph
 unordered_map<char, int> inDegree;
 for(auto word: words)
 for(auto character: word)
 inDegree[character] = 0;

 // Build graph
 unordered_map<char, vector<char>> graph;
 for(int word_ind = 0; word_ind < words.size() - 1; word_ind++) {
 string word1 = words[word_ind];
 string word2 = words[word_ind + 1];

 bool loopBroken = false;
 for(int char_ind = 0; char_ind < min(word1.length(), word2.length()); char_ind++) {
 char char1 = word1[char_ind];
 char char2 = word2[char_ind];
 if(char1 != char2) {
 if(graph.find(char1) == graph.end()) {
 graph[char1].push_back(char2);
 inDegree[char2]++;
 }
 loopBroken = true;
 break;
 }
 }
 // Check that second word isn't a prefix of first word
 if(!loopBroken && word2.length() < word1.length())
 return "";
 }

 // Identify vertices that has inDegree = 0
 queue<char> q;
 for(auto charDegreePair: inDegree)
 if(charDegreePair.second == 0)
 q.push(charDegreePair.first);

 // Do the topological sort
 string alienDict;
 while(!q.empty()) {
 auto node = q.front();
 q.pop();
 alienDict.push_back(node);
 // Loop through neighbors set
 for(auto character: graph[node]) {
 inDegree[character]--;
 if(inDegree[character] == 0)
 q.push(character);
 }
 }

 if(alienDict.length() < inDegree.size())
 return "";

 return alienDict;
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


class Solution {
 public String alienOrder(String[] words) {
 // initialize in degree of graph
 Map<Character, Integer> inDegree = new HashMap<Character, Integer>();
 for(String word : words)
 for(Character character : word.toCharArray())
 inDegree.put(character, 0);

 // Build graph
 Map<Character, List<Character>> graph = new HashMap<Character, List<Character>>();
 for(int word_ind = 0; word_ind < words.length - 1; word_ind++) {
 String word1 = words[word_ind];
 String word2 = words[word_ind + 1];

 boolean loopBroken = false;
 for(int char_ind = 0; char_ind < Math.min(word1.length(), word2.length()); char_ind++) {
 Character char1 = word1.charAt(char_ind);
 Character char2 = word2.charAt(char_ind);
 if(char1 != char2) {
 if(!graph.getOrDefault(char1, new ArrayList<Character>()).contains(char2)) {
 List<Character> prevList = graph.getOrDefault(char1, new ArrayList<Character>());
 prevList.add(char2);
 graph.put(char1, prevList);
 inDegree.put(char2, inDegree.get(char2)+1);
 }
 loopBroken = true;
 break;
 }
 }
 // Check that second word isn't a prefix of first word
 if(!loopBroken)
 if(word2.length() < word1.length())
 return "";
 }


 // Identify vertices that has inDegree = 0
 Queue<Character> queue = new LinkedList<>();
 inDegree.forEach((character, charInDegree) -> {
 if(charInDegree == 0)
 queue.add(character);
 });

 // Do the topological sort
 StringBuilder alienDict = new StringBuilder();
 while(!queue.isEmpty()) {
 Character node = queue.remove();
 alienDict.append(node);
 // Loop through neighbors set
 for(Character character :graph.getOrDefault(node, new ArrayList<>())) {
 inDegree.put(character, inDegree.get(character)-1);
 if(inDegree.get(character) == 0)
 queue.add(character);
 }
 }

 if(alienDict.length() < inDegree.size())
 return "";

 return alienDict.toString();
 }
}

]]>

Leetcode Problem - All Nodes Distance K in Binary Tree

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/all-nodes-distance-k-in-binary-tree/
Difficulty: Medium
Category: Trees

Step 1: Grasping the Problem

This is purely a graph problem. We are given a binary tree (via a root node), a target node, and an integer K. We need to return a list of nodes at K distance from the target node. For the below example, the target node (marked yellow) is 5 and the answer will be [7, 4, 1] (marked blue), because K = 2.

Below are the cases to handle for solving problem:

The targets children at distance K.
The targets parent node being at distance K.
Other nodes being l+m distant from target: where l is the distance from target to a parent node par, and m is the distance from par to the node. (See the picture above)

If K is even, then you can say that target node is at distance K from itself. We are just assuming that we will always exclude the target node.

Step 2: Build a graph

It can be seen that, there is no escape from traversing from the target node to it’s parent for solving this problem. But it cannot be done in a tree data structure.

So the first step is to convert this tree to a bidirectional unweighted graph. We can traverse the tree and every time we go to a child node, we will assign the parent to the child. This can be done both recursively or iteratively.

Unlike other statically typed programming languages, python has the ability to create class attributes outside of class. We will use this ability for convenience.

1
2
3
4
5
6
7
8


# Time Complexity: O(n)
def dfs(node, parent=None):
 if node: # Check if the node is not None
 node.parent = parent # Create a parent attribute
 dfs(node.left, node)
 dfs(node.right, node)

dfs(root) # Now all nodes in the graph has parent attribute

Step 3: BFS

Now that we have the graph, we can easily apply a BFS (Breadth First Search) from the target to all nodes in the graph, check for the distance and if it is K, log it in a list. Finally, return the list. Again, we can keep the distance saved within the node itself.

If we find a node at distance K, BFS property tells that we have all the nodes at distance K already in the queue. So we can stop BFS and return the queue

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


# Time Complexity: O(n*n)
target.dist = 0 # distance from itself is zero
queue = [target] # BFS queue
seen = {target} # A set to check if visited

while queue: # run until queue is empty
 if queue[0].dist == K: # Found one of our answer nodes
 # Return the queue
 ans = []
 for node in queue:
 ans.append(node.val)
 return ans

 node = queue.pop(0) # Takes O(len(queue))

 # Go through the neighbors of current node
 for neighbor in (node.left, node.right, node.parent):
 if neighbor and neighbor not in seen:
 neighbor.dist = node.dist + 1
 seen.add(neighbor)
 queue.append(neighbor)

Step 4: Handle corner cases

In this problem, there can be 2 corner cases.

There will be no node at that distance (the graph is very small compared to K).
The graph is empty.

In both cases, we will need to return an empty array.

1

return []

Step 4: Optimize

The complete algorithm currently runs in O(n + n*n) = O(n*n) complexity. Notice that, we are using a list to do a queue’s job in BFS. Python has a built in queue and deque module which have constant access time for all operations. We can use deque for this purpose. Also in some places, we can use list comprehensions which will not effect on complexity, but may have some interpreter optimizations.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


target.dist = 0
queue = collections.deque([target])
seen = {target}
while queue:
 if queue[0].dist == K:
 return [node.val for node in queue]
 node = queue.popleft()
 for neighbor in (node.left, node.right, node.parent):
 if neighbor and neighbor not in seen:
 neighbor.dist = node.dist + 1
 seen.add(neighbor)
 queue.append(neighbor)
return []

Finally, the time complexity will be O(n) and space complexity is also O(n) where n is the number of nodes in the tree. This is the best because all the n nodes must be visited once to solve the problem.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


import collections

# Definition for a binary tree node.
class TreeNode:
 def __init__(self, x):
 self.val = x
 self.left = None
 self.right = None

class Solution(object):
 def distanceK(self, root: TreeNode, target: TreeNode, K: int) -> [int]:
 def dfs(node, parent=None):
 if node: # Check if the node is not None
 node.parent = parent # Create a parent attribute
 dfs(node.left, node)
 dfs(node.right, node)
 dfs(root) # Now all nodes in the graph has parent attribute

 target.dist = 0 # distance from itself is zero
 queue = collections.deque([target]) # BFS queue
 seen = {target} # A set to check if visited
 while queue: # run until queue is empty
 if queue[0].dist == K: # Found one of our answer nodes
 return [node.val for node in queue]
 node = queue.popleft()

 # Go through the neighbors of current node
 for neighbor in (node.left, node.right, node.parent):
 if neighbor and neighbor not in seen:
 neighbor.dist = node.dist + 1
 seen.add(neighbor)
 queue.append(neighbor)
 return []

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
 vector<int> distanceK(TreeNode* root, TreeNode* target, int K) {
 map<TreeNode*, TreeNode*> parents; // Initial parents for all nodes
 dfs(parents, root, nullptr);

 queue<pair<TreeNode*, int> > q;
 set<TreeNode*> seen;

 q.push({target, 0}); // Distance from itself is zero
 seen.insert(target); // To check if visited
 while(!q.empty()) { // run until queue is empty
 if(q.front().second == K) {
 vector<int> result;
 while(!q.empty()) {
 result.push_back(q.front().first->val);
 q.pop();
 }
 return result;
 }

 // Go through the neighbors of current node
 auto cur = q.front();
 q.pop();
 auto node = cur.first;
 auto dist = cur.second;

 TreeNode* neighbors[] = {
 node->left,
 node->right,
 parents[node]
 };
 for(auto neighbor: neighbors) {
 if(neighbor != nullptr && seen.find(neighbor) == seen.end()) {
 auto new_dist = dist + 1;
 seen.insert(neighbor);
 q.push({neighbor, new_dist});
 }
 }
 }
 return {};
 }

private:
 void dfs(map<TreeNode*, TreeNode*> &parents, TreeNode* node, TreeNode* parent) {
 if(node != nullptr) { // Check if the node is not Node
 parents[node] = parent; // Create a parent
 dfs(parents, node->left, node);
 dfs(parents, node->right, node);
 }
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


import java.util.*;
import java.lang.*;

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode(int x) { val = x; }
 * }
 */
class Pair {
 public TreeNode first;
 public Integer second;
 public Pair(TreeNode first, Integer second) {
 this.first = first;
 this.second = second;
 }
}
class Solution {
 public List<Integer> distanceK(TreeNode root, TreeNode target, int K) {
 Map<TreeNode, TreeNode> parents = new HashMap<>();
 dfs(parents, root, null); // Initial parents for all nodes

 Queue<Pair> queue = new LinkedList<>();
 Set<TreeNode> seen = new HashSet<>();

 queue.add(new Pair(target, 0)); // Distance from itself is zero
 seen.add(target); // To check if visited
 while(!queue.isEmpty()) { // run until queue is empty
 if(queue.peek().second == K) { // Found one of our answer nodes
 List<Integer> result = new ArrayList<>();
 while(!queue.isEmpty())
 result.add(queue.remove().first.val);
 return result;
 }

 // Go through the neighbors of current node
 Pair cur = queue.remove();
 TreeNode node = cur.first;
 int dist = cur.second;

 TreeNode[] neighbors = {
 node.left,
 node.right,
 parents.get(node)
 };
 for(TreeNode neighbor : neighbors) {
 if(neighbor != null && !seen.contains(neighbor)) {
 int new_dist = dist + 1;
 seen.add(neighbor);
 queue.add(new Pair(neighbor, new_dist));
 }
 }
 }
 return new ArrayList<Integer>();
 }

 private void dfs(Map<TreeNode, TreeNode> parents, TreeNode node, TreeNode parent) {
 if(node != null) { // Check if the node is not Node
 parents.put(node, parent); // Create a parent attribute
 dfs(parents, node.left, node);
 dfs(parents, node.right, node);
 }
 }
}

]]>

Leetcode Problem - Continuous Median

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/find-median-from-data-stream/
Difficulty: Hard
Category: Arrays

Step 1: Grasping the Problem

This problem is an ad-hoc problem. So there are tons of solutions with similar time and space complexity. Given a stream of input integers, at any time find the median of the integers. According to wiki, the definition of median is:

The median of a finite list of numbers is the “middle” number, when those numbers are listed in order from smallest to greatest.

If there is an odd number of numbers, the middle one is picked. For example, consider the list of numbers

[1, 3, 3, 6, 7, 8, 9]

This list contains seven numbers. The median is the fourth of them, which is 6.

If there is an even number of observations, then there is no single middle value; the median is then usually defined to be the mean of the two middle values.[1][2] For example, in the data set

[1, 2, 3, 4, 5, 6, 8, 9]

The the naive approach will be to sort the integers and pick the middle values (average them if needed). But it will take O(n*logn) for findMedian() function. Can we optimize this more? Notice that the values are given 1 at a time. So while getting the values with addNum(int) function, we can add data-structures specifically to get the medium as fast as possible.

Step 2: Building data structures concept with heaps

A binary heap is an abstract binary tree with the following properties:

A child parent relation will always hold in the whole tree. Most of the time, the relation is lesser than (<) or greater than (>).
It must be a complete binary tree. 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.

Below are two representations of a min-heap (a heap where the child-parent relationship is “<”) and a max-heap (a heap where the child-parent relationship is “>”).

1
2
3
4
5
6


 1 10
 / \ / \
 5 3 7 3
 / / \ / \
7 3 5 1 -10
 min-heap max-heap

The above two heaps can be represented in arrays like below:

1
2


min-heap: [1, 5, 3, 7]
max-heap: [10, 7, 3, 3, 5, 1, -10]

The implementation of heaps are very easy to do. But python has built-in heap modules to leverage our coding load. Below is TL;DR of the heaps documentation which is used to solve the problem. To learn more about heapq, please refer to the documentation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


import heapq

an_array = []

heapq.heappush(an_array, 5)
heapq.heappush(an_array, 3)
heapq.heappush(an_array, 6)
heapq.heappush(an_array, 1)
heapq.heappush(an_array, 9)

print(an_array)
# [1, 3, 6, 5, 9]

print(heapq.heappop(an_array))
# 1
print(heapq.heappop(an_array))
# 3

print(an_array)
# [5, 9, 6] # 5 is top of tree

Step 3: `addNum(int)` implementation

Now that we are familiar with basic operations of heaps, In this problem, we are going to use two heaps to solve. The first one is a min-heap, and the second one is a max-heap. As we just want the middle of the numbers, the max-heap named left will keep the first half of all the numbers so that it has the middle value (or the left value of the middle values if there are even numbers) on top of the heap. And the min-heap named right will hold the second half of all the numbers so that it has the right value of the middle value/s. As there are multiple functions to use in the class, we have to make member variables to use these in all functions of the class.

1
2
3
4


def __init__(self):
 # Initialization
 self.left = [] # A minheap top is left[0]
 self.right = [] # A maxheap top is -right[0]

Python does not have any implementation for max-heaps. But it can be achieved with a very simple trick. Just negate the values before pushing them to the heap!

We will push the new values to the left first, then pop that value back and push it to the right heap. This makes the left and right arrays always heapified.

1
2
3


def addNum(self, num: int) -> None:
 heapq.heappush(self.left, num)
 heapq.heappush(self.right, -heapq.heappop(self.left))

To make the left heap always have the middle value, it needs always to have more or equal values than right heap. This way, it is guaranteed that left will hold the median if the number of elements is odd. But the new value is currently in the right heap (possibly making it bigger than left). So we compare the size of both, and move one value from right to left.

1
2
3



if len(self.left) < len(self.right):
 heapq.heappush(self.left, -heapq.heappop(self.right))

This completes the addNum(int) function implementation.

Step 4: `findMedian()` implementation

Because we have the median at the top of the two heaps, this implementation is pretty straight forward. We will check if we have even or odd values. We can also check if size of left is greater than size of right and return the top of left if not equal (total even numbers) or return the average of two tops if equal (total odd numbers). Remember that the top of the heap is already the first element of the array. And also remember that because the numbers were inserted into the max-heap after negating, you will have to negate it again to get the actual value. So when calculating the medium, we will subtract the top of right instead of adding with top of left.

1
2
3
4


def findMedian(self) -> float:
 if len(self.left) > len(self.right):
 return self.left[0]
 return (self.left[0] - self.right[0]) * 0.5

The complexity of addNum(int) is O(logn) because we are inserting a value in a binary tree. The complexity of findMedian(self) is constant.

The final solution is given below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


import heapq

class MedianFinder:
 def __init__(self):
 # Initialization
 self.left = [] # A minheap top is left[0]
 self.right = [] # A maxheap top is -right[0]


 def addNum(self, num: int) -> None:
 heapq.heappush(self.left, num)
 heapq.heappush(self.right, -heapq.heappop(self.left))

 if len(self.left) < len(self.right):
 heapq.heappush(self.left, -heapq.heappop(self.right))

 def findMedian(self) -> float:
 if len(self.left) > len(self.right):
 return self.left[0]
 return (self.left[0] - self.right[0]) * 0.5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


import heapq

class MedianFinder:
 def __init__(self):
 # Initialization
 self.left = [] # A minheap top is left[0]
 self.right = [] # A maxheap top is -right[0]


 def addNum(self, num: int) -> None:
 heapq.heappush(self.left, num)
 heapq.heappush(self.right, -heapq.heappop(self.left))

 if len(self.left) < len(self.right):
 heapq.heappush(self.left, -heapq.heappop(self.right))

 def findMedian(self) -> float:
 if len(self.left) > len(self.right):
 return self.left[0]
 return (self.left[0] - self.right[0]) * 0.5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


class MedianFinder {
 priority_queue<int> left;
 priority_queue<int, vector<int>, greater<int> > right;
public:
 /** initialize your data structure here. */
 MedianFinder() { }

 void addNum(int num) {
 left.push(num);
 right.push(left.top());
 left.pop();

 if(left.size() < right.size()) {
 left.push(right.top());
 right.pop();
 }
 }

 double findMedian() {
 if(left.size() > right.size())
 return left.top();
 return (left.top() + right.top()) * 0.5;
 }
};

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder* obj = new MedianFinder();
 * obj->addNum(num);
 * double param_2 = obj->findMedian();
 */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


import java.util.*;
import java.lang.*;

class MedianFinder {
 /** initialize your data structure here. */
 PriorityQueue<Integer> left;
 PriorityQueue<Integer> right;
 public MedianFinder() {
 left = new PriorityQueue<Integer>(); // Java min-heap
 right = new PriorityQueue<Integer>( // Java max-heap
 (Integer val1, Integer val2) -> (- Integer.compare(val1, val2))
 );
 }

 public void addNum(int num) {
 left.add(num);
 right.add(left.remove());

 if(left.size() < right.size())
 left.add(right.remove());
 }

 public double findMedian() {
 if(left.size() > right.size())
 return left.peek();
 return (left.peek() + right.peek()) * 0.5d;
 }
}

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder obj = new MedianFinder();
 * obj.addNum(num);
 * double param_2 = obj.findMedian();
 */

]]>

Leetcode Problem - Four Sum

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/4sum/
Difficulty: Medium
Category: Arrays

Step 1: Grasping the Problem

Given an array of integers, given an array nums and an integer target, we need to find the list of all unique quadruplets that sum to target. It can be easily perceived that we can do a brute force to check all possible combinations in the array resulting in an O(n^4) time complexity solution.

Of course, there is a better solution than O(n^4). Before solving this problem, it is better to get familiar with the famous 2-sum problem. In 2-sum problem, you are given an array and an integer, and you will need to return the pairs of integers which sum to the given integer. The best solution of 2-sum problem is linear in time complexity. YouTube channel Life at Google has a wonderful video on 2-sum problem to have a great intuition.

This problem can be taken as a generalization of 2-sum problem. We can have two loops over the array with first_index and second_index indices and within the loop, we need to find two number that add up to target - nums[first_index] - nums[second_index]. This becomes a reduction to 2-sum problem indeed.

The algorithm must not return duplicate quadruplets. For this reason, while traversing in the array, we need to make sure that no duplicate values are being looped over. The best way to do this is to sort the array first. We have already 2 outer first_index and second_index loops and a linear algorithm within, the worst case will be at least O(n^3). So sorting the array first will help us find duplicate without hurting the complexity of the algorithm.

A general overview with sample input nums = [1, 0, -1, 0, -2, 2] and target = 0 is visualized below. first_index is named i and second_index is named j to save space.

Step 2: Initialization and sorting the array

As mentioned earlier, to check duplicates, we will sort the array. We will also create a res array where we are going to store the detected quadruplets.

1
2


nums.sort()
res = []

Step 2: first_index loop

The most outer loop will take care of the first element of the resulting quadruplets. We will run this loop from the first element of the array till the last possible element we can include as the first item in resulting quadruplets. As quadruplets has 4 elements, there should be at least 3 elements left in the array for the first_index loop.

1
2


# first loop till third last number
for first_index in range(len(nums)-3):

Step 3: Skip duplicate first element

As the array is now sorted, all equal elements will be neighboring. So after the first iteration of first_index loop, if we again encounter the same element, we need to skip that to avoid duplicates. So we need to check if we are in the first iteration, and if we already have seen this element or not.

1
2


 if first_index > 0 and nums[first_index] == nums[first_index-1]:
 continue

Step 4: second_index loop

The second_index loop is very much similar to the first_index loop. We will start from the next element of first_index, and end leaving 2 elements in the array. In this step, we will also skip the duplicates for the second element of quadruplets.

1
2
3
4


 # Second loop till second last number
 for second_index in range(first_index+1, len(nums)-2):
 if second_index>first_index+1 and nums[second_index] == nums[second_index-1]:
 continue

Step 5: 2-SUM

The first two elements of the quadruplets have been taken care of. Now we just need to solve a 2SUM problem from (second_index+1)th element to the last element. There are many ways to solve this problem. Usually hashset is used to keep track of the seen elements and search in the rest of the array for a complement to sum element. But this is used because the array is not sorted. Using a hashset leads to O(n) space complexity for 2-sum problem. If the array is already sorted, we can use two-pointer shrinking method to solve 2-sum problem.

In two pointer shrinking method, we start with two variables left and right being on two ends of the remaining array. Then we check if we got the desired sum or not. If total value of quadruplet is greater than target, we need a smaller sum, so we move pointer right one index left. If total is smaller than target, we need a bigger sum, so we move pointer left one index right. This process is continued until the pointers overlap each other (or the window is shrank to zero). Finally, if total == target, we have a quadruplet! Simply add it to res. This time, we shrink the window from both sides to keep total as unchanged as possible.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


# Two sum problem
left = second_index+1
right = len(nums) - 1
while left < right:
 sample = [nums[first_index] + nums[second_index] + nums[left] + nums[right]]

 total = sum(sample)
 if total < target:
 left += 1
 elif total > target:
 right -= 1
 else:
 res.append(sample)
 left += 1
 right -= 1

But this will not be sufficient to solve the problem because we have not yet taken care of duplicates inside the 2-sum window. To do this, while shrinking the window, we see if the value we are getting in left or right is already found or not. This is not necessary if total != target because it will eventually be automatically skipped in the next iteration in while (total will not change, so total != target remains False).

1
2
3
4
5
6
7


 left += 1
 while nums[left] == nums[left-1] and left < right:
 left += 1

 right -= 1
 while nums[right] == nums[right+1] and left < right:
 right -= 1

Step 5: Return result

After all the loops are finished, we can simply return the res variable we have been using to log quadruplets.

1

return res

Step 6: Handle Corner Cases

This problem will work for all natural numbers (will work also for floating points). Also we do not need to check for undersized nums because the first_index loop will never run if len(nums) < 4.

Finally the algorithm takes O(n*n*n) time complexity and O(1) space complexity. This can not be further optimized because there is a proof for 3-sum (similar to 2-sum and 4-sum) problem to take at least O(n^3) time. The complete program is given below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


class Solution:
 def fourSum(self, nums: [int], target: int) -> [[int]]:
 # Handle corner case
 if len(nums) < 4:
 return []

 nums.sort()
 res = []

 # first loop till third last number
 for first_index in range(len(nums)-3):
 # Skip duplicates
 if first_index > 0 and nums[first_index] == nums[first_index-1]:
 continue

 # Second loop till second last number
 for second_index in range(first_index+1, len(nums)-2):
 # Skip duplicates
 if second_index>first_index+1 and nums[second_index] == nums[second_index-1]:
 continue

 # Two sum problem
 left = second_index+1
 right = len(nums) - 1
 while left < right:
 sample = [nums[first_index], nums[second_index], nums[left], nums[right]]
 total = sum(sample)

 # move left boundary
 if total < target:
 left += 1
 # move right boundary
 elif total > target:
 right -= 1

 # found match!
 else:
 res.append(sample)

 # move left next until new value found
 left += 1
 while nums[left] == nums[left-1] and left < right:
 left += 1

 # move right next until new value found
 right -= 1
 while nums[right] == nums[right+1] and left < right:
 right -= 1
 return res

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


class Solution {
public:
 vector<vector<int>> fourSum(vector<int>& nums, int target) {
 // Handle corner case
 if(nums.size() < 4)
 return {};

 sort(nums.begin(), nums.end());
 vector<vector<int> > res;

 // first loop till third last number
 for(int firstIndex = 0; firstIndex < nums.size() - 3; firstIndex++) {
 // Skip duplicates
 if(firstIndex > 0 && nums[firstIndex] == nums[firstIndex-1])
 continue;

 // Second loop till second last number
 for(int secondIndex = firstIndex+1; secondIndex < nums.size() - 2; secondIndex++) {
 // Skip duplicates
 if(secondIndex > firstIndex + 1 && nums[secondIndex] == nums[secondIndex - 1])
 continue;

 int left = secondIndex + 1;
 int right = nums.size() - 1;
 while(left < right) {
 vector<int> sample = {
 nums[firstIndex],
 nums[secondIndex],
 nums[left],
 nums[right]
 };

 int total = accumulate(sample.begin(), sample.end(), 0);

 // move left boundary
 if(total < target)
 left++;
 // move right boundary
 else if(total > target)
 right--;

 // found match!
 else {
 res.push_back(sample);
 left++;
 while(nums[left] == nums[left-1] && left < right)
 left++;
 right--;
 while(nums[right] == nums[right+1] && left < right)
 right--;
 }
 }
 }
 }
 return res;
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


class Solution {
 public List<List<Integer>> fourSum(int[] nums, int target) {
 // Handle corner case
 if(nums.length < 4)
 return new ArrayList<>();

 Arrays.sort(nums);
 List<List<Integer>> res = new ArrayList<>();

 // first loop till third last number
 for(int firstIndex = 0; firstIndex < nums.length-3; firstIndex++) {
 // Skip duplicates
 if(firstIndex > 0 && nums[firstIndex] == nums[firstIndex - 1])
 continue;

 // Second loop till second last number
 for(int secondIndex = firstIndex+1; secondIndex < nums.length - 2; secondIndex++) {
 // Skip duplicates
 if(secondIndex > firstIndex + 1 && nums[secondIndex] == nums[secondIndex - 1])
 continue;

 int left = secondIndex + 1;
 int right = nums.length - 1;
 while(left < right) {
 List<Integer> sample = new ArrayList<>(
 Arrays.asList(
 nums[firstIndex],
 nums[secondIndex],
 nums[left],
 nums[right]
 )
 );

 int total = 0;
 for(int num: sample)
 total += num;

 // move left boundary
 if(total < target)
 left++;
 // move right boundary
 else if(total > target)
 right--;

 // found match!
 else {
 res.add(sample);
 left++;
 while(nums[left] == nums[left-1] && left < right)
 left++;
 right--;
 while(nums[right] == nums[right+1] && left < right)
 right--;
 }
 }
 }
 }
 return res;
 }
}

]]>

Leetcode Problem - Itinerary Reconstruction

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/reconstruct-itinerary/
Difficulty: Hard
Category: Graphs

Step 1: Grasping the Problem

You are given a list of airline tickets in [from, to] format and you will need to construct an itinerary in order starting from a fixed airport "JFK". The key points to mention in this question are:

Lexical ordered itinerary should be constructed if there are multiple itinerary possible.
It is guaranteed that an itinerary with using all tickets is possible.
One must use all the tickets and start from "JFK".

Because there are a lot of visiting and traversal going on, one can surely tell that this is a graph theory problem. So first and foremost thing to do is create a graph from the given tickets.

In the graph, the airports will be nodes and the tickets will be edges. According to the problem stated above, we can say “using all tickets exactly once” means “using all edges exactly once” in the graph. So in this graph problem, one needs to use all edges no matter if you visit the nodes or not. Hearing this, if you are familiar, you will say this is the application of Eulerian Path Construction Algorithm.

There are a lot of algorithms to construct the eulerian path from both directed and undirected graphs e.g. Fleury’s algorithm, Hierholzer’s algorithm etc. Our graph is directed and we will construct the path with a modified version of Hierholzer’s algorithm.

Step 2: Reverse sort the tickets

Because we need the first lexicographic ordered solution, we need to traverse the graph is lexicographic order. For this, we will construct the graph in a way so that the adjacency list’s descendants will be ordered. For this, we will sort the tickets in descending order.

1
2


# To maintain the lexical order
tickets.sort(reverse=True)

Step 2: Build the Graph

The first part of solving a graph theory problem has always been constructing the graph itself. In python it is now-a-days usual to represent a graph with dictionary graph where the keys are sources and values are list of descendants of each edge. This is an adjacency list representation of the graph.

Many use defaultdict to create the graph, but to keep things simple, we will use “default” dict of python instead. Just loop through the edges (tickets in this problem) and append a src dst to the graph dict.

1
2
3
4
5
6


# Build the graph
graph = {}
for src, dst in tickets:
 if src not in graph:
 graph[src] = []
 graph[src].append(dst)

Step 3: Eulerian Path Construction

A graph may or may not have eulerian paths depending on where the edges it has. Hierholzer’s algorithm first checks if the graph has a feasible Eulerian path in it. To check that, it follows the following table.

There are four flavors of Euler path/circuit problem we care about:

X	Eulerian Circuit	Eulerian Path
Undirected Graph	Every vertex has an even degree	Either every vertex has even degree or exactly two vertices have odd degree.
Directed Graph	Every vertex has equal indegree and outdegree	At most one vertex has (outdegree) - (indegree) = 1 and at most one vertex has (indegree) - (outdegree) = 1 and all other vertices have equal in and outdegrees.

This problem guarantees that there must be at least one eulerian path in it. So we do not need to check whether there is one or not.

After detecting the existence of Eulerian path, the algorithm does the two things:

Choose any starting vertex v, and follow a trail of edges from that vertex until returning to v. It is not possible to get stuck at any vertex other than v, because the even degree of all vertices ensures that, when the trail enters another vertex w there must be an unused edge leaving w. The tour formed in this way is a closed tour, but may not cover all the vertices and edges of the initial graph.

As long as there exists a vertex u that belongs to the current tour but that has adjacent edges not part of the tour, start another trail from u, following unused edges until returning to u, and join the tour formed in this way to the previous tour.

Since we assume the original graph is connected, repeating the previous step will exhaust all edges of the graph.

So we can use a list named route to keep track of “joining the tour formed in this way”. We can also create and call a recursive function to do “repeating the previous step” to “exhaust all edges” and get the final route in backward.

A demonstration of the algorithm is given below. Note that, this graph does not have a valid itinerary to use all tickets, still the algorithm takes as much tickets as possible and build an itinerary.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# Eulerian path
route = []
def visit(airport):
 # DFS-like visiting all node
 while airport in graph and graph[airport]:
 dst = graph[airport].pop()
 visit(dst)
 # push the first non-visited node
 route.append(airport)
visit('JFK')

Step 4: Reverse and Return `route`

Finally, we have route with the eulerian path in backward direction. So we will reverse the path and return it as a result.

1
2


# Return in reverse
return reversed(route)

The time complexity of this problem is O(ELogE) where E is the number of edges (tickets), and V is the number of nodes (airports). The space complexity is order of O(E) because we are just storing the graph with a dict. The small but efficient full code is given below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class Solution:
 def findItinerary(self, tickets: [[str]]) -> [str]:
 # To maintain the lexical order
 tickets.sort(reverse=True)

 # Build the graph
 graph = {}
 for src, dst in tickets:
 if src not in graph:
 graph[src] = []
 graph[src].append(dst)

 # Eulerian path
 route = []
 def visit(airport):
 # DFS-like visiting all node
 while airport in graph and graph[airport]:
 dst = graph[airport].pop()
 visit(dst)
 # push the first non-visited node
 route.append(airport)
 visit('JFK')

 # Return in reverse
 return reversed(route)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


class Solution {
 unordered_map<string, vector<string> > graph;
public:
 vector<string> findItinerary(vector<vector<string>>& tickets) {
 // To maintain the lexical order
 sort(tickets.begin(), tickets.end(), [] (vector<string> &first, vector<string> &second) -> bool {
 bool tmp = lexicographical_compare(first[0].begin(), first[0].end(), second[0].begin(), second[0].end());
 if(first[0] == second[0])
 return lexicographical_compare(first[1].begin(), first[1].end(), second[1].begin(), second[1].end());
 return tmp;
 });
 reverse(tickets.begin(), tickets.end());

 // Build the graph
 for(auto ticket: tickets)
 graph[ticket[0]].push_back(ticket[1]);

 // Eulerian path
 vector<string> route;
 visit("JFK", route);

 // Return in reverse
 reverse(route.begin(), route.end());
 return route;
 }

private:
 void visit(string airport, vector<string> &route) {
 // DFS-like visiting all node
 while(graph.find(airport) != graph.end() && graph[airport].size() != 0) {
 auto dst = graph[airport].back();
 graph[airport].pop_back();
 visit(dst, route);
 }
 // push the first non-visited node
 route.push_back(airport);
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


class Solution {
 Map<String, PriorityQueue<String>> graph;

 public List<String> findItinerary(List<List<String>> tickets) {
 // Unlike python, where we manually sorted tickets.
 // We will use map with PriorityQueue as value which is faster

 // Build the graph
 graph = new HashMap<>();
 for (List<String> ticket : tickets) {
 graph.putIfAbsent(ticket.get(0), new PriorityQueue<>());
 graph.get(ticket.get(0)).add(ticket.get(1));
 }

 // Eulerian path
 LinkedList<String> route = new LinkedList<>();
 visit("JFK", route);

 return route;
 }

 private void visit(String airport, LinkedList<String> route) {
 PriorityQueue<String> priorityQueue = graph.get(airport);
 // DFS-like visiting all node
 while(priorityQueue != null && !priorityQueue.isEmpty())
 visit(priorityQueue.poll(), route);
 route.addFirst(airport);
 }
}

]]>

Leetcode Problem - Jump Game II

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/jump-game-ii/
Difficulty: Hard
Category: Dynamic Programming

Step 1: Grasping the Problem

Many people classify this popular “Minimum number of jumps” problem into a dynamic programming problem. In spite of it being truely a dynamic programming problem, it can be solved without noticing any dynamic programming behavior in it. The problem will give you a non-negative integer array nums, where each element defines the maximum length of jump one can make from that index. Starting from index 0, you need to determine the minimum number of jumps required to reach the end of the array.

Below are some important inference one might miss from this problem.

Although the problem does not say anything whether you can jump backward or not, it is not necessary because each element of the array represents maximum jump length. That means of course, you can make shorter jumps in order to get the best result.
From an element, the farthest point we can go will never decrease for the forthcoming elements. So if we are at ith stair and the farthest stair we could go is farthest_possible, farthest_possible will always increase for i+k where k is |nums|-i.
We do not need the last value of nums. Because we will never jump from the last index (it is the destination).

Step 2: Keep track of farthest stair possible

We can start iterating through nums and keep track of the farthest stair we can go from any previous index. For index i, it will be max(k + nums[k]) where k = 0:i. We will also initialize a variable names total_jumps to store the result. Notice how we are leaving the last index of the array in the loop.

1
2
3
4
5
6


total_jumps = 0
current_end = 0 # We will use this on step 3
farthest_possible = 0 # Or any negative value
for jump_ind, jump_len in enumerate(nums[:-1]):
 # Update farthest index I can reach
 farthest_possible = max(farthest_possible, jump_ind + jump_len)

Step 3: Keep track of last jump end

When we reach at a stair which is farthest from the last jump we made, we need to make a new jump. And this jump is not necessarily needed to make from the current index. We can make a jump from any stair before (preferably from that stair which will send us to the farthest_possible).

But as soon as we make a jump, we need to keep track of the farthest jump during that time (let this stored variable be current_end). Next time at each index, we will check if we have reached the end of the last jump or not.

1
2
3
4


# We have to use a new jump from any previous stair and reach farthest
if jump_ind == current_end:
 total_jumps += 1
 current_end = farthest_possible

The visualization of how farthest_possible, current_end and total_jumps work is demonstrated below.

Step 4: Return the total jumps

After the iteration ends, total_jumps will hold the total jumps needed to reach the last index.

1

return total_jumps

We are assuming that it is guaranteed to reach the end of the array. But it is pretty easy to handle, just check if farthest_possible is less than jump_ind.

This algorithm runs only a single loop, so it takes O(n) time and O(1) space complexity. The complete program is given below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class Solution:
 def minJump(self, nums: [int]) -> int:
 total_jumps = 0
 current_end = 0
 farthest_possible = 0

 for jump_ind, jump_len in enumerate(nums[:-1]):
 # Update farthest index I can reach
 farthest_possible = max(farthest_possible, jump_ind + jump_len)
 # We have to use a new jump from any previous stair and reach farthest
 if jump_ind == current_end:
 total_jumps += 1
 current_end = farthest_possible
 return total_jumps

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


class Solution {
public:
 int jump(vector<int>& nums) {
 int totalJumps = 0, currentEnd = 0, farthestPossible = 0;
 for(int jumpI = 0; jumpI < nums.size() - 1; ++jumpI) {
 int jumpLen = nums[jumpI];
 // Update farthest index I can reach
 farthestPossible = max(farthestPossible, jumpI + jumpLen);
 // We have to use a new jump from any previous stair and reach farthest
 if(jumpI == currentEnd) {
 totalJumps++;
 currentEnd = farthestPossible;
 }
 }
 return totalJumps;
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Solution {
 public int minJump(int[] nums) {
 int totalJumps = 0, currentEnd = 0, farthestPossible = 0;
 for(int jumpI = 0; jumpI < nums.length - 1; jumpI++) {
 int jumpLen = nums[jumpI];
 // Update farthest index I can reach
 farthestPossible = Math.max(farthestPossible, jumpI + jumpLen);
 // We have to use a new jump from any previous stair and reach farthest
 if(jumpI == currentEnd) {
 totalJumps++;
 currentEnd = farthestPossible;
 }
 }
 return totalJumps;
 }
}

]]>

Leetcode Problem - Longest Substring Without Duplication

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/longest-substring-without-repeating-characters/
Difficulty: Hard
Category: Strings

Step 1: Grasping the Problem

We need to get the length of the maximum substring from a given string where the substring must not have any duplicate characters. We do not need to return the substring. So we do not need to care about the order of the substrings.

As we do not need the string, we just need to take care of the frequencies of the largest string. In a more “targeting towards the solution” way, we need to keep the characters of largest string so far stored so that when we try to make the string larger by concatenating more characters, we can make sure that it is not already in the stored characters. Hashset is a perfect data-structure for the following use. Python has built in set for this.

Also, a substring is a sequential subset of the given string string. And we need to expand this sequential subset as large as possible. This tells us that a sliding window maximization approach is best to solve this problem.

In a sliding window maximization problem, we start from the first element with window size one. Then we try to expand the window by one-by-one element until we can’t. Then we shrink the window until again we become able to increase it. Everytime we increase, we could track both the largest substring and it’s length. Below is a small demonstration of what a sliding window approach would look like.

Step 2: Sliding Window Initialization

A sliding window needs four things to operate.

The left boundary of the window (left for this solution).
The right boundary of the window (right for this solution).
The target variable (longest for this solution). This variable stores the target we want to get from the window. It can be many variables or states like the starting and ending of the substring. But in this solution, we only need the length of the largest substring.
Any intermediate variables to assert the conditions of window expanding/shrinking ability. In this problem, it is current_chars which stores the characters of the largest string.

So the initialization will look something like this:

1
2
3


longest = 0 # Answer
left, right = 0, 0 # Window bounds
current_chars = set() # Chars within current window

Step 3: Loop for the window

The sliding window will run until we have reached the end of the string. But do we need the left variable to reach the end too? No, because we need only the largest value. Moving left towards end will only shrink the window making longest smaller that it is now.

So looping until right has reached end will suffice.

1

while right < len(string):

Step 4: Expand the window

We can only expand the window when the new character is not in current_chars list. After checking if we can add the character, we need to add that character to current_chars to check for new characters in the future.

We also need to increase longest if it becomes larger than the previous one. And finally we need to expand the window boundary to one character right.

1
2
3
4
5


# Expand window
if string[right] not in current_chars:
 current_chars.add(string[right])
 right += 1
 longest = max(longest, right - left)

Step 5: Shrink the window

If we cannot expand the window, we will need to shrink it. We will shrink it until the new character is removed from current_chars. This can be taken care by the while loop we created earlier. And after removing the leftmost character of the window, we will move the left boundary of the window one character right.

1
2
3
4


# Shrink window
else:
 current_chars.remove(string[left])
 left += 1

Step 6: Return `longest`

After the while loop ends, we will surely get the longest substrings length. We will return it after the while loop.

1

return longest

Every sliding window problem takes O(n) time itself, where n is the length of the string. Inside the loop, we are making a look-up in a hashset and incrementing and decrementing variable. All these take O(1) time. So the time complexity of the algorithm is O(n) and space complexity is also O(n) in the worst case. The program is given below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Solution:
 def lengthOfLongestSubstring(self, string: str) -> int:
 longest = 0 # Answer
 left, right = 0, 0 # Window bounds
 current_chars = set() # Chars within current window
 while right < len(string):
 # Expand window
 if string[right] not in current_chars:
 current_chars.add(string[right])
 right += 1
 longest = max(longest, right - left)
 # Shrink window
 else:
 current_chars.remove(string[left])
 left += 1
 return longest

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class Solution {
public:
 int lengthOfLongestSubstring(string str) {
 int longest = 0; // Answer
 int left = 0, right = 0; // Window bounds

 // Chars within current window
 set<char> currentChars;
 while(right < str.length()) {
 // Expant window
 if(currentChars.find(str[right]) == currentChars.end()) {
 currentChars.insert(str[right++]);
 longest = max(longest, right - left);
 }
 // Shrink window
 else {
 currentChars.erase(str[left++]);
 }
 }
 return longest;
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
 public int lengthOfLongestSubstring(String string) {
 int longest = 0; // Answer
 int left = 0, right = 0; // Window bounds

 // Chars within current window
 Set<Character> currentChars = new HashSet<>();
 while(right < string.length()) {
 // Expand window
 if(!currentChars.contains(string.charAt(right))) {
 currentChars.add(string.charAt(right));
 right++;
 longest = Math.max(longest, right - left);
 }
 // Shrink window
 else {
 currentChars.remove(string.charAt(left));
 left++;
 }
 }
 return longest;
 }
}

]]>

Leetcode Problem - Lowest Common Ancestor

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/
Difficulty: Medium
Category: Trees

Step 1: Grasping the problem

This is a tree problem where a tree (by root) and two nodes (node1 and node2) within the tree is given. We will need to return LCA of node1 and node2.

Lowest Common Ancestor (LCA) of two nodes is defined as the node which is ancestor of both node1 and node2 and is at the lowest level of tree as possible. For example, in the below tree, node1 = 6 and node2 = 4. The LCA node cannot be 2 because node 2 is not an ancestor of node1 On the other hand, node 3 cannot be LCA node because there is another node (node 5) which is ancestor of both node1 and node2 and is in deeper level than 3. So the answer must be node 5.

Step 2: Add parent attribute

Currently only the root of the tree is given. That means we can only go from root to any child. But to solve this problem, we will need to be able to traverse from a child node to it’s parent. So the first task is to add a new data parent for each node so that we can easily traverse both down and up in the tree.

Unlike other statically typed programming languages, python has the powerful ability to create class attributes from outside of a class. We will use this to create the parent attribute right in each nodes.

To add an attribute to each node we need to traverse through all the nodes once. Any tree traversal algorithm can be used here. We are using simple DFS here. Go ahead and change the stack to a queue to do a BFS traversal.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


root.parent = None
# Start a DFS and assign parent to each node
stack = {root}
while stack:
 node = stack.pop()
 if node.left:
 node.left.parent = node
 stack.append(node.left)
 if node.right:
 node.right.parent = node
 stack.append(node.right)

Step 3: Store the path of `node1`

Now we need to store the path of node node1 and then look where the path conflicts with node node2’s path. node1 and node2 are interchangeable in this case so you can store the path of node2 and look up which node in node1 path conflicts with it.

As we already have the node node1 in hand, with the help of parent attribute we just created, we will traverse up in the tree till root and store all the nodes in the path.

This stored list of nodes will only be used for lookup of a node. So instead of using list as the data structure, we can use a hashset implementation set which is similar to unordered_set<int> in C++ and efficient in key lookups.

1
2
3
4
5


# Trace the path of node node1
node1_path = set()
while node1:
 node1_path.append(node1)
 node1 = node1.parent

Step 4: Search for first existent node

Now it is needed to do the almost same thing with node node2. Except for storing the nodes of the path, we will loop up the node in node1_path. The first node we find will be our answer!

1
2
3
4
5


# Search for first node of node2's parent in node1_path
while node2:
 if node2 in node1_path:
 return node2
 node2 = node2.parent

This is it. A good practice though is to return a value at the end of the function (just in case one cannot find and claim the code to be broken).

1

return None # A good practice

So the overall time complexity of the function is O(n) because there is nothing but traversal we are doing. The space complexity is also O(n) because we are storing the path of one node (node1 or node2). There are algorithms where you can make the space complexity to O(1) in the cost of more time. Below is the complete code of the solution.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


# Definition for a binary tree node.
class TreeNode:
 def __init__(self, x):
 self.val = x
 self.left = None
 self.right = None

class Solution:
 def lowestCommonAncestor(self, root: TreeNode, node1: TreeNode, node2: TreeNode) -> TreeNode:
 root.parent = None

 # Start a DFS and assign parent to each node
 stack = [root]
 while stack:
 node = stack.pop()
 if node.left:
 node.left.parent = node
 stack.append(node.left)
 if node.right:
 node.right.parent = node
 stack.append(node.right)

 # Trace the path of node node1
 node1_path = set()
 while node1:
 node1_path.add(node1)
 node1 = node1.parent

 # Search for first node of node2's parent in p_path
 while node2:
 if node2 in node1_path:
 return node2
 node2 = node2.parent

 return None # A good practice

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
 TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* node1, TreeNode* node2) {
 // Start a DFS and assign to each node
 stack<TreeNode*> st;
 st.push(root);
 map<TreeNode*, TreeNode*> parents;
 while(!st.empty()) {
 auto node = st.top();
 st.pop();
 if(node->left != nullptr) {
 parents[node->left] = node;
 st.push(node->left);
 }
 if(node->right != nullptr) {
 parents[node->right] = node;
 st.push(node->right);
 }
 }

 // Trace the path of node node1
 set<TreeNode*> node1Path;
 while(node1 != nullptr) {
 node1Path.insert(node1);
 node1 = parents.find(node1) != parents.end() ? parents[node1] : nullptr;
 }

 // Search for first node of node2's parent in node1Path
 while(node2 != nullptr) {
 if(node1Path.find(node2) != node1Path.end()) {
 return node2;
 }
 node2 = parents.find(node2) != parents.end() ? parents[node2] : nullptr;
 }
 return nullptr; // Must return in C++
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode(int x) { val = x; }
 * }
 */

class Solution {
 public TreeNode lowestCommonAncestor(TreeNode root, TreeNode node1, TreeNode node2) {

 // Start a DFS and assign parent to each node
 Stack<TreeNode> stack = new Stack<>();
 stack.push(root);
 Map<TreeNode, TreeNode> parents = new HashMap<>();
 while(!stack.isEmpty()) {
 TreeNode node = stack.pop();
 if(node.left != null) {
 parents.put(node.left, node);
 stack.push(node.left);
 }
 if(node.right != null) {
 parents.put(node.right, node);
 stack.push(node.right);
 }
 }

 // Trace the path of node node1
 Set<TreeNode> node1Path = new HashSet<TreeNode>();
 while(node1 != null) {
 node1Path.add(node1);
 node1 = parents.getOrDefault(node1, null);
 }

 // Search for first node of node2's parent in node1_path
 while(node2 != null) {
 if(node1Path.contains(node2))
 return node2;
 node2 = parents.getOrDefault(node2, null);
 }
 return null; // Must return in Java
 }
}

]]>

Leetcode Problem - Maximum Profit with K Transactions

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/
Difficulty: Hard
Category: Dynamic Programming

Step 1: Grasping the Problem

This problem gives an array of integer prices denoting stock prices each day and an integer k denoting the maximum number of transactions that can be made. We need to return the maximum profit possible for that stock. Some key points to notice in this problem is:

There cannot be multiple simultaneous transactions. So there will not be any overlaps in the transactions.
You can have at most |prices|/2 transactions where |prices| is the number of days.
If k > |prices|*2, then it can be said that unlimited transactions can be made. Because you can make at most |prices|/2 transactions as stated in the previous point.

This tells us that we may have to handle the scenario where k>|price|*2 and the normal cases separately.

The problem statement tells that we can do at most k transactions, that means that we can have less than k transactions. Notice that you can break any transaction to multiple transactions if that takes more that 2 days. Below is an example where prices = [2, 4, 5, 7]. To get a profit of 7 - 2 = 5, you can make two transactions: first one buying at day 1 and selling at day 3 (profit = 5-2 = 3), and the second one buying at day 3 and selling at day 4 (profit = 7-5 = 2). This gives a profit of 3 + 2 = 5. And you can also do only one transaction buying at day 1 and selling at day 4.

Now suppose k=1. In that case, you’ll need to check for only one transaction in the whole prices and that would be the result. Then think of k=2. We can do the following things at each day in that scenario:

If we are not holding any transaction, then we can buy a new transaction. Buying means that we are subtracting the price of that day from our total amount. By this process, we can make at most k transactions.
If we are holding a transaction, we can sell a transaction: selling ith transaction means, the total amount becoming the the last time we gave money to buy a transaction plus the price of today’s stock.

So, we can track all the states of the transactions and prices by tracking our total amount for each buy and sell, making new transactions by adding or subtracting todays price from the last transaction.

This gives us intuition about the problem being a DP (Dynamic programming) problem. Here, we will use two arrays to store the maximum amount possible at each transaction. We do not need to track this based on days, because only the transactions make changes to those states.

buy[t] : Amount of money while buying for the t'th transaction.
sell[t]: Amount of money while selling for the t'th transaction.

Step 2: Create a DP table

DP (Dynamic Programming) is a programming paradigm where there can be multiple dependent subproblems. There are two different ways to approach a DP problem: Recursively and iteratively. We will be showing the iterative approach as it can be elaborated more with data. For iterative Dynamic Programming, you will need to fill up a table which is known as DP table. As our problem is only dependent on the last transaction from the current transaction, and there are at most k transactions possible, we will use a DP table of k*2 size, where the first row of the table is the track of best buy transaction amounts, and the second row is track of best sell transaction amounts. Now the initial values of the buy row will be a minimum value, so that we can compute them with a negative value. We will need this in future. On the other hand, sell row will be initialized to zero because, without making any transactions you’ll get total amount of zero.

transaction	1	2	…	k
buy	-∞	-∞	-∞	-∞
sell	0	0	0	0

This can be done either by creating a 2D array, or buy creating just two variable buys and sells. Multiplying an array with an integer in python will result in concatenating the array with itself. We can use this to initialize the value.

1
2
3


# Build the table
buys = [float('-inf')] * k
sells = [0 ] * k

Step 3: Fill up DP table

As we have defined how we are going to store the states needed for the problem, we will need a state transition function. We will do this by first iterating through the prices stock prices list, and then iterating through the number of transactions we can make at most.

1
2


for price in prices:
 for transaction in range(k):

Initially when we do not have any transactions done, the price will be -price where price is the price of the first day. This will be negative so that when we sell this stock, the price will be new_buy = -price(at day 1) + price(at day of selling). Of course the selling price will have to be greater than the buying price so that we can make a profit. We will use a new variable new_buy to store this.

1
2


if transaction == 0:
 new_buy = -price

Now what will be the amount when it is not the first transaction? Then we will already be having a profit in our hand. And this value will be in the sells row’s last transaction column (sells[transaction - 1]). Then we will subtract todays price from that value.

1
2


else:
 new_buy = sells[transaction-1] - price

Now that we have got the value we need for what happens if we buy a transaction or not, we can update the buys row. We will only buy if it is beneficial than not buying the transaction.

1
2


if new_buy > buys[transaction]:
 buys[transaction] = new_buy

After updating the buy for current transaction, We will see if we can sell beneficially today. We will sell today only if it is profitable, meaning adding todays stock price to the last buys[transaction] becomes greater thatn sells[transaction].

1
2


if buys[transaction] + price > sells[transaction]:
 sells[transaction] = buys[transaction] + price

In most of the languages, the above two updating can be done in one line with the help of built-in max function.

1
2


buys[transaction] = max(buys[transaction], new_buy)
sells[transaction] = max(sells[transaction], buys[transaction] + price)

After filling up the table, for example with prices = [5, 11, 3, 50, 60, 90] and k = 2, the table will look like below.

price	transaction	buys	sells
5	0	[-5, -inf]	[0, 0]
5	1	[-5, -5]	[0, 0]
11	0	[-5, -5]	[6, 0]
11	1	[-5, -5]	[6, 6]
…	…	…	…
60	0	[-3, 3]	[57, 53]
60	1	[-3, 3]	[57, 63]
90	0	[-3, 3]	[87, 63]
90	1	[-3, 3]	[87, 93]

Step 4: Handling corner cases

There can be two corner cases for this problem.

The typical corner case: What if you have no stock prices? |prices| = 0. What happens if you can make 0 transactions? k = 0. In both of these scenarios, we can tell that we will have a maximum of 0 profit. So we return 0.

1
2
3


# Corner cases 1: Usual
if not prices or k == 0:
 return 0

Unlimited transactions: As we have already stated in Step 1, you can have at most |prices|*2 transactions? So what if k > |prices|*2? Then you can easily calculate assuming you have unlimited transactions.

1
2
3
4
5
6
7
8


# Corner case 2: unlimited transactions
if k >= len(prices)/2:
 profit = 0
 for price_index in range(len(prices)-1):
 new_profit = prices[price_index+1] - prices[price_index]
 if new_profit > 0:
 profit += new_profit
 return profit

Note that these cases should be handled before going for the actual DP generation. Because there is no need to have a DP table if you already know you can have unlimited transactions.

Step 5: Returning the result

At this point, we have the DP table filled up properly. So what we can do is return our profit at k‘th transaction. We know that our profit is saved in sells row. So returning the k‘th column of it will be sufficient.

1

return sells[k-1]

The overall program is given below. As we had to loop through the prices list and number of transactions (k), the time complexity will be O(|prices| * k). The space complexity will also be O(|prices| * k) for the DP table.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


class Solution:
 def maxProfit(self, k: int, prices: [int]) -> int:
 # Corner cases 1: Usual
 if not prices or k == 0:
 return 0

 # Corner case 2: unlimited transactions
 if k >= len(prices)/2:
 profit = 0
 for price_index in range(len(prices)-1):
 new_profit = prices[price_index+1] - prices[price_index]
 if new_profit > 0:
 profit += new_profit
 return profit

 # Build the table
 buys = [float('-inf')]*k
 sells = [0]*k
 for price in prices:
 for transaction in range(k):
 if transaction == 0:
 new_buy = -price
 else:
 new_buy = sells[transaction-1] - price

 buys[transaction] = max(buys[transaction], new_buy)
 sells[transaction] = max(sells[transaction], buys[transaction] + price)
 return sells[k-1]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class Solution {
public:
 int maxProfit(int k, vector<int>& prices) {
 // Corner cases 1: Usual
 if(prices.size() == 0 || k == 0)
 return 0;

 // Corner case 2: unlimited transactions
 if(k >= prices.size()/2) {
 int profit = 0;
 for(int priceIndex = 0; priceIndex < prices.size()-1; priceIndex++) {
 int newProfit = prices[priceIndex + 1] - prices[priceIndex];
 if(newProfit > 0)
 profit += newProfit;
 }
 return profit;
 }

 // Build the table
 vector<int> buys(k, INT_MIN);
 vector<int> sells(k, 0);
 for(int price: prices) {
 for(int transaction = 0; transaction < k; transaction++) {
 int new_buy = -price;
 if(transaction != 0)
 new_buy = sells[transaction - 1] - price;
 buys[transaction] = max(buys[transaction], new_buy);
 sells[transaction] = max(sells[transaction], buys[transaction] + price);
 }
 }
 return sells[k-1];
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


class Solution {
 public int maxProfit(int k, int[] prices) {
 // Corner cases 1: Usual
 if(prices.length == 0 || k == 0)
 return 0;

 // Corner case 2: unlimited transactions
 if(k >= prices.length/2) {
 int profit = 0;
 for(int priceIndex = 0; priceIndex < prices.length - 1; priceIndex++) {
 int newProfit = prices[priceIndex+1] - prices[priceIndex];
 if(newProfit > 0)
 profit += newProfit;
 }
 return profit;
 }

 // Build the table
 int[] buys = new int[k];
 for(int buyI = 0; buyI < k; buyI++)
 buys[buyI] = Integer.MIN_VALUE;

 int[] sells = new int[k];
 for(int sellI = 0; sellI < k; sellI++)
 sells[sellI] = 0;

 for(int price: prices) {
 for(int transaction = 0; transaction < k; transaction++) {
 int new_buy = -price;
 if(transaction != 0)
 new_buy = sells[transaction - 1] - price;

 buys[transaction] = Math.max(buys[transaction], new_buy);
 sells[transaction] = Math.max(sells[transaction], buys[transaction] + price);
 }
 }
 return sells[k-1];
 }
}

]]>

Leetcode Problem - Minimum Window Substring

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/minimum-window-substring/
Difficulty: Hard
Category: Strings

Step 1: Grasping the Problem

A strings text and characters is given. We need to return the smallest substring of text which contains all the characters in characters.

The problem would have been easier if it said all the characters is the string characters will be unique. Then we could just manage a set and push characters from text until we get all the characters. But as the characters might not be unique, instead of set, we will need a hashtable/counter to keep track of the frequencies of each characters we encounter in string text.

A substring is a sequential subset of the given string text. And we need to minimize this sequential subset to as small as possible. This tells us that a sliding window minimization approach is best to solve this problem.

We will try to keep the sliding window as small as possible. For this, first we need to start the window with 0 length. We will have to option other than increasing the window size until a valid substring is found. Whenever substring is found, we will keep it as a potential result and try shrinking the window for smaller substring. When we cannot shrink the window, we will start increasing it again until the right bound of the window reaches the end.

Below is a visual demonstration of the process. Here, text = "ADCBCAAB" and characters = "BCAC".

Step 2: Sliding Window Initialization

A sliding window needs four things to operate.

The left boundary of the window (left for this solution).
The right boundary of the window (right for this solution).
The target variable (best_text for this solution). This variable stores the target we want to get from the window. It can be of many variables or states like the starting and ending of the substring (which will be more efficient). But for simplicity, in this solution, we will take the substring directly.
Any intermediate variables to assert the conditions of window expanding/shrinking ability. In this problem, we need two python collections.Counter objects to keep track if we have all the characters we need.

Initially, we want the target variable to be the worst or unfeasible. So that it will be overwritten by any existent solution in the window expanding/shrinking loop. The initialization will look something like this:

1
2
3
4
5
6
7


chars_given = Counter(characters) # count characters
chars_taken = Counter() # count remaining characters

best_text = "-" * (len(text) + 1) # bigger than text

left = 0 # Window left
# right window pointer can be moved into for loops dummy variable

Step 3: Expand the window

The sliding window will run until we have reached the end of the string. But do we need the left variable to reach the end too? Yes, because we are going to need the smallest value. But we do not need that condition to check in the outer loop, we will take care in the shrinking loop.

So looping until right has reached end will suffice. And at each time window is shrank, we will get a character char. We will take it in our `chars

1
2


for right, char in enumerate(text):
 chars_taken[char] += 1 # Expand window

Step 4: Shrinking ability check

We can only expand the window when we have all the characters we need in our chars_taken counter. One way to check this is looping through all the elements in chars_given and check if that character in chars_taken is greater. Something like below:

1
2
3
4
5
6


have_all = True
for char in chars_given:
 if chars_given[char] >= chars_taken[char]:
 have_all = False
if have_all:
 # We have all the characters, so we can shrink

But python has a more elegant & operator with better time complexity to handle this. chars_given & chars_taken returns intersection of the two counters. We need to check if the intersection is equal to chars_given.

1
2


# While window can be shrunk (operator & is intersection)
while chars_taken & chars_given == chars_given:

Step 5: Get Minimum Substring

We will need to update best_text everytime when we change the window size. This is for the following reasons.

When expanding the window: It would not be necessary at all if we had guaranteed substring. But if it wasn’t guaranteed, best_text needs to be updated if there is only one string matching our criteria.
When shrinking the window: We are going to need the smallest substring matching the criteria, so each time the window shrinks, there is a possibility of getting a smaller substring, so we need to update to the smallest.

We will check the window size (right - left) with the length of best_text then update best_text by slicing if needed.

1
2
3


# Update best_text
if right - left < len(best_text):
 best_text = text[left:right+1]

Step 6: Shrink the Window

Shrinking the window means removing a character from left in this context. So we will remove a character from chars_taken as well. And finally update the window bound left.

1
2
3


# Try to shrink window 
chars_taken[text[left]] -= 1
left += 1

Step 7: Return Smallest Substring

After the while loops ends, the best_text is guaranteed to be the smallest possible substring. But, the problem statement does not guaranteed that there will be a valid substring in text. So we need to check whether there is a valid substring or not before returning best_text.

Before the loops, best_text had a dummy string with length longer than the given string. If it is not updated inside the sliding window, that means best_text will still have that large dummy string. So we can check if length is greater than length of text and then return accordingly.

1
2
3
4
5


# if no string found
if len(best_text) <= len(text):
 return best_text
else:
 return ""

Every sliding window problem takes O(n) time itself, where n is the length of text. Inside the loop, we are making a look-up in a counters which is implemented by hashtables and incrementing and decrementing variables. The intersection of counters however will take O(S) time where S is the minimum number of elements in best_text(the answer). It can be told that S is very much negligible compared to n. So the time complexity of the algorithm will remain O(n) and space complexity is also O(n) in the worst case. The program is given below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


from collections import Counter

class Solution:
 def minWindow(self, text: str, characters: str) -> str:
 chars_given = Counter(characters) # count characters
 chars_taken = Counter() # count taken characters

 best_text = "-" * (len(text) + 1) # bigger than text

 left = 0 # Window left
 for right, char in enumerate(text):
 chars_taken[char] += 1 # Expand window

 # While window can be shrunk (operator & is intersection)
 while chars_taken & chars_given == chars_given:
 # Update best_text
 if right - left < len(best_text):
 best_text = text[left:right+1]

 # Try to shrink window 
 chars_taken[text[left]] -= 1
 left += 1

 # if no string found
 if len(best_text) <= len(text):
 return best_text
 else:
 return ""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


class Solution {
 unordered_map<char, int> charsGiven; // count given characters
 unordered_map<char, int> charsTaken; // count taken characters
public:
 string minWindow(string text, string characters) {

 for(char character: characters)
 charsGiven[character]++;

 string bestText(text.length() + 1, (char)0); // Initialize with invalid state

 int left = 0;
 for(int right = 0; right < text.length(); right++) {
 char character = text[right];
 charsTaken[character]++;
 // While window can be shrunk
 while(isValidWindow()) {
 // Update bestText
 if(right - left < bestText.length()) {
 bestText = text.substr(left, right-left+1);
 }

 // Try to shrink window
 charsTaken[text[left]]--;
 left++;
 }
 }
 // If no string found, bestText will remain invalid
 if(bestText.length() > text.length())
 return "";
 return bestText;
 }

private:
 bool isValidWindow() {
 for(auto charCountPair: charsGiven) {
 if(charsTaken.find(charCountPair.first) == charsTaken.end())
 return false;
 if(charsTaken[charCountPair.first] < charsGiven[charCountPair.first])
 return false;
 }
 return true;
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


class Solution {
 Map<Character, Integer> charsGiven;
 Map<Character, Integer> charsTaken;

 public String minWindow(String text, String characters) {
 charsGiven = new HashMap<>(); // count given characters
 charsTaken = new HashMap<>(); // count taken characters

 for(char character : characters.toCharArray())
 charsGiven.put(character, charsGiven.getOrDefault(character, 0) + 1);

 String bestText = new String(new char[text.length()+1]); // Initialize with invalid state

 int left = 0;
 for(int right = 0; right < text.length(); right++) {
 char character = text.charAt(right);
 charsTaken.put(character, charsTaken.getOrDefault(character, 0) + 1);
 // While window can be shrunk
 while(isValidWindow()) {
 // Update bestText
 if(right - left < bestText.length())
 bestText = text.substring(left, right+1);

 // Try to shrink window
 charsTaken.put(text.charAt(left), charsTaken.getOrDefault(text.charAt(left), 0) - 1);
 left++;
 }
 }
 // If no string found, bestText will remain invalid
 if(bestText.length() > text.length())
 return "";
 return bestText;
 }

 private boolean isValidWindow() {
 for(char character: charsGiven.keySet()) {
 if(!charsTaken.containsKey(character))
 return false;
 if(charsTaken.get(character) < charsGiven.get(character))
 return false;
 }
 return true;
 }
}

]]>

Leetcode Problem - Monotonic Array

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/monotonic-array/
Difficulty: Medium
Category: Arrays

Step 1: Grasping the Problem

The median of a finite list of numbers is the “middle” number, when those numbers are listed in order from smallest to greatest.

If there is an odd number of numbers, the middle one is picked. For example, consider the list of numbers

[1, 3, 3, 6, 7, 8, 9]

This list contains seven numbers. The median is the fourth of them, which is 6.

If there is an even number of observations, then there is no single middle value; the median is then usually defined to be the mean of the two middle values.[1][2] For example, in the data set

[1, 2, 3, 4, 5, 6, 8, 9]

Step 2: Building data structures concept with heaps

A binary heap is an abstract binary tree with the following properties:

A child parent relation will always hold in the whole tree. Most of the time, the relation is lesser than (<) or greater than (>).
It must be a complete binary tree. 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.

Below are two representations of a min-heap (a heap where the child-parent relationship is “<”) and a max-heap (a heap where the child-parent relationship is “>”).

1
2
3
4
5
6


 1 10
 / \ / \
 5 3 7 3
 / / \ / \
7 3 5 1 -10
 min-heap max-heap

The above two heaps can be represented in arrays like below:

1
2


min-heap: [1, 5, 3, 7]
max-heap: [10, 7, 3, 3, 5, 1, -10]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


import heapq

an_array = []

heapq.heappush(an_array, 5)
heapq.heappush(an_array, 3)
heapq.heappush(an_array, 6)
heapq.heappush(an_array, 1)
heapq.heappush(an_array, 9)

print(an_array)
# [1, 3, 6, 5, 9]

print(heapq.heappop(an_array))
# 1
print(heapq.heappop(an_array))
# 3

print(an_array)
# [5, 9, 6] # 5 is top of tree

Step 3: `addNum(int)` implementation

1
2
3
4


def __init__(self):
 # Initialization
 self.left = [] # A minheap top is left[0]
 self.right = [] # A maxheap top is -right[0]

Python does not have any implementation for max-heaps. But it can be achieved with a very simple trick. Just negate the values before pushing them to the heap!

We will push the new values to the left first, then pop that value back and push it to the right heap. This makes the left and right arrays always heapified.

1
2
3


def addNum(self, num: int) -> None:
 heapq.heappush(self.left, num)
 heapq.heappush(self.right, -heapq.heappop(self.left))

1
2
3



if len(self.left) < len(self.right):
 heapq.heappush(self.left, -heapq.heappop(self.right))

This completes the addNum(int) function implementation.

Step 4: `findMedian()` implementation

1
2
3
4


def findMedian(self) -> float:
 if len(self.left) > len(self.right):
 return self.left[0]
 return (self.left[0] - self.right[0]) * 0.5

The complexity of addNum(int) is O(logn) because we are inserting a value in a binary tree. The complexity of findMedian(self) is constant.

The final solution is given below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


import heapq

class MedianFinder:
 def __init__(self):
 # Initialization
 self.left = [] # A minheap top is left[0]
 self.right = [] # A maxheap top is -right[0]


 def addNum(self, num: int) -> None:
 heapq.heappush(self.left, num)
 heapq.heappush(self.right, -heapq.heappop(self.left))

 if len(self.left) < len(self.right):
 heapq.heappush(self.left, -heapq.heappop(self.right))

 def findMedian(self) -> float:
 if len(self.left) > len(self.right):
 return self.left[0]
 return (self.left[0] - self.right[0]) * 0.5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


class MedianFinder {
 priority_queue<int> left;
 priority_queue<int, vector<int>, greater<int> > right;
public:
 /** initialize your data structure here. */
 MedianFinder() { }

 void addNum(int num) {
 left.push(num);
 right.push(left.top());
 left.pop();

 if(left.size() < right.size()) {
 left.push(right.top());
 right.pop();
 }
 }

 double findMedian() {
 if(left.size() > right.size())
 return left.top();
 return (left.top() + right.top()) * 0.5;
 }
};

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder* obj = new MedianFinder();
 * obj->addNum(num);
 * double param_2 = obj->findMedian();
 */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


import java.util.*;
import java.lang.*;

class MedianFinder {
 /** initialize your data structure here. */
 PriorityQueue<Integer> left;
 PriorityQueue<Integer> right;
 public MedianFinder() {
 left = new PriorityQueue<Integer>(); // Java min-heap
 right = new PriorityQueue<Integer>( // Java max-heap
 (Integer val1, Integer val2) -> (- Integer.compare(val1, val2))
 );
 }

 public void addNum(int num) {
 left.add(num);
 right.add(left.remove());

 if(left.size() < right.size())
 left.add(right.remove());
 }

 public double findMedian() {
 if(left.size() > right.size())
 return left.peek();
 return (left.peek() + right.peek()) * 0.5d;
 }
}

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder obj = new MedianFinder();
 * obj.addNum(num);
 * double param_2 = obj.findMedian();
 */

]]>

Leetcode Problem - Parallel Courses

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/parallel-courses/
Difficulty: Hard
Category: Graphs

Step 1: Grasping the Problem

There are N courses with a prerequisites relationship among them. Our task is to determine the number of semester needed to complete all the courses. Here are the key points that will help us get started:

We cannot take a course whose prerequisites are not yet taken.
We cannot take a course whose prerequisites are even taken in this semester.
We have to start with the course that has no prerequisites.
If there is a cycle in the prerequisites relationship, there will be no solution.

As there are relationship among courses and we need to pick and complete each course at semesters, we know that it is a graph problem. We need to check if there is any cycle or not, if there isn’t, then we will need to get the course whose prerequisites are all complete. This is exactly what Topological Sorting does.

In computer science, a topological sort or topological ordering of a directed graph is a linear ordering of its vertices such that for every directed edge uv from vertex u to vertex v, u comes before v in the ordering.

So the answer of our problem is to make a topological ordering of the courses. And if we cannot make the ordering, then we will need to return -1.

Step 2: Build the Graph

To solve the problem with topological sorting, we need a graph first. In this graph, the nodes will be courses and the edges will be the relationships. The relationships are already given as edges relations. We will convert these into adjacency matrix representation.

So the graph will be a dictionary where, keys are courses and values are lists having courses that are dependent on the keys. We loop through relations and put them in the graph accordingly.

1
2
3
4
5
6


graph = {}
for relation in relations:
 # Make sure we don't get KeyError
 if relation[0] not in graph:
 graph[relation[0]] = []
 graph[relation[0]].append(relation[1])

Step 3: Topological Sorting Initialization

Topological Sorting requires us to track the in degrees of all nodes. For this, we will create an array named in_degree of size N+1. The courses in the problem is given in 1-indexed notation, for this, we have to create the extra unused index at 0.

1
2


in_degree = [0] * (N+1)
# Or: in_degree = [0 for _ in range(N+1)]

We can track the degrees while building the graph. Each time we find a relation, we increase the in degree of the descendant node.

1
2
3
4
5
6
7
8


# in_degree of N nodes, 1 indexed
in_degree = [0]*(N+1) # in_degree initialization
graph = {}
for relation in relations:
 if relation[0] not in graph:
 graph[relation[0]] = []
 graph[relation[0]].append(relation[1])
 in_degree[relation[1]] += 1 # update in_degree

Topological Sorting is very similar to BFS (Breadth First Search) or DFS (Depth First Search). Except that BFS/DFS starts from a source, topological sorting starts from all the nodes that has in_degree = 0. We will do a BFS. To do this, we will need a queue. For implementation, we will use pythons built-in collections.deque data structure. Start a loop through all the N courses, and put the courses that has in_degree = 0 into the queue.

1
2
3
4
5


# Collect all 0 in degree nodes
queue = deque()
for i in range(1, N+1):
 if in_degree[i] == 0:
 queue.append(i)

Step 4: Topological Sorting

Topological Sorting will keep running a loop until the queue is empty. At the beginning of the loop, we will keep track of how many courses we have in the queue. Because that will be the number of courses we can take in this semester (this_semester). this_semester is not used in anywhere, it is named so, for understanding purposes only.

At each semester, we will take each course from the queue, and decrease the in_degrees of all the courses that depend on current course. If in_degree for a course becomes 0, we push it into the queue to mark it available for the next semester. After doing this for all the queue elements, we will increament the semester by 1.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


# Topological sort
semesters = 0
courses_taken = 0
while queue:
 # len(queue) courses in 1 semester
 for this_semester in range(len(queue)):
 course = queue.popleft()
 courses_taken += 1

 if course in graph:
 for neighbor in graph[course]:
 in_degree[neighbor] -= 1
 if in_degree[neighbor] == 0:
 queue.append(neighbor)
 semesters += 1

courses_taken another variable is used to count the number of courses popped from the queue. This will be used after the topological sorting to test if we could take all the courses or not. Here, courses_taken != N will be True when there is a cycle detected in the graph and there is no topological sorting possible.

Below is a demonstration of the topological sorting process.

If courses_taken == N, we know that we have taken all the courses, so we return the number of semesters.

1
2
3
4
5


# Make sure all courses are taken
if courses_taken != N:
 return -1

return semesters

This is a pure algorithm of topological sorting with no overhead. So the time and space complexity for this problem is that of topological sorting, O(N+|relations|) and O(N). The complete solution is given below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


from collections import deque
from typing import List

class Solution:
 def minimumSemesters(self, N: int, relations: List[List[int]]) -> int:
 # in_degree of N nodes, 1 indexed
 in_degree = [0]*(N+1)
 graph = {}
 for relation in relations:
 # Make sure we don't get KeyError
 if relation[0] not in graph:
 graph[relation[0]] = []
 graph[relation[0]].append(relation[1])
 in_degree[relation[1]] += 1

 # Collect all 0 in degree nodes
 queue = deque()
 for i in range(1, N+1):
 if in_degree[i] == 0:
 queue.append(i)

 # Topological sort
 semesters = 0
 courses_taken = 0
 while queue:
 # len(queue) courses in 1 semester
 for this_semester in range(len(queue)):
 course = queue.popleft()
 courses_taken += 1

 if course in graph:
 for neighbor in graph[course]:
 in_degree[neighbor] -= 1
 if in_degree[neighbor] == 0:
 queue.append(neighbor)
 semesters += 1

 # Make sure all courses are taken
 if courses_taken != N:
 return -1

 return semesters

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class Solution {
public:
 int minimumSemesters(int N, vector<vector<int>> &relations) {
 // in_degree of N nodes, 1 indexed
 vector<int> inDegree(N+1);
 map<int, vector<int>> graph;
 for(auto relation: relations) {
 graph[relation[0]].push_back(relation[1]);
 inDegree[relation[1]]++;
 }

 // Collect all 0 in degree nodes
 queue<int> q;
 for(int i = 1; i < N+1; i++)
 if(inDegree[i] == 0)
 q.push(i);

 // Topological sort
 int semesters = 0;
 int coursesTaken = 0;
 while(!q.empty()) {
 // q.size() courses in 1 semester
 int thisSemesterCourses = q.size();
 for(int thisSemester = 0; thisSemester < thisSemesterCourses; thisSemester++) {
 int course = q.front();
 q.pop();
 coursesTaken++;

 if(graph.find(course) != graph.end()) {
 for(auto neighbor: graph[course]) {
 inDegree[neighbor]--;
 if(inDegree[neighbor] == 0)
 q.push(neighbor);
 }
 }
 }
 semesters++;
 }

 // Make sure all courses are taken
 if(coursesTaken != N)
 return -1;

 return semesters;
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


class Solution {
 public int minimumSemesters(int N, List<List<Integer>> relations) {
 // in_degree of N nodes, 1 indexed
 int[] inDegree = new int[N+1];
 Map<Integer, List<Integer>> graph = new HashMap<>();
 for(List<Integer> relation: relations) {
 List<Integer> descendants = graph.getOrDefault(relation.get(0), new ArrayList<>());
 descendants.add(relation.get(1));
 graph.put(relation.get(0), descendants);
 inDegree[relation.get(1)]++;
 }

 // Collect all 0 in degree nodes
 Queue<Integer> queue = new LinkedList<>();
 for(int i = 1; i < N+1; i++)
 if(inDegree[i] == 0)
 queue.add(i);

 // Topological sort
 int semesters = 0;
 int coursesTaken = 0;
 while(!queue.isEmpty()) {
 // queue.size() courses in 1 semester
 int thisSemesterCourses = queue.size();
 for(int thisSemester = 0; thisSemester < thisSemesterCourses; thisSemester++) {
 int course = queue.remove();
 coursesTaken++;

 if(graph.containsKey(course)) {
 for(int neighbor: graph.get(course)) {
 inDegree[neighbor]--;
 if(inDegree[neighbor] == 0)
 queue.add(neighbor);
 }
 }
 }
 semesters++;
 }

 // Make sure all courses are taken
 if(coursesTaken != N)
 return -1;

 return semesters;
 }
}

]]>

Leetcode Problem - Sudoku Solver

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/sudoku-solver/
Difficulty: Hard
Category: Backtracking

Step 1: Grasping the Problem

We have to design a [Sudoku] solver. The problem statement defined what is Sudoku and how it is played. The given board is always a fixed size of 9x9. So, the input is always a fixed board. In that case, whatever we do with the solution (unless we are doing terribly complicated things), it will be a O(1) solution.

In spite of the time complexity is O(1), we need to think of the total time the solution might take. For example, if you do a blind brute force, the total search space for the 9x9 board is going to be (9x9)^9 = 150094635296999121 ~ 1.5x10^17. So a naive brute force solution will not be feasible.

There are some restrictions on putting a value in an index in the board. So, we do not need to put all values from 0 to 9 to check if we can solve. This is a perfect example for Backtracking algorithms where you have a number of of constraints to check and if following the constraints for a particular set of values end-up in a dead end, then go back and change some of the values to try the next space.

Wikipedia has an amazing animation to demonstrate how backtracking works with sudoku.

Step 2: Implement Board Validation Function

Before implementation of the solver itself, first we need to create a function that can be used to see if we can put a value on an index in the board. The function will take the board, a row, a col and finally a val to put into that index of the board.

1

def validate_board(self, board, row, col, val):

The function will first check if there is same value as val in the same row or column in the board. We can check this easily by looping through that row and column once at a time.

1
2
3
4
5
6
7
8
9


# Check if duplicate in row
for row_it in range(9):
 if board[row_it][col] == val:
 return False

# Check if duplicate in col
for col_it in range(9):
 if board[row][col_it] == val:
 return False

Then we will check if the same value as val also appears in the same 3x3 block. To do this, we will take the current block where row and col resides. Then we will iterate through the block and check accordingly.

1
2
3
4
5
6
7


# Check if block has duplicate
row_block = row - row%3
col_block = col - col%3
for row_it in range(3):
 for col_it in range(3):
 if board[row_block+row_it][col_block+col_it] == val:
 return False

Finally if none of these return False, we are sure that val at row, col position is a valid move. So we will return true.

1
2


# None of them return false. So satisfies
return True

Step 3: Base Conditions of Recursing Backtracking

We will start from the first element in the board. We will putting valid values in places and move forward. To do this, we will continuously put values, then increment col.

While incrementing col, we will reach at a point when col will be greater than 8 (out of the board). At that time, we reset col to zero and increment row. Finally row will go out of the board, so at that time, we will be sure that the board is solved.

1
2
3
4
5
6


if row == 9:
 # If all rows are complete, we have solved it!
 return True
if col == 9:
 # This column is complete, go to next row's first col
 return self.recursiveSolve(board, row+1, 0)

Also, if an index of the board is already filled by the problem, then we do not need to do anything at that index. So we will move forward.

1
2
3


if board[row][col] != '.':
 # This index is already filled
 return self.recursiveSolve(board, row, col+1)

Step 4: Implement Recursive Backtracking

For the backtracking, we will take numbers from 1 to 9 and fill each index of the board one by one. The problem gives us the board with characters in the indices. So we also need to put characters (or strings for python). For this, we will loop over the characters from ‘1’ to ‘9’.

1

for val in ['1', '2', '3', '4', '5', '6', '7', '8', '9']:

A more pythonic way of doing this is following.

1

for val in '123456789':

Then we will see if we can put val in the index with the help of our previously implemented function validate_board.

1

if self.validate_board(board, row, col, val):

If we can, we will put the value in the board and recursively go to the next index. And after continuously doing this, finally we will get an answer if puting val in this index results in a feasible board solution. If it is feasible, then we are done. If not, then we will have to backtrack. For backtracking we will again put a '.' in the index and continue with the next val.

1
2
3
4
5
6
7


# Put a correct value
board[row][col] = val
# Check if we can proceed to finish
if self.recursiveSolve(board, row, col+1):
 return True
# Couldn't finish, so BackTrack!
board[row][col] = '.'

Finally there will be at least one state for which, recursiveSolve will return True. For that case, we are returning True. And for the rest of the case, we will return False.

1
2


# Dead end in this path. So return false
return False

Step 5: Start the Backtracking

We will start the backtracking process from row=0 and col=0. Even if there may be already a value in that index, our backtracking function will take care of it.

1
2
3
4
5
6


def solveSudoku(self, board: [[str]]) -> None:
 """
 Modify board in-place
 """
 # Start solving from first index
 self.recursiveSolve(board, 0, 0)

This is the most known algorithm for solving Sudoku. The time complexity as already mentioned is O(1). The space is only the board size. The problem expects you to change the board in place so this solution is perfect. If you could not change the board and return a new one, you can do a slight modification to this program like copying the board before the backtracking and returning the board after the process.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def solveSudoku(self, board: [[str]]) -> [[str]]:
 """
 Modify board in-place
 """
 # Copy board
 board_copy = board.copy()
 # Start solving from first index
 self.recursiveSolve(board_copy, 0, 0)
 # Return the copy
 return board_copy

The complete solution of the problem is given by the following.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


class Solution:
 def solveSudoku(self, board: [[str]]) -> None:
 """
 Modify board in-place
 """
 # Start solving from first index
 self.recursiveSolve(board, 0, 0)


 def validate_board(self, board, row, col, val):
 # Check if duplicate in row
 for row_it in range(9):
 if board[row_it][col] == val:
 return False

 # Check if duplicate in col
 for col_it in range(9):
 if board[row][col_it] == val:
 return False

 # Check if block has duplicate
 row_block = row - row%3
 col_block = col - col%3
 for row_it in range(3):
 for col_it in range(3):
 if board[row_block+row_it][col_block+col_it] == val:
 return False
 # None of them return false. So satisfies
 return True

 def recursiveSolve(self, board, row, col):
 if row == 9:
 # If all rows are complete, we have solved it!
 return True
 if col == 9:
 # This column is complete, go to next row's first col
 return self.recursiveSolve(board, row+1, 0)
 if board[row][col] != '.':
 # This index is already filled
 return self.recursiveSolve(board, row, col+1)

 # Try putting all values in 1-9
 for val in '123456789':
 if self.validate_board(board, row, col, val):
 # Put a correct value
 board[row][col] = val
 # Check if we can proceed to finish
 if self.recursiveSolve(board, row, col+1):
 return True
 # Couldn't finish, so BackTrack!
 board[row][col] = '.'

 # Dead end in this path. So return false
 return False

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


class Solution {
public:
 void solveSudoku(vector<vector<char>> &board) {
 // Start solving from first index
 recursiveSolve(board, 0, 0);
 }

private:
 bool validateBoard(vector<vector<char>> &board, int row, int col, int val) {
 // Check if duplicate in row
 for(int rowI = 0; rowI < board.size(); rowI++)
 if(board[rowI][col] == val)
 return false;

 // Check if duplicate in col
 for(int colI = 0; colI < board.size(); colI++)
 if(board[row][colI] == val)
 return false;

 // Check if block has duplicate
 int rowBlock = row - row%3;
 int colBlock = col - col%3;
 for(int rowI = 0; rowI < 3; rowI++)
 for(int colI = 0; colI < 3; colI++)
 if(board[rowBlock+rowI][colBlock+colI] == val)
 return false;

 // None of them return false. So satisfies
 return true;
 }

 bool recursiveSolve(vector<vector<char>> &board, int row, int col) {
 // If all rows are complete, we have solve it!
 if(row == 9)
 return true;

 // This column is done, go to next row's first col
 if(col == 9)
 return recursiveSolve(board, row+1, 0);

 // This index is already filled
 if(board[row][col] != '.')
 return recursiveSolve(board, row, col+1);

 // Try putting all values in 1-9
 for(char val = '1'; val <= '9'; val++) {
 if(validateBoard(board, row, col, val)) {
 // Put a correct value
 board[row][col] = val;
 // Check if we can proceed to finish
 if(recursiveSolve(board, row, col+1))
 return true;
 // Couldn't finish, so BackTrack!
 board[row][col] = '.';
 }
 }
 // Dead end in this path, So return false
 return false;
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


class Solution {
 public void solveSudoku(char[][] board) {
 // Start solving from first index
 recursiveSolve(board, 0, 0);
 }

 private boolean validateBoard(char[][] board, int row, int col, int val) {
 // Check if duplicate in row
 for(int rowI = 0; rowI < board.length; rowI++)
 if(board[rowI][col] == val)
 return false;

 // Check if duplicate in col
 for(int colI = 0; colI < board.length; colI++)
 if(board[row][colI] == val)
 return false;

 // Check if block has duplicate
 int rowBlock = row - row%3;
 int colBlock = col - col%3;
 for(int rowI = 0; rowI < 3; rowI++)
 for(int colI = 0; colI < 3; colI++)
 if(board[rowBlock+rowI][colBlock+colI] == val)
 return false;

 // None of them return false. So satisfies
 return true;
 }

 private boolean recursiveSolve(char[][] board, int row, int col) {
 // If all rows are complete, we have solve it!
 if(row == 9)
 return true;

 // This column is done, go to next row's first col
 if(col == 9)
 return recursiveSolve(board, row+1, 0);

 // This index is already filled
 if(board[row][col] != '.')
 return recursiveSolve(board, row, col+1);

 // Try putting all values in 1-9
 for(char val = '1'; val <= '9'; val++) {
 if(validateBoard(board, row, col, val)) {
 // Put a correct value
 board[row][col] = val;
 // Check if we can proceed to finish
 if(recursiveSolve(board, row, col+1))
 return true;
 // Couldn't finish, so BackTrack!
 board[row][col] = '.';
 }
 }
 // Dead end in this path, So return false
 return false;
 }
}

]]>

Leetcode Problem - Tree Right Side

rahatzamancse@gmail.com (Rahat Zaman) — Mon, 25 May 2020 00:00:00 +0000

Problem link: https://leetcode.com/problems/binary-tree-right-side-view/
Difficulty: Medium
Category: Trees

Step 1: Grasping the Problem

This problem is a pure binary tree problem. You are given a binary tree with integer value in each node. Suppose that you are on the right side of the tree, so you need to print the values of the nodes from top to bottom which you will see.

1
2
3
4
5
6
7


 5 <------- 👁
 / \
 3 7 <----- 👁
 / \ / \
4 1 1 12 <-- 👁

result = [5, 7, 12]

A very misleading approach to solve this problem is thinking of always going to the right child and print them out. This is completely wrong and the problem requires you to visit all nodes to solve. See some examples below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25



 Tree 1

 5 <------- 👁
 / \
 3 7 <----- 👁
 /
 4 <-------------- 👁
 /
 9 <---------------- 👁

result = [5, 7, 4, 9]


 Tree 2

 5 <------- 👁
 / \
 3 7 <----- 👁
 / \
 4 6 <--------- 👁
 / /
 9 2 <----------- 👁

result = [5, 7, 6, 2]

For visiting all the nodes in the tree, we need a tree traversal algorithm. We are at the right side of the tree and we need to print from top to bottom. That means we must do two things while traversing the tree.

We must visit the parent before visiting it’s children. Because we need to print from top to bottom. This gives us an intuition of using a pre-order traversal.
We must visit the right child of two siblings at the same level. Because we need to see the rightmost node first. This gives us an intuition of traversing the right child first in the pre-order traversal.

So we have came up with a pre-order traversal visiting the right child first. But how are we going to make sure that the node is shadowed by another node at the name level (and at it’s right side)? To do this, we can use a level variable and check if any node has already been visited at that height. If visited, we will continue traversing the nodes children without using itself for the answer. But a more elegant solution is taking parts of the left that is after our stored node. It will be cleared more in the implementation step.

Step 2: Recursing pre-order traversal

A recursive pre-order traversal can be thought dividing into subproblems and solving them recursively. First we see if the current node is None of not. If current node is None, we will return an empty result List.

1
2


if not root:
 return []

This also gives up guarantee for accessing the nodes children. Now that we can are sure that current node is not None, we go to our right child (Remember, we must visit the right child first) and do this same thing. “Doing the same thing for another node” is similar to calling the same function (recursively) with different parameters.

1

right = self.rightSideView(root.right)

Finally we do the same thing for the left child.

1

left = self.rightSideView(root.left)

Step 3: Creating Visited Nodes List

At this point, the recursive calls have finished and we will have the final result from both the right and left children. We just need to aggregate both results into one final list.

Let us see the example again in the below tree.

 5(1)
/ \
3(3) 7(2)
/ \
(6)4 6(4)
/ /
(7)9 2(5)

This is the breakdown of each recursive call and the list we want to return from those calls.

Calls that needs to return	Final Return	Root	Right	Left
call 1	[5, 7, 6, 2]	[5]	[7 ]	[6, 2]
call 2	[7 ]	[7]	[ ]	[ ]
call 3	[6, 2 ]	[ ]	[6, 2]	[ ]
call 4	[6, 2 ]	[6]	[ ]	[ ]
call 5	[2 ]	[2]	[ ]	[ ]
call 6	[ ]	[ ]	[ ]	[ ]
call 7	[ ]	[ ]	[ ]	[ ]

It is clear the every time we are returning the root itself first. And after that, we are also returning the result of right calls. So clearly for these two, the code will be something like this:

1

return [root.val] + right + # and the rest

We are wrapping the root.val so that python can concatenate the list for us. You could also do [root.val, *right] if you want, the result is the same.

Finally, we need to add the rest nodes (coming from the left subtrees). We can clearly tell that it will be a suffix of the left child’s recursive call’s return list. We know that if we have found n children from the right recursive call, we do not need the first n children from the left call (because they are shadowed by the right nodes). So we can remove first len(right) nodes from the left list and concatenate that with our result.

1

return [root.val] + right + left[len(right):]

This is it. The complete program just loops through the nodes recursively and at the end concatenates creating the list. The concatenation of python lists takes amortized O(1) time. So the complete time complexity is O(n) where there are n nodes in the tree. The space complexity is also O(n) in both average and worst case. The program is very small in python and given below.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# Definition for a binary tree node.
class TreeNode:
 def __init__(self, val=0, left=None, right=None):
 self.val = val
 self.left = left
 self.right = right

class Solution:
 def rightSideView(self, root: TreeNode) -> [int]:
 if not root:
 return []
 right = self.rightSideView(root.right)
 left = self.rightSideView(root.left)
 return [root.val] + right + left[len(right):]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 * int val;
 * TreeNode *left;
 * TreeNode *right;
 * TreeNode() : val(0), left(nullptr), right(nullptr) {}
 * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
 vector<int> rightSideView(TreeNode* root) {
 if(root == nullptr)
 return {};
 vector<int> right = rightSideView(root->right);
 vector<int> left = rightSideView(root->left);
 vector<int> result;
 result.push_back(root->val);
 result.insert(result.end(), right.begin(), right.end());
 for(int level = right.size(); level < left.size(); level++)
 result.push_back(left[level]);
 return result;
 }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
 public List<Integer> rightSideView(TreeNode root) {
 if(root == null)
 return new ArrayList<Integer>();
 List<Integer> right = rightSideView(root.right);
 List<Integer> left = rightSideView(root.left);
 List<Integer> result = new ArrayList<Integer>();
 result.add(root.val);
 result.addAll(right);
 for(int level = right.size(); level < left.size(); level++)
 result.add(left.get(level));
 return result;
 }
}

]]>

Leetcode-Explained on Rahat Zaman

Leetcode Problem - Alien Dictionary

Step 1: Grasping the Problem

Step 2: Build the graph

Step 3: Build an in_degree dict for topological sorting

Step 4: Topological Sorting

Leetcode Problem - All Nodes Distance K in Binary Tree

Step 1: Grasping the Problem

Step 2: Build a graph

Step 3: BFS

Step 4: Handle corner cases

Step 4: Optimize

Leetcode Problem - Continuous Median

Step 1: Grasping the Problem

Step 2: Building data structures concept with heaps

Step 3: addNum(int) implementation

Step 4: findMedian() implementation

Leetcode Problem - Four Sum

Step 1: Grasping the Problem

Step 2: Initialization and sorting the array

Step 2: first_index loop

Step 3: Skip duplicate first element

Step 4: second_index loop

Step 5: 2-SUM

Step 5: Return result

Step 6: Handle Corner Cases

Leetcode Problem - Itinerary Reconstruction

Step 1: Grasping the Problem

Step 2: Reverse sort the tickets

Step 2: Build the Graph

Step 3: Eulerian Path Construction

Step 4: Reverse and Return route

Leetcode Problem - Jump Game II

Step 1: Grasping the Problem

Step 2: Keep track of farthest stair possible

Step 3: Keep track of last jump end

Step 4: Return the total jumps

Leetcode Problem - Longest Substring Without Duplication

Step 1: Grasping the Problem

Step 2: Sliding Window Initialization

Step 3: Loop for the window

Step 4: Expand the window

Step 5: Shrink the window

Step 6: Return longest

Leetcode Problem - Lowest Common Ancestor

Step 1: Grasping the problem

Step 2: Add parent attribute

Step 3: Store the path of node1

Step 4: Search for first existent node

Leetcode Problem - Maximum Profit with K Transactions

Step 1: Grasping the Problem

Step 2: Create a DP table

Step 3: Fill up DP table

Step 4: Handling corner cases

Step 5: Returning the result

Leetcode Problem - Minimum Window Substring

Step 1: Grasping the Problem

Step 2: Sliding Window Initialization

Step 3: Expand the window

Step 4: Shrinking ability check

Step 5: Get Minimum Substring

Step 6: Shrink the Window

Step 7: Return Smallest Substring

Leetcode Problem - Monotonic Array

Step 1: Grasping the Problem

Step 2: Building data structures concept with heaps

Step 3: addNum(int) implementation

Step 4: findMedian() implementation

Leetcode Problem - Parallel Courses

Step 1: Grasping the Problem

Step 2: Build the Graph

Step 3: Topological Sorting Initialization

Step 4: Topological Sorting

Leetcode Problem - Sudoku Solver

Step 1: Grasping the Problem

Step 2: Implement Board Validation Function

Step 3: Base Conditions of Recursing Backtracking

Step 4: Implement Recursive Backtracking

Step 5: Start the Backtracking

Leetcode Problem - Tree Right Side

Step 3: Build an `in_degree` dict for topological sorting

Step 3: `addNum(int)` implementation

Step 4: `findMedian()` implementation

Step 4: Reverse and Return `route`

Step 6: Return `longest`

Step 3: Store the path of `node1`

Step 3: `addNum(int)` implementation

Step 4: `findMedian()` implementation