add solutions to 300 problems

Author: ashishps1

c#/01-matrix.md

@@ -0,0 +1,126 @@
+# [542. 01 Matrix](https://leetcode.com/problems/01-matrix/)
+
+## Approaches
+- [Approach 1: Breadth-First Search (BFS)](#approach-1-bfs)
+- [Approach 2: Dynamic Programming](#approach-2-dp)
+- [Approach 3: Optimized BFS with a 2-pass solution](#approach-3-optimized-bfs)
+
+### Approach 1: Breadth-First Search (BFS)
+
+**Intuition:**
+  - The fundamental idea is to find the shortest path from each cell containing `1` to the nearest cell containing `0`.
+  - We can consider each cell with `0` as the source node and perform a breadth-first search (BFS) to find the shortest distance to all `1`s.
+
+**Steps:**
+1. Initialize the result matrix with `int.MaxValue` for each cell.
+2. Use a queue to track coordinates of `0` cells and begin BFS from here.
+3. For each `0`, attempt to move in all four directions, updating any `1` cell's distance if a shorter path is discovered.
+
+```csharp
+public class Solution {
+    public int[][] UpdateMatrix(int[][] matrix) {
+        int rows = matrix.Length;
+        int cols = matrix[0].Length;
+        int[][] distances = new int[rows][];
+        Queue<(int, int)> queue = new Queue<(int, int)>();
+
+        for (int i = 0; i < rows; i++) {
+            distances[i] = new int[cols];
+            for (int j = 0; j < cols; j++) {
+                // Initialize distances. 0 cells will be the start of BFS.
+                if (matrix[i][j] == 0) {
+                    queue.Enqueue((i,j));
+                } else {
+                    distances[i][j] = int.MaxValue;
+                }
+            }
+        }
+
+        int[][] directions = new int[][] { new int[] {1, 0}, new int[] {-1, 0}, new int[] {0, 1}, new int[] {0, -1} };
+
+        while (queue.Count > 0) {
+            (int x, int y) = queue.Dequeue();
+            for (int i = 0; i < directions.Length; i++) {
+                int newX = x + directions[i][0];
+                int newY = y + directions[i][1];
+                // Ensure within bounds and found a shorter path
+                if (newX >= 0 && newX < rows && newY >= 0 && newY < cols) {
+                    if (distances[newX][newY] > distances[x][y] + 1) {
+                        distances[newX][newY] = distances[x][y] + 1;
+                        queue.Enqueue((newX, newY));
+                    }
+                }
+            }
+        }
+        return distances;
+    }
+}
+```
+
+- **Time Complexity:** O(rows * cols), as each cell is processed at most once.
+- **Space Complexity:** O(rows * cols), for the `distances` matrix and queue space.
+
+### Approach 2: Dynamic Programming
+
+**Intuition:**
+  - We can reduce the problem into finding the minimum distance in two passes: one forward and one backward.
+  - Update the current cell's distance based on its neighboring cells.
+
+**Steps:**
+1. Pass from top-left to bottom-right. For each cell update its distance using the top and left neighbors.
+2. Pass from bottom-right to top-left. Update its distance using the bottom and right neighbors.
+
+```csharp
+public class Solution {
+    public int[][] UpdateMatrix(int[][] matrix) {
+        int rows = matrix.Length;
+        int cols = matrix[0].Length;
+        int[][] distances = new int[rows][];
+
+        for (int i = 0; i < rows; i++) {
+            distances[i] = new int[cols];
+            for (int j = 0; j < cols; j++) {
+                distances[i][j] = matrix[i][j] == 0 ? 0 : int.MaxValue - 100000; // Avoid overflow in addition
+            }
+        }
+
+        // Top-left to bottom-right
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (matrix[i][j] != 0) {
+                    if (i > 0) {
+                        distances[i][j] = Math.Min(distances[i][j], distances[i-1][j] + 1);
+                    }
+                    if (j > 0) {
+                        distances[i][j] = Math.Min(distances[i][j], distances[i][j-1] + 1);
+                    }
+                }
+            }
+        }
+
+        // Bottom-right to top-left
+        for (int i = rows - 1; i >= 0; i--) {
+            for (int j = cols - 1; j >= 0; j--) {
+                if (i < rows - 1) {
+                    distances[i][j] = Math.Min(distances[i][j], distances[i+1][j] + 1);
+                }
+                if (j < cols - 1) {
+                    distances[i][j] = Math.Min(distances[i][j], distances[i][j+1] + 1);
+                }
+            }
+        }
+        return distances;
+    }
+}
+```
+
+- **Time Complexity:** O(rows * cols), two complete passes over the data.
+- **Space Complexity:** O(1), as we modify the input matrix directly.
+
+### Approach 3: Optimized BFS with a 2-pass Solution
+
+This uses the first two methods but optimizes BFS by reducing unnecessary checks using a two-pass solution similar to dynamic programming. This method can save some overhead in BFS initialization. Although very similar to the dynamic programming approach, careful attention is paid so initial BFS fills in skews of the grid minimizing the work in the main passes. The same code and logic apply for this optimization.
+
+- **Time Complexity:** O(rows * cols)
+- **Space Complexity:** O(rows * cols) for BFS queue usage, reducible to O(1) when done during passes.
+

c#/132-pattern.md

@@ -0,0 +1,94 @@
+# [Leetcode 456: 132 Pattern](https://leetcode.com/problems/132-pattern/)
+
+## Solutions
+
+- [Brute Force Approach](#brute-force-approach)
+- [Optimal Solution Using Stack](#optimal-solution-using-stack)
+
+### Brute Force Approach
+
+#### Intuition
+The brute force solution involves checking every possible subsequence of length three for each triplet `(i, j, k)` with conditions `i < j < k` and `nums[i] < nums[k] < nums[j]`. This method essentially checks all combinations of triplets to see if they form the "132" pattern.
+
+#### Approach
+1. Use three nested loops to iterate over each possible triplet `(i, j, k)`.
+2. For each triplet, check if they satisfy the "132" pattern: `nums[i] < nums[k] < nums[j]`.
+3. If we find such a triplet, return `true`.
+4. If we finish all iterations without finding such a triplet, return `false`.
+
+#### Complexity
+- **Time Complexity**: O(n^3), where n is the length of the input array.
+- **Space Complexity**: O(1), as we use only a constant amount of extra space.
+
+```csharp
+public bool Find132patternBruteForce(int[] nums) 
+{
+    int n = nums.Length;
+    for (int i = 0; i < n; i++) 
+    {
+        for (int j = i + 1; j < n; j++) 
+        {
+            for (int k = j + 1; k < n; k++) 
+            {
+                // Check for the "132" pattern
+                if (nums[i] < nums[k] && nums[k] < nums[j]) 
+                {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+```
+
+### Optimal Solution Using Stack
+
+#### Intuition
+This solution involves using a stack to efficiently find the "132" pattern. The idea is to iterate backward through the array and keep track of potential third elements (`nums[k]` in the pattern) using a stack. We maintain a variable to track the potential `nums[k]` as we traverse backwards. If we find a triplet satisfying the 132 conditions, we return true.
+
+#### Approach
+1. Initialize a stack to keep potential third elements (`nums[k]`).
+2. Start traversing from the end of the array towards the beginning.
+3. Keep track of the maximum `nums[k]` found (`third`), initially set to the minimum integer value.
+4. For each element `nums[j]`, check if it can potentially be the middle element in the "132" pattern with `third` as `nums[k]`.
+5. If `nums[j]` is less than `third`, we've found a valid "132" pattern.
+6. If not, push `nums[j]` to the stack, updating `third` if necessary when elements are popped.
+7. Continue until a pattern is found or all elements are processed.
+
+#### Complexity
+- **Time Complexity**: O(n), as each element is pushed and popped from the stack at most once.
+- **Space Complexity**: O(n), due to the stack used to store elements.
+
+```csharp
+public bool Find132patternOptimal(int[] nums) 
+{
+    int n = nums.Length;
+    int third = Int32.MinValue;
+    Stack<int> stack = new Stack<int>();
+
+    // Traverse from the end of the list to the beginning
+    for (int i = n - 1; i >= 0; i--) 
+    {
+        // If current element is less than the third element of 132 pattern
+        if (nums[i] < third) 
+        {
+            return true;
+        }
+        
+        // Pop elements from stack until we find something larger than nums[i]
+        while (stack.Count > 0 && nums[i] > stack.Peek()) 
+        {
+            // Update third
+            third = stack.Pop();
+        }
+
+        // Push current element onto the stack
+        stack.Push(nums[i]);
+    }
+    return false;
+}
+```
+
+This solution effectively utilizes a stack to achieve linear time complexity, providing an optimal solution to detect the "132" pattern in an array.
+

c#/3Sum.md

@@ -1,80 +1,90 @@
-# [15. 3Sum](https://leetcode.com/problems/3sum/)
+# [3Sum](https://leetcode.com/problems/3sum/)
 
-## Approach 1: Brute Force (Basic)
+## Approaches:
+- [Brute Force Approach](#brute-force-approach)
+- [Sorting and Two-Pointer Approach](#sorting-and-two-pointer-approach)
 
-### Solution
-csharp
-```csharp
-// Time Complexity: O(n^3)
-// Space Complexity: O(1) (excluding output list)
-using System;
-using System.Collections.Generic;
-using System.Linq;
+### Brute Force Approach
+The brute force approach for solving the 3Sum problem is to generate all possible triplets (i, j, k) where i < j < k. We then check if the sum of the elements at these indices is zero.
+
+**Intuition:**
+- Iterate through all unique pairs of indices (i, j, k) in the array, and check if their sum equals zero.
+- Since we need combinations without repetitions, ensure i < j < k.
 
+```csharp
 public class Solution {
     public IList<IList<int>> ThreeSum(int[] nums) {
-        var result = new HashSet<IList<int>>();
-        int n = nums.Length;
+        IList<IList<int>> result = new List<IList<int>>();
 
-        // Iterate through all possible triplets
-        for (int i = 0; i < n - 2; i++) {
-            for (int j = i + 1; j < n - 1; j++) {
-                for (int k = j + 1; k < n; k++) {
+        // Iterate through all elements for the first number
+        for (int i = 0; i < nums.Length - 2; i++) {
+            // Iterate for the second number
+            for (int j = i + 1; j < nums.Length - 1; j++) {
+                // Iterate for the third number
+                for (int k = j + 1; k < nums.Length; k++) {
+                    // Check if these three add up to zero
                     if (nums[i] + nums[j] + nums[k] == 0) {
-                        var triplet = new List<int> { nums[i], nums[j], nums[k] };
-                        triplet.Sort(); // Ensure the triplet is in sorted order
-                        result.Add(triplet); // Add triplet to the set to avoid duplicates
+                        List<int> triplet = new List<int> { nums[i], nums[j], nums[k] };
+                        triplet.Sort(); // Sort to ensure the triplet is in order
+                        if (!ContainsTriplet(result, triplet)) {
+                            result.Add(triplet);
+                        }
                     }
                 }
             }
         }
+        
+        return result;
+    }
 
-        return result.ToList(); // Convert set to list for the output
+    private bool ContainsTriplet(IList<IList<int>> list, List<int> triplet) {
+        foreach (var item in list) {
+            if (item[0] == triplet[0] && item[1] == triplet[1] && item[2] == triplet[2]) {
+                return true;
+            }
+        }
+        return false;
     }
 }
 ```
 
-## Approach 2: Two Pointers (Optimal)
+**Time Complexity:** O(n^3)  
+**Space Complexity:** O(n), storing the result.
 
-### Solution
-csharp
-```csharp
-// Time Complexity: O(n^2)
-// Space Complexity: O(n) (for sorting or output list)
-using System;
-using System.Collections.Generic;
-using System.Linq;
+### Sorting and Two-Pointer Approach
+This approach reduces the time complexity by first sorting the array and then using a two-pointer strategy to find the pairs that sum to the negative of each element.
 
+**Intuition:**
+- Sort the array. This helps in easily skipping duplicates and using a two-pointer method effectively.
+- Fix one number a[i] and then find two numbers from the remaining part of the array which sum to -a[i].
+- Use two pointers starting from both ends of the remaining array to find the combinations.
+
+```csharp
 public class Solution {
     public IList<IList<int>> ThreeSum(int[] nums) {
-        var result = new List<IList<int>>();
-        Array.Sort(nums); // Sort the array to use two-pointer technique
+        Array.Sort(nums); // Sort the array
+        IList<IList<int>> result = new List<IList<int>>();
 
         for (int i = 0; i < nums.Length - 2; i++) {
-            // Skip duplicates for the first element
-            if (i > 0 && nums[i] == nums[i - 1]) {
-                continue;
-            }
-
-            int left = i + 1;
-            int right = nums.Length - 1;
+            // Skip duplicates
+            if (i > 0 && nums[i] == nums[i - 1]) continue;
 
-            // Two-pointer approach
+            int left = i + 1, right = nums.Length - 1;
             while (left < right) {
                 int sum = nums[i] + nums[left] + nums[right];
                 if (sum == 0) {
                     result.Add(new List<int> { nums[i], nums[left], nums[right] });
 
-                    // Skip duplicates for the second and third elements
+                    // Skip duplicates for left and right
                     while (left < right && nums[left] == nums[left + 1]) left++;
                     while (left < right && nums[right] == nums[right - 1]) right--;
 
                     left++;
                     right--;
                 } else if (sum < 0) {
-                    left++; // Increase the sum
+                    left++; // We need a larger sum, move the left pointer to the right
                 } else {
-                    right--; // Decrease the sum
+                    right--; // We need a smaller sum, move the right pointer to the left
                 }
             }
         }
@@ -84,3 +94,6 @@ public class Solution {
 }
 ```
 
+**Time Complexity:** O(n^2)  
+**Space Complexity:** O(n), storing the result.
+