add more solutions

Author: ashishps1

python/best_time_to_buy_and_sell_stock_3.md

@@ -0,0 +1,93 @@
+# 123. [Best Time to Buy and Sell Stock III](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/)
+
+## Approach 1: Dynamic Programming with State Variables
+
+### Solution
+python
+```python
+# Time Complexity: O(n)
+# Space Complexity: O(1)
+
+class Solution:
+    def maxProfit(self, prices):
+        hold1 = float('-inf')
+        hold2 = float('-inf')
+        release1 = 0
+        release2 = 0
+
+        for price in prices:
+            # First transaction
+            release1 = max(release1, hold1 + price)  # Sell stock held by hold1
+            hold1 = max(hold1, -price)               # Buy stock
+
+            # Second transaction
+            release2 = max(release2, hold2 + price)  # Sell stock held by hold2
+            hold2 = max(hold2, release1 - price)     # Buy stock after first sell
+            
+        return release2  # Maximum profit from two transactions
+```
+
+## Approach 2: Dynamic Programming with 2D DP Array
+
+### Solution
+python
+```python
+# Time Complexity: O(n)
+# Space Complexity: O(n)
+
+class Solution:
+    def maxProfit(self, prices):
+        if not prices or len(prices) <= 1:
+            return 0
+
+        k = 2  # Maximum number of transactions
+        n = len(prices)
+        # dp[i][j] = maximum profit using at most i transactions by time j
+        dp = [[0] * n for _ in range(k + 1)]
+
+        for i in range(1, k + 1):
+            maxDiff = -prices[0]
+            for j in range(1, n):
+                # Previous maximum profit obtained with `i` transactions or profit after selling stock by day `j`
+                dp[i][j] = max(dp[i][j - 1], prices[j] + maxDiff)
+                # Max profit after buying stock on day `j`
+                maxDiff = max(maxDiff, dp[i - 1][j] - prices[j])
+
+        return dp[k][n - 1]  # Maximum profit with at most `k` transactions at the last day
+```
+
+## Approach 3: Forward and Backward Pass
+
+### Solution
+python
+```python
+# Time Complexity: O(n)
+# Space Complexity: O(n)
+
+class Solution:
+    def maxProfit(self, prices):
+        n = len(prices)
+        if n <= 1:
+            return 0
+
+        leftProfits = [0] * n
+        rightProfits = [0] * n
+
+        minPrice = prices[0]
+        for i in range(1, n):
+            minPrice = min(minPrice, prices[i])
+            leftProfits[i] = max(leftProfits[i - 1], prices[i] - minPrice)
+
+        maxPrice = prices[n - 1]
+        for i in range(n - 2, -1, -1):
+            maxPrice = max(maxPrice, prices[i])
+            rightProfits[i] = max(rightProfits[i + 1], maxPrice - prices[i])
+
+        maxProfit = 0
+        for i in range(n):
+            maxProfit = max(maxProfit, leftProfits[i] + rightProfits[i])
+
+        return maxProfit
+```
+
+

python/clone_graph.md

@@ -0,0 +1,38 @@
+# 133. [Clone Graph](https://leetcode.com/problems/clone-graph/)
+
+## Approach: Depth-First Search (DFS) with HashMap
+
+### Solution
+```python
+# Time Complexity: O(n), where n is the number of nodes in the graph
+# Space Complexity: O(n), for the HashMap and recursion stack
+from collections import defaultdict
+
+class Node:
+    def __init__(self, val=0, neighbors=None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+
+class Solution:
+    def __init__(self):
+        self.map = {}
+
+    def cloneGraph(self, node):
+        if node is None:
+            return None
+
+        # If the node is already cloned, return the cloned node
+        if node in self.map:
+            return self.map[node]
+
+        # Clone the current node
+        clone = Node(node.val)
+        self.map[node] = clone
+
+        # Recursively clone all neighbors
+        for neighbor in node.neighbors:
+            clone.neighbors.append(self.cloneGraph(neighbor))
+
+        return clone
+```
+

