add more solutions

Author: ashishps1

c#/best_time_to_buy_and_sell_stock_3.md

@@ -1,2 +1,97 @@
-# best_time_to_buy_and_sell_stock_3.md
+# 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
+csharp
+```csharp
+// Time Complexity: O(n)
+// Space Complexity: O(1)
+public class Solution {
+    public int MaxProfit(int[] prices) {
+        int hold1 = int.MinValue, hold2 = int.MinValue;
+        int release1 = 0, release2 = 0;
+
+        foreach (int price in prices) {
+            // First transaction
+            release1 = Math.Max(release1, hold1 + price);  // Sell stock held by hold1
+            hold1 = Math.Max(hold1, -price);               // Buy stock
+
+            // Second transaction
+            release2 = Math.Max(release2, hold2 + price);  // Sell stock held by hold2
+            hold2 = Math.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
+csharp
+```csharp
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+public class Solution {
+    public int MaxProfit(int[] prices) {
+        if (prices == null || prices.Length <= 1) return 0;
+
+        int k = 2; // Maximum number of transactions
+        int n = prices.Length;
+        // dp[i][j] = maximum profit using at most i transactions by time j
+        int[,] dp = new int[k + 1, n];
+
+        for (int i = 1; i <= k; i++) {
+            int maxDiff = -prices[0];
+            for (int j = 1; j < n; j++) {
+                // Previous maximum profit obtained with `i` transactions or profit after selling stock by day `j`
+                dp[i, j] = Math.Max(dp[i, j - 1], prices[j] + maxDiff);
+                // Max profit after buying stock on day `j`
+                maxDiff = Math.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
+csharp
+```csharp
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+public class Solution {
+    public int MaxProfit(int[] prices) {
+        int n = prices.Length;
+        if (n <= 1) return 0;
+
+        int[] leftProfits = new int[n];
+        int[] rightProfits = new int[n];
+
+        int minPrice = prices[0];
+        for (int i = 1; i < n; i++) {
+            minPrice = Math.Min(minPrice, prices[i]);
+            leftProfits[i] = Math.Max(leftProfits[i - 1], prices[i] - minPrice);
+        }
+
+        int maxPrice = prices[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            maxPrice = Math.Max(maxPrice, prices[i]);
+            rightProfits[i] = Math.Max(rightProfits[i + 1], maxPrice - prices[i]);
+        }
+
+        int maxProfit = 0;
+        for (int i = 0; i < n; i++) {
+            maxProfit = Math.Max(maxProfit, leftProfits[i] + rightProfits[i]);
+        }
+
+        return maxProfit;
+    }
+}
+```
+
 

c#/clone_graph.md

@@ -1,2 +1,55 @@
-# clone_graph.md
+# 133. [Clone Graph](https://leetcode.com/problems/clone-graph/)
+
+## Approach: Depth-First Search (DFS) with Dictionary
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n), where n is the number of nodes in the graph
+// Space Complexity: O(n), for the Dictionary and recursion stack
+using System.Collections.Generic;
+
+class Node {
+    public int val;
+    public List<Node> neighbors;
+    public Node() {
+        val = 0;
+        neighbors = new List<Node>();
+    }
+    public Node(int _val) {
+        val = _val;
+        neighbors = new List<Node>();
+    }
+    public Node(int _val, List<Node> _neighbors) {
+        val = _val;
+        neighbors = _neighbors;
+    }
+}
+
+public class Solution {
+    private Dictionary<Node, Node> map = new Dictionary<Node, Node>();
+
+    public Node CloneGraph(Node node) {
+        if (node == null) {
+            return null;
+        }
+
+        // If the node is already cloned, return the cloned node
+        if (map.ContainsKey(node)) {
+            return map[node];
+        }
+
+        // Clone the current node
+        Node clone = new Node(node.val);
+        map[node] = clone;
+
+        // Recursively clone all neighbors
+        foreach (Node neighbor in node.neighbors) {
+            clone.neighbors.Add(CloneGraph(neighbor));
+        }
+
+        return clone;
+    }
+}
+```
 

c#/design_browser_history.md

@@ -1,2 +1,61 @@
-# design_browser_history.md
+# 1472. [Design Browser History](https://leetcode.com/problems/design-browser-history/)
+
+## Approach: Doubly Linked List
+
+### Solution
+csharp
+```csharp
+// Time Complexity:
+//   - Visit: O(1)
+//   - Back: O(steps)
+//   - Forward: O(steps)
+// Space Complexity: O(n), where n is the number of visited pages
+public class BrowserHistory {
+    private class Node {
+        public string Url;
+        public Node Prev, Next;
+
+        public Node(string url) {
+            Url = url;
+        }
+    }
+
+    private Node current;
+
+    public BrowserHistory(string homepage) {
+        current = new Node(homepage);
+    }
+
+    public void Visit(string url) {
+        Node newNode = new Node(url);
+        current.Next = newNode;
+        newNode.Prev = current;
+        current = newNode; // Move to the newly visited page
+    }
+
+    public string Back(int steps) {
+        while (steps > 0 && current.Prev != null) {
+            current = current.Prev;
+            steps--;
+        }
+        return current.Url;
+    }
+
+    public string Forward(int steps) {
+        while (steps > 0 && current.Next != null) {
+            current = current.Next;
+            steps--;
+        }
+        return current.Url;
+    }
+}
+
+/**
+ * Your BrowserHistory object will be instantiated and called as such:
+ * BrowserHistory obj = new BrowserHistory(homepage);
+ * obj.Visit(url);
+ * string param_2 = obj.Back(steps);
+ * string param_3 = obj.Forward(steps);
+ */
+```
 

c#/distinct_subsequences.md

@@ -1,2 +1,123 @@
-# distinct_subsequences.md
+# 115. [Distinct Subsequences](https://leetcode.com/problems/distinct-subsequences/)
+
+## Approach 1: Recursion with Memoization
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n * m)
+// Space Complexity: O(n * m)
+public class Solution {
+    public int NumDistinct(string s, string t) {
+        // Memoization table
+        int[,] memo = new int[s.Length, t.Length];
+        // Initialize all entries with -1
+        for (int i = 0; i < s.Length; i++) {
+            for (int j = 0; j < t.Length; j++) {
+                memo[i, j] = -1;
+            }
+        }
+        return NumDistinctHelper(s, t, 0, 0, memo);
+    }
+    
+    private int NumDistinctHelper(string s, string t, int sIndex, int tIndex, int[,] memo) {
+        // If t is exhausted, one subsequence is found
+        if (tIndex == t.Length) {
+            return 1;
+        }
+        // If s is exhausted first, no subsequence can be formed
+        if (sIndex == s.Length) {
+            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] = NumDistinctHelper(s, t, sIndex + 1, tIndex + 1, memo) + 
+                                   NumDistinctHelper(s, t, sIndex + 1, tIndex, memo);
+        } else {
+            // If characters don't match, skip the current character in s
+            memo[sIndex, tIndex] = NumDistinctHelper(s, t, sIndex + 1, tIndex, memo);
+        }
+        
+        return memo[sIndex, tIndex];
+    }
+}
+```
+
+## Approach 2: Dynamic Programming
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n * m)
+// Space Complexity: O(n * m)
+public class Solution {
+    public int NumDistinct(string s, string t) {
+        // DP table
+        int[,] dp = new int[s.Length + 1, t.Length + 1];
+
+        // Base case: empty t can be formed by all possible substrings of s
+        for (int i = 0; i <= s.Length; i++) {
+            dp[i, t.Length] = 1;
+        }
+
+        // Fill the table in reverse order
+        for (int i = s.Length - 1; i >= 0; i--) {
+            for (int j = t.Length - 1; j >= 0; j--) {
+                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
+csharp
+```csharp
+// Time Complexity: O(n * m)
+// Space Complexity: O(m)
+public class Solution {
+    public int NumDistinct(string s, string t) {
+        // Previous and current row for space optimization
+        int[] prev = new int[t.Length + 1];
+        int[] curr = new int[t.Length + 1];
+        
+        // Base case: empty t can be formed by all possible substrings of s
+        for (int i = 0; i <= s.Length; i++) {
+            prev[t.Length] = 1;
+        }
+        
+        // Fill the table in reverse order
+        for (int i = s.Length - 1; i >= 0; i--) {
+            for (int j = t.Length - 1; j >= 0; j--) {
+                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
+            Array.Copy(curr, prev, curr.Length);
+        }
+        
+        // Result is the number of ways to form t[0...m] from s[0...n]
+        return prev[0];
+    }
+}
+```