Improved tasks 198-208

Author: javadev

src/main/python/g0101_0200/s0198_house_robber/readme.md

@@ -31,4 +31,40 @@ Given an integer array `nums` representing the amount of money of each house, re
 **Constraints:**
 
 *   `1 <= nums.length <= 100`
-*   `0 <= nums[i] <= 400`
+*   `0 <= nums[i] <= 400`
+
+To solve the House Robber problem, we can utilize dynamic programming to find the maximum amount of money we can rob without alerting the police. Here's how we can approach this problem:
+
+1. **Initialize Variables**:
+   - Initialize two variables, `prev_max` and `curr_max`, to keep track of the maximum amount of money robbed from previous houses and the current house, respectively.
+
+2. **Iterate Through Houses**:
+   - Iterate through the array of house values `nums`.
+   
+3. **Calculate Maximum Amount of Money Robbed**:
+   - For each house, update `curr_max` to the maximum value between the sum of the value of the current house and `prev_max`, and `prev_max`.
+   
+4. **Return Result**:
+   - After iterating through all houses, return `curr_max`, which represents the maximum amount of money that can be robbed without alerting the police.
+
+Let's implement this approach:
+
+```python
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        if not nums:
+            return 0
+        if len(nums) == 1:
+            return nums[0]
+        
+        prev_max = curr_max = 0
+        
+        for num in nums:
+            temp = curr_max
+            curr_max = max(prev_max + num, curr_max)
+            prev_max = temp
+        
+        return curr_max
+```
+
+This solution ensures that we calculate the maximum amount of money that can be robbed without alerting the police in linear time complexity O(n) and constant space complexity O(1), meeting the problem constraints.

src/main/python/g0101_0200/s0200_number_of_islands/readme.md

@@ -37,4 +37,53 @@ An **island** is surrounded by water and is formed by connecting adjacent lands
 *   `m == grid.length`
 *   `n == grid[i].length`
 *   `1 <= m, n <= 300`
-*   `grid[i][j]` is `'0'` or `'1'`.
+*   `grid[i][j]` is `'0'` or `'1'`.
+
+To solve the Number of Islands problem, we can utilize Depth-First Search (DFS) to traverse the grid and identify the islands. Here's a step-by-step approach to solve this problem:
+
+1. **Define DFS Function**:
+   - Define a DFS function to traverse the grid recursively.
+   - This function will mark visited cells as `'0'` to avoid revisiting them.
+   - It will explore adjacent cells (up, down, left, right) and continue DFS traversal if the adjacent cell is land (`'1'`).
+
+2. **Iterate Through Grid**:
+   - Iterate through each cell in the grid.
+   
+3. **Count Islands**:
+   - For each cell with land (`'1'`), call the DFS function to explore the island.
+   - Increment the count of islands by 1 after each DFS traversal.
+
+4. **Return Count**:
+   - After traversing the entire grid, return the count of islands.
+
+Let's implement this approach:
+
+```python
+class Solution:
+    def numIslands(self, grid: List[List[str]]) -> int:
+        def dfs(grid, i, j):
+            if i < 0 or i >= len(grid) or j < 0 or j >= len(grid[0]) or grid[i][j] == '0':
+                return
+            grid[i][j] = '0'  # Mark the current cell as visited
+            # Explore adjacent cells
+            dfs(grid, i+1, j)
+            dfs(grid, i-1, j)
+            dfs(grid, i, j+1)
+            dfs(grid, i, j-1)
+        
+        if not grid:
+            return 0
+        
+        num_islands = 0
+        rows, cols = len(grid), len(grid[0])
+        
+        for i in range(rows):
+            for j in range(cols):
+                if grid[i][j] == '1':
+                    num_islands += 1
+                    dfs(grid, i, j)
+        
+        return num_islands
+```
+
+This solution efficiently counts the number of islands in the given grid by performing DFS traversal on each unvisited land cell. It has a time complexity of O(M * N), where M is the number of rows and N is the number of columns in the grid.

src/main/python/g0201_0300/s0206_reverse_linked_list/readme.md

@@ -31,4 +31,48 @@ Given the `head` of a singly linked list, reverse the list, and return _the reve
 *   The number of nodes in the list is the range `[0, 5000]`.
 *   `-5000 <= Node.val <= 5000`
 