python/design_browser_history.md

@@ -0,0 +1,47 @@
+# 1472. [Design Browser History](https://leetcode.com/problems/design-browser-history/)
+
+## Approach: Doubly Linked List
+
+### Solution
+python
+```python
+# Time Complexity:
+#   - visit: O(1)
+#   - back: O(steps)
+#   - forward: O(steps)
+# Space Complexity: O(n), where n is the number of visited pages
+class Node:
+    def __init__(self, url: str):
+        self.url = url
+        self.prev = None
+        self.next = None
+
+class BrowserHistory:
+    def __init__(self, homepage: str):
+        self.current = Node(homepage)
+
+    def visit(self, url: str) -> None:
+        new_node = Node(url)
+        self.current.next = new_node
+        new_node.prev = self.current
+        self.current = new_node  # Move to the newly visited page
+
+    def back(self, steps: int) -> str:
+        while steps > 0 and self.current.prev is not None:
+            self.current = self.current.prev
+            steps -= 1
+        return self.current.url
+
+    def forward(self, steps: int) -> str:
+        while steps > 0 and self.current.next is not None:
+            self.current = self.current.next
+            steps -= 1
+        return self.current.url
+
+# Example usage:
+# obj = BrowserHistory(homepage)
+# obj.visit(url)
+# param_2 = obj.back(steps)
+# param_3 = obj.forward(steps)
+```
+

python/distinct_subsequences.md

@@ -0,0 +1,98 @@
+# 115. [Distinct Subsequences](https://leetcode.com/problems/distinct-subsequences/)
+
+## Approach 1: Recursion with Memoization
+
+### Solution
+python
+```python
+# Time Complexity: O(n * m)
+# Space Complexity: O(n * m)
+class Solution:
+    def numDistinct(self, s: str, t: str) -> int:
+        # Memoization table
+        memo = [[-1 for _ in range(len(t))] for _ in range(len(s))]
+        return self.numDistinctHelper(s, t, 0, 0, memo)
+    
+    def numDistinctHelper(self, s: str, t: str, sIndex: int, tIndex: int, memo: list) -> int:
+        # If t is exhausted, one subsequence is found
+        if tIndex == len(t):
+            return 1
+        # If s is exhausted first, no subsequence can be formed
+        if sIndex == len(s):
+            return 0
+        # Check memoization table
+        if memo[sIndex][tIndex] != -1:
+            return memo[sIndex][tIndex]
+        
+        # If characters match, both decisions can be made
+        if s[sIndex] == t[tIndex]:
+            memo[sIndex][tIndex] = self.numDistinctHelper(s, t, sIndex + 1, tIndex + 1, memo) + \
+                                   self.numDistinctHelper(s, t, sIndex + 1, tIndex, memo)
+        else:
+            # If characters don't match, skip the current character in s
+            memo[sIndex][tIndex] = self.numDistinctHelper(s, t, sIndex + 1, tIndex, memo)
+        
+        return memo[sIndex][tIndex]
+```
+
+## Approach 2: Dynamic Programming
+
+### Solution
+python
+```python
+# Time Complexity: O(n * m)
+# Space Complexity: O(n * m)
+class Solution:
+    def numDistinct(self, s: str, t: str) -> int:
+        # DP table
+        dp = [[0] * (len(t) + 1) for _ in range(len(s) + 1)]
+
+        # Base case: empty t can be formed by all possible substrings of s
+        for i in range(len(s) + 1):
+            dp[i][len(t)] = 1
+
+        # Fill the table in reverse order
+        for i in range(len(s) - 1, -1, -1):
+            for j in range(len(t) - 1, -1, -1):
+                if s[i] == t[j]:
+                    # Both using the character and ignoring it
+                    dp[i][j] = dp[i + 1][j + 1] + dp[i + 1][j]
+                else:
+                    # Ignore the character in s
+                    dp[i][j] = dp[i + 1][j]
+
+        # Result is the number of ways to form t[0...m] from s[0...n]
+        return dp[0][0]
+```
+
+## Approach 3: Dynamic Programming with Space Optimization
+
+### Solution
+python
+```python
+# Time Complexity: O(n * m)
+# Space Complexity: O(m)
+class Solution:
+    def numDistinct(self, s: str, t: str) -> int:
+        # Previous and current row for space optimization
+        prev = [0] * (len(t) + 1)
+        curr = [0] * (len(t) + 1)
+        
+        # Base case: empty t can be formed by all possible substrings of s
+        for i in range(len(s) + 1):
+            prev[len(t)] = 1
+        
+        # Fill the table in reverse order
+        for i in range(len(s) - 1, -1, -1):
+            for j in range(len(t) - 1, -1, -1):
+                if s[i] == t[j]:
+                    curr[j] = prev[j + 1] + prev[j]
+                else:
+                    curr[j] = prev[j]
+            # Move current row to previous for next iteration
+            prev = curr[:]
+        
+        # Result is the number of ways to form t[0...m] from s[0...n]
+        return prev[0]
+```
+

