Updated readme

Author: javadev

README.md

@@ -36,24 +36,38 @@ Given an integer array `nums` representing the amount of money of each house, re
 *   `1 <= nums.length <= 100`
 *   `0 <= nums[i] <= 400`
 
-## Solution
+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 len(nums) == 0:
+        if not nums:
             return 0
         if len(nums) == 1:
             return nums[0]
-        if len(nums) == 2:
-            return max(nums[0], nums[1])
 
-        profit = [0] * len(nums)
-        profit[0] = nums[0]
-        profit[1] = max(nums[1], nums[0])
+        prev_max = curr_max = 0
 
-        for i in range(2, len(nums)):
-            profit[i] = max(profit[i - 1], nums[i] + profit[i - 2])
+        for num in nums:
+            temp = curr_max
+            curr_max = max(prev_max + num, curr_max)
+            prev_max = temp
 
-        return profit[len(nums) - 1]
-```
+        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/s0198_house_robber/readme.md

@@ -42,26 +42,51 @@ An **island** is surrounded by water and is formed by connecting adjacent lands
 *   `1 <= m, n <= 300`
 *   `grid[i][j]` is `'0'` or `'1'`.
 
-## Solution
+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, x, y):
-            if x < 0 or x >= len(grid) or y < 0 or y >= len(grid[0]) or grid[x][y] != '1':
+        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[x][y] = 'x'
-            dfs(grid, x + 1, y)
-            dfs(grid, x - 1, y)
-            dfs(grid, x, y + 1)
-            dfs(grid, x, y - 1)
+            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)
 
-        islands = 0
-        if grid and grid[0]:
-            for i in range(len(grid)):
-                for j in range(len(grid[0])):
-                    if grid[i][j] == '1':
-                        dfs(grid, i, j)
-                        islands += 1
-        return islands
-```
+        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/g0101_0200/s0200_number_of_islands/readme.md

@@ -36,22 +36,46 @@ Given the `head` of a singly linked list, reverse the list, and return _the reve
 
 **Follow up:** A linked list can be reversed either iteratively or recursively. Could you implement both?
 
-## Solution
+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
-# Definition for singly-linked list.
-# class ListNode:
-#     def __init__(self, val=0, next=None):
-#         self.val = val
-#         self.next = next
 class Solution:
-    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
-        prev = None
-        curr = head
-        while curr is not None:
+    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/s0206_reverse_linked_list/readme.md

@@ -35,35 +35,79 @@ Return `true` if you can finish all courses. Otherwise, return `false`.
 *   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < numCourses</code>
 *   All the pairs prerequisites[i] are **unique**.
 
-## Solution
+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
-class Solution:
-    WHITE = 0
-    GRAY = 1
-    BLACK = 2
+from collections import defaultdict
 
+class Solution:
     def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
-        adj = [[] for _ in range(numCourses)]
-        for pre in prerequisites:
-            adj[pre[1]].append(pre[0])
+        # Build the graph
+        graph = defaultdict(list)
+        for course, prereq in prerequisites:
+            graph[course].append(prereq)
 
-        colors = [self.WHITE] * numCourses
+        # 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
 
-        for i in range(numCourses):
-            if colors[i] == self.WHITE and adj[i] and self.hasCycle(adj, i, colors):
+        # 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
+```
 
-    def hasCycle(self, adj: List[List[int]], node: int, colors: List[int]) -> bool:
-        colors[node] = self.GRAY
-        
-        for nei in adj[node]:
-            if colors[nei] == self.GRAY:
-                return True
-            if colors[nei] == self.WHITE and self.hasCycle(adj, nei, colors):
-                return True
-        
-        colors[node] = self.BLACK
-        return False
-```
+### 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.