-**Follow up:** A linked list can be reversed either iteratively or recursively. Could you implement both?
+**Follow up:** A linked list can be reversed either iteratively or recursively. Could you implement both?
+
+To solve the Reverse Linked List problem, we can either use an iterative approach or a recursive approach. Here are the steps for both approaches:
+
+### Iterative Approach:
+1. **Initialize Pointers**: Initialize three pointers, `prev`, `curr`, and `next`.
+2. **Iterate Through List**: Iterate through the list until `curr` is not `None`.
+   - Update `next` to `curr.next`.
+   - Reverse the `curr` node's pointer to point to `prev` instead of `next`.
+   - Move `prev` to `curr` and `curr` to `next`.
+3. **Return Head**: Return `prev` as the new head of the reversed list.
+
+### Recursive Approach:
+1. **Define Recursive Function**: Define a recursive function that takes a node as input.
+2. **Base Case**: If the input node or its next node is `None`, return the node itself.
+3. **Recursive Call**: Recursively call the function on the next node.
+4. **Reverse Pointers**: Reverse the pointers of the current node and its next node.
+5. **Return Head**: Return the new head of the reversed list.
+
+Let's implement both approaches:
+
+```python
+class Solution:
+    def reverseListIterative(self, head: ListNode) -> ListNode:
+        prev, curr = None, head
+        while curr:
+            next_node = curr.next
+            curr.next = prev
+            prev = curr
+            curr = next_node
+        return prev
+    
+    def reverseListRecursive(self, head: ListNode) -> ListNode:
+        def reverse(node):
+            if not node or not node.next:
+                return node
+            new_head = reverse(node.next)
+            node.next.next = node
+            node.next = None
+            return new_head
+        
+        return reverse(head)
+```
+
+These solutions will efficiently reverse the linked list either iteratively or recursively, meeting the problem constraints. The time complexity for both approaches is O(n), where n is the number of nodes in the linked list.

src/main/python/g0201_0300/s0207_course_schedule/readme.md

@@ -30,4 +30,81 @@ Return `true` if you can finish all courses. Otherwise, return `false`.
 *   `0 <= prerequisites.length <= 5000`
 *   `prerequisites[i].length == 2`
 *   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < numCourses</code>
-*   All the pairs prerequisites[i] are **unique**.
+*   All the pairs prerequisites[i] are **unique**.
+
+To solve the Course Schedule problem, we can use a graph-based approach with topological sorting. We'll represent the courses and their prerequisites as a directed graph, and then perform a topological sort to determine if there exists any cycle in the graph. If there is a cycle, it means there is a dependency loop, and it won't be possible to complete all courses.
+
+### Steps:
+
+1. **Build the Graph**:
+   - Create an adjacency list to represent the directed graph.
+   - Iterate through the `prerequisites` array and add edges to the graph.
+
+2. **Perform Topological Sorting**:
+   - Implement a function for topological sorting, which can be done using Depth-First Search (DFS) or Breadth-First Search (BFS).
+   - In each approach, keep track of the visited nodes and the current path.
+   - If during DFS, we encounter a node that is already in the current path, it indicates a cycle, and we return False.
+   - If the sorting completes without finding a cycle, return True.
+
+3. **Check for Cycle**:
+   - If any node has a cycle in its path, return False.
+
+4. **Return Result**:
+   - If no cycle is found, return True, indicating it's possible to finish all courses.
+
+### Implementation:
+
+```python
+from collections import defaultdict
+
+class Solution:
+    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
+        # Build the graph
+        graph = defaultdict(list)
+        for course, prereq in prerequisites:
+            graph[course].append(prereq)
+        
+        # Function for topological sorting using DFS
+        def dfs(course, visited, path):
+            if course in path:
+                return False  # Cycle detected
+            if visited[course]:
+                return True  # Already visited
+            visited[course] = True
+            path.add(course)
+            for neighbor in graph[course]:
+                if not dfs(neighbor, visited, path):
+                    return False
+            path.remove(course)
+            return True
+        
+        # Perform topological sorting for each course
+        for course in range(numCourses):
+            visited = [False] * numCourses
+            path = set()
+            if not dfs(course, visited, path):
+                return False
+        
+        return True
+```
+
+### Explanation:
+
+1. **Build the Graph**:
+   - We use a defaultdict to create an adjacency list representation of the directed graph.
+   - We iterate through the `prerequisites` array and add edges to the graph.
+
+2. **Perform Topological Sorting**:
+   - We implement a function `dfs` for topological sorting using Depth-First Search (DFS).
+   - We keep track of visited nodes and the current path to detect cycles.
+   - If we encounter a node that is already in the current path, it indicates a cycle, and we return False.
+   - Otherwise, if DFS completes without finding a cycle, we return True.
+
+3. **Check for Cycle**:
+   - We iterate through each course and perform topological sorting.
+   - If any node has a cycle in its path, we return False.
+
+4. **Return Result**:
+   - If no cycle is found, we return True, indicating it's possible to finish all courses.
+
+This solution has a time complexity of O(V + E), where V is the number of courses and E is the number of prerequisites. The space complexity is O(V + E) for storing the graph.

