add more solutions

Author: ashishps1

c#/01_matrix.md

@@ -8,51 +8,39 @@
 // Space Complexity: O(m * n), for the queue and distance matrix
 using System.Collections.Generic;
 
-public class Solution 
-{
-    public int[][] UpdateMatrix(int[][] mat) 
-    {
+public class Solution {
+    public int[][] UpdateMatrix(int[][] mat) {
         int rows = mat.Length;
         int cols = mat[0].Length;
         int[][] distances = new int[rows][];
         bool[][] visited = new bool[rows][];
         Queue<int[]> queue = new Queue<int[]>();
 
-        // Step 1: Initialize the queue with all '0' cells and mark them as visited
-        for (int i = 0; i < rows; i++) 
-        {
+        for (int i = 0; i < rows; i++) {
             distances[i] = new int[cols];
             visited[i] = new bool[cols];
-            for (int j = 0; j < cols; j++) 
-            {
-                if (mat[i][j] == 0) 
-                {
+        }
+
+        // Step 1: Initialize the queue with all '0' cells and mark them as visited
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (mat[i][j] == 0) {
                     queue.Enqueue(new int[] { i, j });
                     visited[i][j] = true;
                 }
             }
         }
 
         // Step 2: Perform BFS to calculate distances
-        int[][] directions = new int[][] 
-        {
-            new int[] { 0, 1 },
-            new int[] { 1, 0 },
-            new int[] { 0, -1 },
-            new int[] { -1, 0 }
-        };
-
-        while (queue.Count > 0) 
-        {
+        int[][] directions = new int[][] { new int[] { 0, 1 }, new int[] { 1, 0 }, new int[] { 0, -1 }, new int[] { -1, 0 } };
+        while (queue.Count > 0) {
             int[] current = queue.Dequeue();
-            foreach (int[] dir in directions) 
-            {
+            foreach (var dir in directions) {
                 int newRow = current[0] + dir[0];
                 int newCol = current[1] + dir[1];
 
                 // Check bounds and if the cell is not visited
-                if (newRow >= 0 && newRow < rows && newCol >= 0 && newCol < cols && !visited[newRow][newCol]) 
-                {
+                if (newRow >= 0 && newRow < rows && newCol >= 0 && newCol < cols && !visited[newRow][newCol]) {
                     distances[newRow][newCol] = distances[current[0]][current[1]] + 1;
                     queue.Enqueue(new int[] { newRow, newCol });
                     visited[newRow][newCol] = true;

c#/add_two_numbers.md

@@ -1,2 +1,41 @@
-# add_two_numbers.md
+# [2. Add Two Numbers](https://leetcode.com/problems/add-two-numbers/)
+
+## Approach: Iterative Solution with Carry
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(max(m, n)), where m and n are the lengths of the two lists
+// Space Complexity: O(max(m, n)), for the new linked list
+public class Solution {
+    public ListNode AddTwoNumbers(ListNode l1, ListNode l2) {
+        ListNode dummy = new ListNode(0); // Dummy node to simplify the process
+        ListNode current = dummy; // Pointer to the current node in the result list
+        int carry = 0; // Store carry from the addition
+
+        // Traverse both lists
+        while (l1 != null || l2 != null || carry != 0) {
+            int sum = carry; // Start with the carry
+
+            // Add values from l1 and l2 if they exist
+            if (l1 != null) {
+                sum += l1.val;
+                l1 = l1.next;
+            }
+            if (l2 != null) {
+                sum += l2.val;
+                l2 = l2.next;
+            }
+
+            // Calculate new carry and the digit to store
+            carry = sum / 10;
+            current.next = new ListNode(sum % 10); // Store the last digit of the sum
+            current = current.next; // Move to the next node
+        }
+
+        return dummy.next; // Skip the dummy node
+    }
+}
+```
+
 

c#/basic_calculator_2.md

@@ -1,2 +1,54 @@
-# basic_calculator_2.md
+# [227. Basic Calculator II](https://leetcode.com/problems/basic-calculator-ii/)
+
+## Approach: Using a Stack for Intermediate Results
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+using System;
+using System.Collections.Generic;
+
+public class Solution {
+    public int Calculate(string s) {
+        Stack<int> stack = new Stack<int>();
+        int currentNumber = 0;
+        char operation = '+'; // Default operation is addition
+
+        for (int i = 0; i < s.Length; i++) {
+            char c = s[i];
+
+            // Build the current number
+            if (char.IsDigit(c)) {
+                currentNumber = currentNumber * 10 + (c - '0');
+            }
+
+            // Process operators and the last number
+            if (!char.IsDigit(c) && c != ' ' || i == s.Length - 1) {
+                if (operation == '+') {
+                    stack.Push(currentNumber);
+                } else if (operation == '-') {
+                    stack.Push(-currentNumber);
+                } else if (operation == '*') {
+                    stack.Push(stack.Pop() * currentNumber);
+                } else if (operation == '/') {
+                    stack.Push(stack.Pop() / currentNumber);
+                }
+
+                operation = c; // Update the operation
+                currentNumber = 0; // Reset the current number
+            }
+        }
+
+        // Sum up all the values in the stack
+        int result = 0;
+        while (stack.Count > 0) {
+            result += stack.Pop();
+        }
+
+        return result;
+    }
+}
+```
 

c#/binary_tree_cameras.md

@@ -1,2 +1,108 @@
-# binary_tree_cameras.md
+
+# 968. [Binary Tree Cameras](https://leetcode.com/problems/binary-tree-cameras/)
+
+## Approach 1: Greedy Approach with Recursion
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n)
+// Space Complexity: O(h) where h is the height of the tree (recursion stack)
+public class Solution {
+    private int cameras = 0;
+    
+    public int MinCameraCover(TreeNode root) {
+        // If root returns 0, it means it needs a camera
+        return Dfs(root) == 0 ? cameras + 1 : cameras;
+    }
+    
+    // Helper function for recursive traversal
+    private int Dfs(TreeNode node) {
+        if (node == null) {
+            return 1; // This node is covered
+        }
+        
+        int left = Dfs(node.left);
+        int right = Dfs(node.right);
+        
+        if (left == 0 || right == 0) {
+            cameras++;
+            return 2; // Placing a camera at this node
+        }
+        
+        return (left == 2 || right == 2) ? 1 : 0;
+        // 2 indicates child has a camera, 1 means this node is covered
+        // 0 indicates this node needs a camera
+    }
+}
+
+public class TreeNode {
+    public int val;
+    public TreeNode left;
+    public TreeNode right;
+    public TreeNode(int x) { val = x; }
+}
+```
+
+## Approach 2: Dynamic Programming with State Tracking
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n)
+// Space Complexity: O(n)
+using System.Collections.Generic;
+
+public class Solution {
+    private const int HAS_CAMERA = 0;
+    private const int COVERED = 1;
+    private const int NEEDS_CAMERA = 2;
+    
+    public int MinCameraCover(TreeNode root) {
+        var dp = new Dictionary<TreeNode, int[]>();
+        
+        return Dfs(root, dp) == NEEDS_CAMERA ? dp[root][HAS_CAMERA] + 1 : dp[root][HAS_CAMERA];
+    }
+    
+    private int Dfs(TreeNode node, Dictionary<TreeNode, int[]> dp) {
+        if (node == null) {
+            return COVERED;
+        }
+        
+        if (!dp.ContainsKey(node)) {
+            var state = new int[3];
+
+            int left = Dfs(node.left, dp);
+            int right = Dfs(node.right, dp);
+            
+            if (left == NEEDS_CAMERA || right == NEEDS_CAMERA) {
+                state[HAS_CAMERA] = dp.GetValueOrDefault(node, new int[]{0, 0, 0})[HAS_CAMERA] + 1;
+                dp[node] = state;
+                return HAS_CAMERA;
+            }
+
+            if (left == HAS_CAMERA || right == HAS_CAMERA) {
+                state[COVERED] = dp.GetValueOrDefault(node, new int[]{0, 0, 0})[COVERED];
+                dp[node] = state;
+                return COVERED;
+            }
+
+            state[NEEDS_CAMERA] = dp.GetValueOrDefault(node, new int[]{0, 0, 0})[NEEDS_CAMERA];
+            dp[node] = state;
+            return NEEDS_CAMERA;
+        }
+
+        return dp[node][0];
+    }
+}
+
+public class TreeNode {
+    public int val;
+    public TreeNode left;
+    public TreeNode right;
+    public TreeNode(int x) { val = x; }
+}
+```
+
+Note: The second approach is a detailed version using dynamic programming concepts, but the greedy recursive version is typically more straightforward and efficient due to its optimizations for this specific problem.
 

c#/binary_tree_level_order_traversal.md

@@ -1,2 +1,106 @@
-# binary_tree_level_order_traversal.md
+# 102. [Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/)
+
+## Approach 1: Breadth-First Search (Using Queue)
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n), where n is the number of nodes in the tree
+// Space Complexity: O(n) for the queue and result storage
+
+using System;
+using System.Collections.Generic;
+
+public class Solution {
+    public IList<IList<int>> LevelOrder(TreeNode root) {
+        IList<IList<int>> result = new List<IList<int>>();
+        if (root == null) {
+            return result; // Return empty result if the tree is empty
+        }
+
+        Queue<TreeNode> queue = new Queue<TreeNode>();
+        queue.Enqueue(root);
+
+        while (queue.Count > 0) {
+            int levelSize = queue.Count;
+            List<int> currentLevel = new List<int>();
+
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode currentNode = queue.Dequeue(); // Process the current node
+                currentLevel.Add(currentNode.val);
+
+                if (currentNode.left != null) {
+                    queue.Enqueue(currentNode.left); // Add left child to the queue
+                }
+                if (currentNode.right != null) {
+                    queue.Enqueue(currentNode.right); // Add right child to the queue
+                }
+            }
+
+            result.Add(currentLevel); // Add the current level to the result
+        }
+
+        return result;
+    }
+}
+
+public class TreeNode {
+    public int val;
+    public TreeNode left;
+    public TreeNode right;
+
+    public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}
+```
+
+## Approach 2: Depth-First Search (Recursive)
+
+### Solution
+csharp
+```csharp
+// Time Complexity: O(n), where n is the number of nodes in the tree
+// Space Complexity: O(h), where h is the height of the tree for recursion stack
+
+using System;
+using System.Collections.Generic;
+
+public class Solution {
+    public IList<IList<int>> LevelOrder(TreeNode root) {
+        IList<IList<int>> result = new List<IList<int>>();
+        Dfs(root, 0, result);
+        return result;
+    }
+
+    private void Dfs(TreeNode node, int level, IList<IList<int>> result) {
+        if (node == null) {
+            return; // Base case: if the node is null, return
+        }
+
+        if (level == result.Count) {
+            result.Add(new List<int>()); // Create a new level in the result
+        }
+
+        result[level].Add(node.val); // Add the current node's value to the current level
+
+        Dfs(node.left, level + 1, result); // Recurse for the left child
+        Dfs(node.right, level + 1, result); // Recurse for the right child
+    }
+}
+
+public class TreeNode {
+    public int val;
+    public TreeNode left;
+    public TreeNode right;
+
+    public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}
+```