python/house_robber.md

@@ -0,0 +1,100 @@
+# 198. [House Robber](https://leetcode.com/problems/house-robber/)
+
+## Approach 1: Recursive Solution
+
+### Solution
+```python
+# Time Complexity: O(2^n)
+# Space Complexity: O(n)
+class Solution:
+    def rob(self, nums):
+        return self.robFrom(0, nums)
+
+    def robFrom(self, index, nums):
+        # Base case: If index is out of bounds, return 0
+        if index >= len(nums):
+            return 0
+
+        # Either rob this house and skip one, or skip it
+        robCurrent = nums[index] + self.robFrom(index + 2, nums)
+        skipCurrent = self.robFrom(index + 1, nums)
+
+        # Return the maximum of both choices
+        return max(robCurrent, skipCurrent)
+```
+
+## Approach 2: Recursion with Memoization
+
+### Solution
+```python
+# Time Complexity: O(n)
+# Space Complexity: O(n)
+class Solution:
+    def rob(self, nums):
+        return self.robFrom(0, nums, {})
+
+    def robFrom(self, index, nums, memo):
+        # Base case: If index is out of bounds, return 0
+        if index >= len(nums):
+            return 0
+
+        # Check memoization table
+        if index in memo:
+            return memo[index]
+
+        # Either rob this house and skip one, or skip it
+        robCurrent = nums[index] + self.robFrom(index + 2, nums, memo)
+        skipCurrent = self.robFrom(index + 1, nums, memo)
+
+        # Memoize the result
+        result = max(robCurrent, skipCurrent)
+        memo[index] = result
+
+        return result
+```
+
+## Approach 3: Dynamic Programming (Bottom Up)
+
+### Solution
+```python
+# Time Complexity: O(n)
+# Space Complexity: O(n)
+class Solution:
+    def rob(self, nums):
+        if not nums:
+            return 0
+
+        dp = [0] * (len(nums) + 1)
+        dp[0] = 0
+        dp[1] = nums[0]
+
+        # Build the dp array
+        for i in range(2, len(nums) + 1):
+            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i - 1])
+
+        return dp[len(nums)]
+```
+
+## Approach 4: Optimized Dynamic Programming (Constant Space)
+
+### Solution
+```python
+# Time Complexity: O(n)
+# Space Complexity: O(1)
+class Solution:
+    def rob(self, nums):
+        if not nums:
+            return 0
+
+        prev1 = 0  # max money can rob up to the previous house
+        prev2 = 0  # max money can rob up to two houses before
+
+        # Iterate through each house
+        for num in nums:
+            temp = prev1
+            prev1 = max(prev2 + num, prev1)
+            prev2 = temp
+
+        return prev1
+```
+