src/main/python/g0201_0300/s0208_implement_trie_prefix_tree/readme.md

@@ -33,4 +33,82 @@ Implement the Trie class:
 
 *   `1 <= word.length, prefix.length <= 2000`
 *   `word` and `prefix` consist only of lowercase English letters.
-*   At most <code>3 * 10<sup>4</sup></code> calls **in total** will be made to `insert`, `search`, and `startsWith`.
+*   At most <code>3 * 10<sup>4</sup></code> calls **in total** will be made to `insert`, `search`, and `startsWith`.
+
+To solve the task, here are the steps for implementing the Trie (Prefix Tree) problem:
+
+1. **Define the TrieNode Class**:
+   - Define a class named `TrieNode` to represent each node in the trie.
+   - Each node will have a dictionary to store child nodes, indicating possible characters that can follow the current node.
+   - Additionally, each node will have a boolean flag to mark whether it represents the end of a word.
+
+2. **Initialize the Trie Class**:
+   - Implement the `__init__` method for the Trie class to initialize an empty trie with a root node.
+
+3. **Implement the Insert Method**:
+   - Implement the `insert` method to insert a word into the trie.
+   - Start from the root node and iterate through each character in the word.
+   - Check if the character exists as a child of the current node. If not, create a new node for it.
+   - Move to the child node and repeat the process for the next character.
+   - After processing all characters, mark the last node as the end of the word.
+
+4. **Implement the Search Method**:
+   - Implement the `search` method to check if a word exists in the trie.
+   - Start from the root node and iterate through each character in the word.
+   - If at any point, a character is not found as a child of the current node, return False.
+   - If all characters are found and the last node is marked as the end of a word, return True.
+
+5. **Implement the StartsWith Method**:
+   - Implement the `startsWith` method to check if there is any word in the trie that starts with a given prefix.
+   - Follow a similar process as the search method, but return True as soon as all characters of the prefix are found, regardless of whether it forms a complete word.
+
+6. **Return Results**:
+   - After implementing all methods, create an instance of the Trie class and perform the required operations according to the given input.
+
+Here's a Python implementation:
+
+```python
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+        self.is_end_of_word = False
+
+class Trie:
+    def __init__(self):
+        self.root = TrieNode()
+
+    def insert(self, word: str) -> None:
+        node = self.root
+        for char in word:
+            if char not in node.children:
+                node.children[char] = TrieNode()
+            node = node.children[char]
+        node.is_end_of_word = True
+
+    def search(self, word: str) -> bool:
+        node = self.root
+        for char in word:
+            if char not in node.children:
+                return False
+            node = node.children[char]
+        return node.is_end_of_word
+
+    def startsWith(self, prefix: str) -> bool:
+        node = self.root
+        for char in prefix:
+            if char not in node.children:
+                return False
+            node = node.children[char]
+        return True
+
+# Example Usage
+trie = Trie()
+trie.insert("apple")
+print(trie.search("apple")) # Output: True
+print(trie.search("app")) # Output: False
+print(trie.startsWith("app")) # Output: True
+trie.insert("app")
+print(trie.search("app")) # Output: True
+``` 
+
+This solution efficiently implements the Trie data structure and satisfies the requirements of the problem.