diff --git a/articles/4sum.md b/articles/4sum.md
index f99c11ddd..b590cf39e 100644
--- a/articles/4sum.md
+++ b/articles/4sum.md
@@ -96,6 +96,35 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> FourSum(int[] nums, int target) {
+        int n = nums.Length;
+        Array.Sort(nums);
+        HashSet<(int, int, int, int)> res = new HashSet<(int, int, int, int)>();
+
+        for (int a = 0; a < n; a++) {
+            for (int b = a + 1; b < n; b++) {
+                for (int c = b + 1; c < n; c++) {
+                    for (int d = c + 1; d < n; d++) {
+                        long sum = (long)nums[a] + nums[b] + nums[c] + nums[d];
+                        if (sum == target) {
+                            res.Add((nums[a], nums[b], nums[c], nums[d]));
+                        }
+                    }
+                }
+            }
+        }
+
+        var result = new List<List<int>>();
+        foreach (var quad in res) {
+            result.Add(new List<int> { quad.Item1, quad.Item2, quad.Item3, quad.Item4 });
+        }
+        return result;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -287,6 +316,58 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> FourSum(int[] nums, int target) {
+        Array.Sort(nums);
+        Dictionary<int, int> count = new Dictionary<int, int>();
+
+        foreach (int num in nums) {
+            if (!count.ContainsKey(num)) {
+                count[num] = 0;
+            }
+            count[num]++;
+        }
+
+        List<List<int>> res = new List<List<int>>();
+
+        for (int i = 0; i < nums.Length; i++) {
+            count[nums[i]]--;
+            if (i > 0 && nums[i] == nums[i - 1]) continue;
+
+            for (int j = i + 1; j < nums.Length; j++) {
+                count[nums[j]]--;
+                if (j > i + 1 && nums[j] == nums[j - 1]) continue;
+
+                for (int k = j + 1; k < nums.Length; k++) {
+                    count[nums[k]]--;
+                    if (k > j + 1 && nums[k] == nums[k - 1]) continue;
+
+                    long fourth = (long)target - (long)nums[i] - (long)nums[j] - (long)nums[k];
+                    if (fourth > int.MaxValue || fourth < int.MinValue) {
+                        continue;
+                    }
+
+                    if (count.ContainsKey((int)fourth) && count[(int)fourth] > 0) {
+                        res.Add(new List<int> { nums[i], nums[j], nums[k], (int)fourth });
+                    }
+                }
+
+                for (int k = j + 1; k < nums.Length; k++) {
+                    count[nums[k]]++;
+                }
+            }
+
+            for (int j = i + 1; j < nums.Length; j++) {
+                count[nums[j]]++;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -448,6 +529,42 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> FourSum(int[] nums, int target) {
+        Array.Sort(nums);
+        List<List<int>> res = new List<List<int>>();
+        int n = nums.Length;
+
+        for (int i = 0; i < n; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) continue;
+
+            for (int j = i + 1; j < n; j++) {
+                if (j > i + 1 && nums[j] == nums[j - 1]) continue;
+
+                int left = j + 1, right = n - 1;
+                while (left < right) {
+                    long sum = (long)nums[i] + nums[j] + nums[left] + nums[right];
+                    if (sum == target) {
+                        res.Add(new List<int> { nums[i], nums[j], nums[left], nums[right] });
+                        left++;
+                        right--;
+                        while (left < right && nums[left] == nums[left - 1]) left++;
+                        while (left < right && nums[right] == nums[right + 1]) right--;
+                    } else if (sum < target) {
+                        left++;
+                    } else {
+                        right--;
+                    }
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -637,6 +754,52 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private List<List<int>> res;
+    private List<int> quad;
+
+    public List<List<int>> FourSum(int[] nums, int target) {
+        Array.Sort(nums);
+        res = new List<List<int>>();
+        quad = new List<int>();
+        KSum(nums, 4, 0, target);
+        return res;
+    }
+
+    private void KSum(int[] nums, int k, int start, long target) {
+        if (k == 2) {
+            int l = start, r = nums.Length - 1;
+            while (l < r) {
+                long sum = (long)nums[l] + nums[r];
+                if (sum < target) {
+                    l++;
+                } else if (sum > target) {
+                    r--;
+                } else {
+                    List<int> newQuad = new List<int>(quad);
+                    newQuad.Add(nums[l]);
+                    newQuad.Add(nums[r]);
+                    res.Add(newQuad);
+                    l++;
+                    r--;
+                    while (l < r && nums[l] == nums[l - 1]) l++;
+                    while (l < r && nums[r] == nums[r + 1]) r--;
+                }
+            }
+            return;
+        }
+
+        for (int i = start; i < nums.Length - k + 1; i++) {
+            if (i > start && nums[i] == nums[i - 1]) continue;
+            quad.Add(nums[i]);
+            KSum(nums, k - 1, i + 1, target - nums[i]);
+            quad.RemoveAt(quad.Count - 1);
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/accounts-merge.md b/articles/accounts-merge.md
index 665334798..15b8e9881 100644
--- a/articles/accounts-merge.md
+++ b/articles/accounts-merge.md
@@ -284,6 +284,79 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private Dictionary<string, int> emailIdx = new Dictionary<string, int>();
+    private List<string> emails = new List<string>();
+    private List<List<int>> adj;
+    private bool[] visited;
+    private Dictionary<int, List<string>> components = new Dictionary<int, List<string>>();
+    private Dictionary<int, string> componentName = new Dictionary<int, string>();
+
+    public List<List<string>> AccountsMerge(List<List<string>> accounts) {
+        int m = 0;
+
+        for (int accId = 0; accId < accounts.Count; accId++) {
+            var account = accounts[accId];
+            for (int i = 1; i < account.Count; i++) {
+                string email = account[i];
+                if (!emailIdx.ContainsKey(email)) {
+                    emailIdx[email] = m++;
+                    emails.Add(email);
+                }
+            }
+        }
+
+        adj = new List<List<int>>();
+        for (int i = 0; i < m; i++) adj.Add(new List<int>());
+
+        foreach (var account in accounts) {
+            for (int i = 2; i < account.Count; i++) {
+                int u = emailIdx[account[i - 1]];
+                int v = emailIdx[account[i]];
+                adj[u].Add(v);
+                adj[v].Add(u);
+            }
+        }
+
+        visited = new bool[m];
+
+        foreach (var account in accounts) {
+            string name = account[0];
+            foreach (var email in account.Skip(1)) {
+                int idx = emailIdx[email];
+                if (!visited[idx]) {
+                    components[idx] = new List<string>();
+                    componentName[idx] = name;
+                    Dfs(idx, idx);
+                }
+            }
+        }
+
+        var res = new List<List<string>>();
+        foreach (var kvp in components) {
+            var group = kvp.Value;
+            group.Sort(StringComparer.Ordinal);
+            var merged = new List<string> { componentName[kvp.Key] };
+            merged.AddRange(group);
+            res.Add(merged);
+        }
+
+        return res;
+    }
+
+    private void Dfs(int node, int root) {
+        visited[node] = true;
+        components[root].Add(emails[node]);
+        foreach (int nei in adj[node]) {
+            if (!visited[nei]) {
+                Dfs(nei, root);
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -607,6 +680,85 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<string>> AccountsMerge(List<List<string>> accounts) {
+        int n = accounts.Count;
+        Dictionary<string, int> emailIdx = new Dictionary<string, int>();
+        List<string> emails = new List<string>();
+        Dictionary<int, int> emailToAcc = new Dictionary<int, int>();
+
+        int m = 0;
+        for (int accId = 0; accId < n; accId++) {
+            var account = accounts[accId];
+            for (int i = 1; i < account.Count; i++) {
+                string email = account[i];
+                if (!emailIdx.ContainsKey(email)) {
+                    emailIdx[email] = m;
+                    emails.Add(email);
+                    emailToAcc[m] = accId;
+                    m++;
+                }
+            }
+        }
+
+        List<List<int>> adj = new List<List<int>>();
+        for (int i = 0; i < m; i++) adj.Add(new List<int>());
+        
+        foreach (var account in accounts) {
+            for (int i = 2; i < account.Count; i++) {
+                int id1 = emailIdx[account[i]];
+                int id2 = emailIdx[account[i - 1]];
+                adj[id1].Add(id2);
+                adj[id2].Add(id1);
+            }
+        }
+
+        Dictionary<int, List<string>> emailGroup = new Dictionary<int, List<string>>();
+        bool[] visited = new bool[m];
+
+        void Bfs(int start, int accId) {
+            Queue<int> queue = new Queue<int>();
+            queue.Enqueue(start);
+            visited[start] = true;
+
+            if (!emailGroup.ContainsKey(accId))
+                emailGroup[accId] = new List<string>();
+
+            while (queue.Count > 0) {
+                int node = queue.Dequeue();
+                emailGroup[accId].Add(emails[node]);
+
+                foreach (int nei in adj[node]) {
+                    if (!visited[nei]) {
+                        visited[nei] = true;
+                        queue.Enqueue(nei);
+                    }
+                }
+            }
+        }
+
+        for (int i = 0; i < m; i++) {
+            if (!visited[i]) {
+                Bfs(i, emailToAcc[i]);
+            }
+        }
+
+        List<List<string>> res = new List<List<string>>();
+        foreach (var kvp in emailGroup) {
+            int accId = kvp.Key;
+            string name = accounts[accId][0];
+            List<string> merged = new List<string> { name };
+            kvp.Value.Sort(StringComparer.Ordinal);
+            merged.AddRange(kvp.Value);
+            res.Add(merged);
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -922,6 +1074,87 @@ class Solution {
 }
 ```
 
+```csharp
+public class UnionFind {
+    private int[] parent;
+    private int[] rank;
+
+    public UnionFind(int n) {
+        parent = new int[n];
+        rank = new int[n];
+        for (int i = 0; i < n; i++) {
+            parent[i] = i;
+            rank[i] = 1;
+        }
+    }
+
+    public int Find(int x) {
+        if (x != parent[x]) {
+            parent[x] = Find(parent[x]);
+        }
+        return parent[x];
+    }
+
+    public bool Union(int x, int y) {
+        int rootX = Find(x);
+        int rootY = Find(y);
+
+        if (rootX == rootY) return false;
+
+        if (rank[rootX] > rank[rootY]) {
+            parent[rootY] = rootX;
+            rank[rootX] += rank[rootY];
+        } else {
+            parent[rootX] = rootY;
+            rank[rootY] += rank[rootX];
+        }
+
+        return true;
+    }
+}
+
+public class Solution {
+    public List<List<string>> AccountsMerge(List<List<string>> accounts) {
+        int n = accounts.Count;
+        UnionFind uf = new UnionFind(n);
+        Dictionary<string, int> emailToAcc = new Dictionary<string, int>();
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 1; j < accounts[i].Count; j++) {
+                string email = accounts[i][j];
+                if (emailToAcc.ContainsKey(email)) {
+                    uf.Union(i, emailToAcc[email]);
+                } else {
+                    emailToAcc[email] = i;
+                }
+            }
+        }
+
+        Dictionary<int, List<string>> emailGroup = new Dictionary<int, List<string>>();
+        foreach (var kvp in emailToAcc) {
+            string email = kvp.Key;
+            int leader = uf.Find(kvp.Value);
+            if (!emailGroup.ContainsKey(leader)) {
+                emailGroup[leader] = new List<string>();
+            }
+            emailGroup[leader].Add(email);
+        }
+
+        List<List<string>> res = new List<List<string>>();
+        foreach (var kvp in emailGroup) {
+            int accId = kvp.Key;
+            List<string> emails = kvp.Value;
+            emails.Sort(StringComparer.Ordinal);
+            List<string> merged = new List<string> { accounts[accId][0] };
+            merged.AddRange(emails);
+            res.Add(merged);
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/asteroid-collision.md b/articles/asteroid-collision.md
index e9634e9e8..94a5993d3 100644
--- a/articles/asteroid-collision.md
+++ b/articles/asteroid-collision.md
@@ -101,6 +101,35 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int[] AsteroidCollision(int[] asteroids) {
+        Stack<int> stack = new Stack<int>();
+
+        foreach (int a in asteroids) {
+            int current = a;
+            while (stack.Count > 0 && current < 0 && stack.Peek() > 0) {
+                int diff = current + stack.Peek();
+                if (diff < 0) {
+                    stack.Pop();
+                } else if (diff > 0) {
+                    current = 0;
+                } else {
+                    current = 0;
+                    stack.Pop();
+                }
+            }
+            if (current != 0) {
+                stack.Push(current);
+            }
+        }
+
+        int[] result = stack.Reverse().ToArray();
+        return result;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -231,6 +260,40 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int[] AsteroidCollision(int[] asteroids) {
+        int n = asteroids.Length;
+        int j = -1;
+
+        foreach (int a in asteroids) {
+            int current = a;
+
+            while (j >= 0 && asteroids[j] > 0 && current < 0) {
+                if (asteroids[j] > Math.Abs(current)) {
+                    current = 0;
+                    break;
+                } else if (asteroids[j] == Math.Abs(current)) {
+                    j--;
+                    current = 0;
+                    break;
+                } else {
+                    j--;
+                }
+            }
+
+            if (current != 0) {
+                asteroids[++j] = current;
+            }
+        }
+
+        int[] result = new int[j + 1];
+        Array.Copy(asteroids, 0, result, 0, j + 1);
+        return result;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/baseball-game.md b/articles/baseball-game.md
index 2d04f4311..ac8e53feb 100644
--- a/articles/baseball-game.md
+++ b/articles/baseball-game.md
@@ -1,4 +1,4 @@
-## 1. Stack
+## 1. Stack - I
 
 ::tabs-start
 
@@ -96,6 +96,36 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int CalPoints(string[] operations) {
+        Stack<int> stack = new Stack<int>();
+
+        foreach (var op in operations) {
+            if (op == "+") {
+                int top = stack.Pop();
+                int newTop = top + stack.Peek();
+                stack.Push(top);
+                stack.Push(newTop);
+            } else if (op == "D") {
+                stack.Push(2 * stack.Peek());
+            } else if (op == "C") {
+                stack.Pop();
+            } else {
+                stack.Push(int.Parse(op));
+            }
+        }
+
+        int total = 0;
+        foreach (var val in stack) {
+            total += val;
+        }
+
+        return total;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -215,6 +245,38 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int CalPoints(string[] operations) {
+        Stack<int> stack = new Stack<int>();
+        int res = 0;
+
+        foreach (var op in operations) {
+            if (op == "+") {
+                int top = stack.Pop();
+                int second = stack.Peek();
+                int sum = top + second;
+                stack.Push(top);
+                stack.Push(sum);
+                res += sum;
+            } else if (op == "D") {
+                int doubleVal = 2 * stack.Peek();
+                stack.Push(doubleVal);
+                res += doubleVal;
+            } else if (op == "C") {
+                res -= stack.Pop();
+            } else {
+                int num = int.Parse(op);
+                stack.Push(num);
+                res += num;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/binary-tree-inorder-traversal.md b/articles/binary-tree-inorder-traversal.md
index 4735f8400..84e525d71 100644
--- a/articles/binary-tree-inorder-traversal.md
+++ b/articles/binary-tree-inorder-traversal.md
@@ -126,6 +126,35 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public List<int> InorderTraversal(TreeNode root) {
+        List<int> res = new List<int>();
+        void Inorder(TreeNode node) {
+            if (node == null) return;
+            Inorder(node.left);
+            res.Add(node.val);
+            Inorder(node.right);
+        }
+        Inorder(root);
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -273,6 +302,41 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public IList<int> InorderTraversal(TreeNode root) {
+        List<int> res = new List<int>();
+        Stack<TreeNode> stack = new Stack<TreeNode>();
+        TreeNode cur = root;
+
+        while (cur != null || stack.Count > 0) {
+            while (cur != null) {
+                stack.Push(cur);
+                cur = cur.left;
+            }
+            cur = stack.Pop();
+            res.Add(cur.val);
+            cur = cur.right;
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -457,6 +521,51 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public List<int> InorderTraversal(TreeNode root) {
+        List<int> res = new List<int>();
+        TreeNode cur = root;
+
+        while (cur != null) {
+            if (cur.left == null) {
+                res.Add(cur.val);
+                cur = cur.right;
+            } else {
+                TreeNode prev = cur.left;
+                while (prev.right != null && prev.right != cur) {
+                    prev = prev.right;
+                }
+
+                if (prev.right == null) {
+                    prev.right = cur;
+                    cur = cur.left;
+                } else {
+                    prev.right = null;
+                    res.Add(cur.val);
+                    cur = cur.right;
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/binary-tree-postorder-traversal.md b/articles/binary-tree-postorder-traversal.md
index 554c3006a..8853be764 100644
--- a/articles/binary-tree-postorder-traversal.md
+++ b/articles/binary-tree-postorder-traversal.md
@@ -126,6 +126,37 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public List<int> PostorderTraversal(TreeNode root) {
+        List<int> res = new List<int>();
+
+        void Postorder(TreeNode node) {
+            if (node == null) return;
+            Postorder(node.left);
+            Postorder(node.right);
+            res.Add(node.val);
+        }
+
+        Postorder(root);
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -309,6 +340,52 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public List<int> PostorderTraversal(TreeNode root) {
+        var stack = new Stack<TreeNode>();
+        var visit = new Stack<bool>();
+        var res = new List<int>();
+
+        stack.Push(root);
+        visit.Push(false);
+
+        while (stack.Count > 0) {
+            var cur = stack.Pop();
+            var v = visit.Pop();
+
+            if (cur != null) {
+                if (v) {
+                    res.Add(cur.val);
+                } else {
+                    stack.Push(cur);
+                    visit.Push(true);
+                    stack.Push(cur.right);
+                    visit.Push(false);
+                    stack.Push(cur.left);
+                    visit.Push(false);
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -464,6 +541,43 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public List<int> PostorderTraversal(TreeNode root) {
+        List<int> res = new List<int>();
+        Stack<TreeNode> stack = new Stack<TreeNode>();
+        TreeNode cur = root;
+
+        while (cur != null || stack.Count > 0) {
+            if (cur != null) {
+                res.Add(cur.val);
+                stack.Push(cur);
+                cur = cur.right;
+            } else {
+                cur = stack.Pop();
+                cur = cur.left;
+            }
+        }
+
+        res.Reverse();
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -652,6 +766,52 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public List<int> PostorderTraversal(TreeNode root) {
+        List<int> res = new List<int>();
+        TreeNode cur = root;
+
+        while (cur != null) {
+            if (cur.right == null) {
+                res.Add(cur.val);
+                cur = cur.left;
+            } else {
+                TreeNode prev = cur.right;
+                while (prev.left != null && prev.left != cur) {
+                    prev = prev.left;
+                }
+
+                if (prev.left == null) {
+                    res.Add(cur.val);
+                    prev.left = cur;
+                    cur = cur.right;
+                } else {
+                    prev.left = null;
+                    cur = cur.left;
+                }
+            }
+        }
+
+        res.Reverse();
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/binary-tree-preorder-traversal.md b/articles/binary-tree-preorder-traversal.md
index fbcc8b4d6..f7f86ffb9 100644
--- a/articles/binary-tree-preorder-traversal.md
+++ b/articles/binary-tree-preorder-traversal.md
@@ -126,6 +126,37 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public List<int> PreorderTraversal(TreeNode root) {
+        List<int> res = new List<int>();
+        Preorder(root, res);
+        return res;
+    }
+
+    private void Preorder(TreeNode node, List<int> res) {
+        if (node == null) return;
+
+        res.Add(node.val);
+        Preorder(node.left, res);
+        Preorder(node.right, res);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -274,6 +305,41 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public List<int> PreorderTraversal(TreeNode root) {
+        List<int> res = new List<int>();
+        Stack<TreeNode> stack = new Stack<TreeNode>();
+        TreeNode cur = root;
+
+        while (cur != null || stack.Count > 0) {
+            if (cur != null) {
+                res.Add(cur.val);
+                stack.Push(cur.right);
+                cur = cur.left;
+            } else {
+                cur = stack.Pop();
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -458,6 +524,51 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public List<int> PreorderTraversal(TreeNode root) {
+        List<int> res = new List<int>();
+        TreeNode cur = root;
+
+        while (cur != null) {
+            if (cur.left == null) {
+                res.Add(cur.val);
+                cur = cur.right;
+            } else {
+                TreeNode prev = cur.left;
+                while (prev.right != null && prev.right != cur) {
+                    prev = prev.right;
+                }
+
+                if (prev.right == null) {
+                    res.Add(cur.val);
+                    prev.right = cur;
+                    cur = cur.left;
+                } else {
+                    prev.right = null;
+                    cur = cur.right;
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/capacity-to-ship-packages-within-d-days.md b/articles/capacity-to-ship-packages-within-d-days.md
index 9a5d4e777..dfc4f2146 100644
--- a/articles/capacity-to-ship-packages-within-d-days.md
+++ b/articles/capacity-to-ship-packages-within-d-days.md
@@ -97,6 +97,29 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int ShipWithinDays(int[] weights, int days) {
+        int res = weights.Max();
+        while (true) {
+            int ships = 1;
+            int cap = res;
+            foreach (int w in weights) {
+                if (cap - w < 0) {
+                    ships++;
+                    cap = res;
+                }
+                cap -= w;
+            }
+            if (ships <= days) {
+                return res;
+            }
+            res++;
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -258,6 +281,44 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int ShipWithinDays(int[] weights, int days) {
+        int l = weights.Max();
+        int r = weights.Sum();
+        int res = r;
+
+        bool CanShip(int cap) {
+            int ships = 1;
+            int currCap = cap;
+
+            foreach (int w in weights) {
+                if (currCap - w < 0) {
+                    ships++;
+                    if (ships > days) return false;
+                    currCap = cap;
+                }
+                currCap -= w;
+            }
+
+            return true;
+        }
+
+        while (l <= r) {
+            int cap = (l + r) / 2;
+            if (CanShip(cap)) {
+                res = Math.Min(res, cap);
+                r = cap - 1;
+            } else {
+                l = cap + 1;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/car-pooling.md b/articles/car-pooling.md
index 3eac0695d..df5745d6d 100644
--- a/articles/car-pooling.md
+++ b/articles/car-pooling.md
@@ -92,6 +92,28 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CarPooling(int[][] trips, int capacity) {
+        Array.Sort(trips, (a, b) => a[1].CompareTo(b[1]));
+
+        for (int i = 0; i < trips.Length; i++) {
+            int curPass = trips[i][0];
+            for (int j = 0; j < i; j++) {
+                if (trips[j][2] > trips[i][1]) {
+                    curPass += trips[j][0];
+                }
+            }
+            if (curPass > capacity) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -196,12 +218,12 @@ class Solution {
     carPooling(trips, capacity) {
         trips.sort((a, b) => a[1] - b[1]);
 
-        const minHeap = new MinPriorityQueue({ priority: x => x[0] }); // [end, numPassengers]
+        const minHeap = new MinPriorityQueue(x => x[0]); // [end, numPassengers]
         let curPass = 0;
 
         for (const [numPass, start, end] of trips) {
-            while (!minHeap.isEmpty() && minHeap.front().element[0] <= start) {
-                curPass -= minHeap.dequeue().element[1];
+            while (!minHeap.isEmpty() && minHeap.front()[0] <= start) {
+                curPass -= minHeap.dequeue()[1];
             }
 
             curPass += numPass;
@@ -217,6 +239,36 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CarPooling(int[][] trips, int capacity) {
+        Array.Sort(trips, (a, b) => a[1].CompareTo(b[1]));
+        
+        var minHeap = new PriorityQueue<int[], int>();
+        int curPass = 0;
+
+        foreach (var trip in trips) {
+            int numPass = trip[0];
+            int start = trip[1];
+            int end = trip[2];
+
+            while (minHeap.Count > 0 && minHeap.Peek()[0] <= start) {
+                curPass -= minHeap.Dequeue()[1];
+            }
+
+            curPass += numPass;
+            if (curPass > capacity) {
+                return false;
+            }
+
+            minHeap.Enqueue(new int[] { end, numPass }, end);
+        }
+
+        return true;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -330,6 +382,36 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CarPooling(int[][] trips, int capacity) {
+        List<int[]> points = new List<int[]>();
+        
+        foreach (var trip in trips) {
+            int passengers = trip[0];
+            int start = trip[1];
+            int end = trip[2];
+
+            points.Add(new int[] { start, passengers });
+            points.Add(new int[] { end, -passengers });
+        }
+
+        points.Sort((a, b) => {
+            if (a[0] == b[0]) return a[1] - b[1];
+            return a[0] - b[0];
+        });
+
+        int curPass = 0;
+        foreach (var point in points) {
+            curPass += point[1];
+            if (curPass > capacity) return false;
+        }
+
+        return true;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -459,6 +541,40 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CarPooling(int[][] trips, int capacity) {
+        int L = int.MaxValue, R = int.MinValue;
+
+        foreach (var trip in trips) {
+            int start = trip[1], end = trip[2];
+            L = Math.Min(L, start);
+            R = Math.Max(R, end);
+        }
+
+        int N = R - L + 1;
+        int[] passChange = new int[N + 1];
+
+        foreach (var trip in trips) {
+            int passengers = trip[0];
+            int start = trip[1];
+            int end = trip[2];
+
+            passChange[start - L] += passengers;
+            passChange[end - L] -= passengers;
+        }
+
+        int curPass = 0;
+        foreach (int change in passChange) {
+            curPass += change;
+            if (curPass > capacity) return false;
+        }
+
+        return true;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/combination-sum-iv.md b/articles/combination-sum-iv.md
index 3a607251c..b2d2c5386 100644
--- a/articles/combination-sum-iv.md
+++ b/articles/combination-sum-iv.md
@@ -97,6 +97,31 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int CombinationSum4(int[] nums, int target) {
+        Array.Sort(nums);
+        return Dfs(nums, target);
+    }
+
+    private int Dfs(int[] nums, int total) {
+        if (total == 0) {
+            return 1;
+        }
+
+        int res = 0;
+        foreach (int num in nums) {
+            if (total < num) {
+                break;
+            }
+            res += Dfs(nums, total - num);
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -222,6 +247,36 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private Dictionary<int, int> memo;
+
+    public int CombinationSum4(int[] nums, int target) {
+        Array.Sort(nums);
+        memo = new Dictionary<int, int>();
+        memo[0] = 1;
+        return Dfs(nums, target);
+    }
+
+    private int Dfs(int[] nums, int total) {
+        if (memo.ContainsKey(total)) {
+            return memo[total];
+        }
+
+        int res = 0;
+        foreach (int num in nums) {
+            if (total < num) {
+                break;
+            }
+            res += Dfs(nums, total - num);
+        }
+
+        memo[total] = res;
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -310,6 +365,26 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int CombinationSum4(int[] nums, int target) {
+        Dictionary<int, int> dp = new Dictionary<int, int>();
+        dp[0] = 1;
+
+        for (int total = 1; total <= target; total++) {
+            dp[total] = 0;
+            foreach (int num in nums) {
+                if (dp.ContainsKey(total - num)) {
+                    dp[total] += dp[total - num];
+                }
+            }
+        }
+
+        return dp[target];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -403,6 +478,30 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int CombinationSum4(int[] nums, int target) {
+        Array.Sort(nums);
+        Dictionary<int, int> dp = new Dictionary<int, int>();
+        dp[target] = 1;
+
+        for (int total = target; total > 0; total--) {
+            if (!dp.ContainsKey(total)) continue;
+            foreach (int num in nums) {
+                if (total < num) break;
+                int key = total - num;
+                if (!dp.ContainsKey(key)) {
+                    dp[key] = 0;
+                }
+                dp[key] += dp[total];
+            }
+        }
+
+        return dp.ContainsKey(0) ? dp[0] : 0;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/combinations-of-a-phone-number.md b/articles/combinations-of-a-phone-number.md
index 6f6bfd6dd..51796e3f7 100644
--- a/articles/combinations-of-a-phone-number.md
+++ b/articles/combinations-of-a-phone-number.md
@@ -1,4 +1,4 @@
-## 1. Bactracking
+## 1. Backtracking
 
 ::tabs-start
 
@@ -497,4 +497,4 @@ class Solution {
 * Time complexity: $O(n * 4 ^ n)$
 * Space complexity:
     * $O(n)$ extra space.
-    * $O(n * 4 ^ n)$ space for the output list.
\ No newline at end of file
+    * $O(n * 4 ^ n)$ space for the output list.
diff --git a/articles/combinations.md b/articles/combinations.md
index d5e838baf..321ffeab1 100644
--- a/articles/combinations.md
+++ b/articles/combinations.md
@@ -105,6 +105,31 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> Combine(int n, int k) {
+        List<List<int>> res = new List<List<int>>();
+        
+        void Backtrack(int i, List<int> comb) {
+            if (i > n) {
+                if (comb.Count == k) {
+                    res.Add(new List<int>(comb));
+                }
+                return;
+            }
+
+            comb.Add(i);
+            Backtrack(i + 1, comb);
+            comb.RemoveAt(comb.Count - 1);
+            Backtrack(i + 1, comb);
+        }
+
+        Backtrack(1, new List<int>());
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -220,6 +245,30 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> Combine(int n, int k) {
+        List<List<int>> res = new List<List<int>>();
+
+        void Backtrack(int start, List<int> comb) {
+            if (comb.Count == k) {
+                res.Add(new List<int>(comb));
+                return;
+            }
+
+            for (int i = start; i <= n; i++) {
+                comb.Add(i);
+                Backtrack(i + 1, comb);
+                comb.RemoveAt(comb.Count - 1);
+            }
+        }
+
+        Backtrack(1, new List<int>());
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -348,6 +397,33 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> Combine(int n, int k) {
+        List<List<int>> res = new List<List<int>>();
+        int[] comb = new int[k];
+        int i = 0;
+
+        while (i >= 0) {
+            comb[i]++;
+            if (comb[i] > n) {
+                i--;
+                continue;
+            }
+
+            if (i == k - 1) {
+                res.Add(new List<int>(comb));
+            } else {
+                i++;
+                comb[i] = comb[i - 1];
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -446,6 +522,28 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> Combine(int n, int k) {
+        List<List<int>> res = new List<List<int>>();
+
+        for (int mask = 0; mask < (1 << n); mask++) {
+            List<int> comb = new List<int>();
+            for (int bit = 0; bit < n; bit++) {
+                if ((mask & (1 << bit)) != 0) {
+                    comb.Add(bit + 1);
+                }
+            }
+            if (comb.Count == k) {
+                res.Add(comb);
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/construct-quad-tree.md b/articles/construct-quad-tree.md
index 48e117a86..5e2b91594 100644
--- a/articles/construct-quad-tree.md
+++ b/articles/construct-quad-tree.md
@@ -237,6 +237,76 @@ class Solution {
 }
 ```
 
+```csharp
+/*
+// Definition for a QuadTree node.
+public class Node {
+    public bool val;
+    public bool isLeaf;
+    public Node topLeft;
+    public Node topRight;
+    public Node bottomLeft;
+    public Node bottomRight;
+
+    public Node() {
+        val = false;
+        isLeaf = false;
+        topLeft = null;
+        topRight = null;
+        bottomLeft = null;
+        bottomRight = null;
+    }
+    
+    public Node(bool _val, bool _isLeaf) {
+        val = _val;
+        isLeaf = _isLeaf;
+        topLeft = null;
+        topRight = null;
+        bottomLeft = null;
+        bottomRight = null;
+    }
+    
+    public Node(bool _val,bool _isLeaf,Node _topLeft,Node _topRight,Node _bottomLeft,Node _bottomRight) {
+        val = _val;
+        isLeaf = _isLeaf;
+        topLeft = _topLeft;
+        topRight = _topRight;
+        bottomLeft = _bottomLeft;
+        bottomRight = _bottomRight;
+    }
+}
+*/
+
+public class Solution {
+    public Node Construct(int[][] grid) {
+        return Dfs(grid, grid.Length, 0, 0);
+    }
+
+    private Node Dfs(int[][] grid, int n, int r, int c) {
+        bool allSame = true;
+        for (int i = 0; i < n && allSame; i++) {
+            for (int j = 0; j < n && allSame; j++) {
+                if (grid[r][c] != grid[r + i][c + j]) {
+                    allSame = false;
+                }
+            }
+        }
+
+        if (allSame) {
+            return new Node(grid[r][c] == 1, true);
+        }
+
+        int half = n / 2;
+        Node topLeft = Dfs(grid, half, r, c);
+        Node topRight = Dfs(grid, half, r, c + half);
+        Node bottomLeft = Dfs(grid, half, r + half, c);
+        Node bottomRight = Dfs(grid, half, r + half, c + half);
+
+        return new Node(false, false, topLeft, topRight, bottomLeft, bottomRight);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -475,6 +545,75 @@ class Solution {
 }
 ```
 
+```csharp
+/*
+// Definition for a QuadTree node.
+public class Node {
+    public bool val;
+    public bool isLeaf;
+    public Node topLeft;
+    public Node topRight;
+    public Node bottomLeft;
+    public Node bottomRight;
+
+    public Node() {
+        val = false;
+        isLeaf = false;
+        topLeft = null;
+        topRight = null;
+        bottomLeft = null;
+        bottomRight = null;
+    }
+    
+    public Node(bool _val, bool _isLeaf) {
+        val = _val;
+        isLeaf = _isLeaf;
+        topLeft = null;
+        topRight = null;
+        bottomLeft = null;
+        bottomRight = null;
+    }
+    
+    public Node(bool _val,bool _isLeaf,Node _topLeft,Node _topRight,Node _bottomLeft,Node _bottomRight) {
+        val = _val;
+        isLeaf = _isLeaf;
+        topLeft = _topLeft;
+        topRight = _topRight;
+        bottomLeft = _bottomLeft;
+        bottomRight = _bottomRight;
+    }
+}
+*/
+
+public class Solution {
+    public Node Construct(int[][] grid) {
+        return Dfs(grid, grid.Length, 0, 0);
+    }
+
+    private Node Dfs(int[][] grid, int n, int r, int c) {
+        if (n == 1) {
+            return new Node(grid[r][c] == 1, true);
+        }
+
+        int mid = n / 2;
+        Node topLeft = Dfs(grid, mid, r, c);
+        Node topRight = Dfs(grid, mid, r, c + mid);
+        Node bottomLeft = Dfs(grid, mid, r + mid, c);
+        Node bottomRight = Dfs(grid, mid, r + mid, c + mid);
+
+        if (topLeft.isLeaf && topRight.isLeaf && 
+            bottomLeft.isLeaf && bottomRight.isLeaf &&
+            topLeft.val == topRight.val &&
+            topRight.val == bottomLeft.val &&
+            bottomLeft.val == bottomRight.val) {
+            return new Node(topLeft.val, true);
+        }
+
+        return new Node(false, false, topLeft, topRight, bottomLeft, bottomRight);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -725,6 +864,79 @@ class Solution {
 }
 ```
 
+```csharp
+/*
+// Definition for a QuadTree node.
+public class Node {
+    public bool val;
+    public bool isLeaf;
+    public Node topLeft;
+    public Node topRight;
+    public Node bottomLeft;
+    public Node bottomRight;
+
+    public Node() {
+        val = false;
+        isLeaf = false;
+        topLeft = null;
+        topRight = null;
+        bottomLeft = null;
+        bottomRight = null;
+    }
+    
+    public Node(bool _val, bool _isLeaf) {
+        val = _val;
+        isLeaf = _isLeaf;
+        topLeft = null;
+        topRight = null;
+        bottomLeft = null;
+        bottomRight = null;
+    }
+    
+    public Node(bool _val,bool _isLeaf,Node _topLeft,Node _topRight,Node _bottomLeft,Node _bottomRight) {
+        val = _val;
+        isLeaf = _isLeaf;
+        topLeft = _topLeft;
+        topRight = _topRight;
+        bottomLeft = _bottomLeft;
+        bottomRight = _bottomRight;
+    }
+}
+*/
+
+public class Solution {
+    private readonly Node falseLeaf = new Node(false, true);
+    private readonly Node trueLeaf = new Node(true, true);
+
+    public Node Construct(int[][] grid) {
+        int n = grid.Length;
+        return Dfs(grid, n, 0, 0);
+    }
+
+    private Node Dfs(int[][] grid, int n, int r, int c) {
+        if (n == 1) {
+            return grid[r][c] == 1 ? trueLeaf : falseLeaf;
+        }
+
+        int half = n / 2;
+        Node topLeft = Dfs(grid, half, r, c);
+        Node topRight = Dfs(grid, half, r, c + half);
+        Node bottomLeft = Dfs(grid, half, r + half, c);
+        Node bottomRight = Dfs(grid, half, r + half, c + half);
+
+        if (topLeft.isLeaf && topRight.isLeaf &&
+            bottomLeft.isLeaf && bottomRight.isLeaf &&
+            topLeft.val == topRight.val &&
+            topLeft.val == bottomLeft.val &&
+            topLeft.val == bottomRight.val) {
+            return topLeft;
+        }
+
+        return new Node(false, false, topLeft, topRight, bottomLeft, bottomRight);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/contains-duplicate-ii.md b/articles/contains-duplicate-ii.md
index 9e1c9367e..cc98d9da1 100644
--- a/articles/contains-duplicate-ii.md
+++ b/articles/contains-duplicate-ii.md
@@ -63,6 +63,21 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool ContainsNearbyDuplicate(int[] nums, int k) {
+        for (int L = 0; L < nums.Length; L++) {
+            for (int R = L + 1; R < Math.Min(nums.Length, L + k + 1); R++) {
+                if (nums[L] == nums[R]) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -148,6 +163,23 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool ContainsNearbyDuplicate(int[] nums, int k) {
+        Dictionary<int, int> mp = new Dictionary<int, int>();
+
+        for (int i = 0; i < nums.Length; i++) {
+            if (mp.ContainsKey(nums[i]) && i - mp[nums[i]] <= k) {
+                return true;
+            }
+            mp[nums[i]] = i;
+        }
+        
+        return false;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -249,6 +281,28 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool ContainsNearbyDuplicate(int[] nums, int k) {
+        HashSet<int> window = new HashSet<int>();
+        int L = 0;
+
+        for (int R = 0; R < nums.Length; R++) {
+            if (R - L > k) {
+                window.Remove(nums[L]);
+                L++;
+            }
+            if (window.Contains(nums[R])) {
+                return true;
+            }
+            window.Add(nums[R]);
+        }
+        
+        return false;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/course-schedule-iv.md b/articles/course-schedule-iv.md
index 0768d9038..0738453e4 100644
--- a/articles/course-schedule-iv.md
+++ b/articles/course-schedule-iv.md
@@ -109,6 +109,35 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<bool> CheckIfPrerequisite(int numCourses, int[][] prerequisites, int[][] queries) {
+        List<int>[] adj = new List<int>[numCourses];
+        for (int i = 0; i < numCourses; i++) {
+            adj[i] = new List<int>();
+        }
+
+        foreach (var pre in prerequisites) {
+            adj[pre[0]].Add(pre[1]);
+        }
+
+        bool Dfs(int node, int target) {
+            if (node == target) return true;
+            foreach (var nei in adj[node]) {
+                if (Dfs(nei, target)) return true;
+            }
+            return false;
+        }
+
+        var res = new List<bool>();
+        foreach (var q in queries) {
+            res.Add(Dfs(q[0], q[1]));
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -259,6 +288,46 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<bool> CheckIfPrerequisite(int numCourses, int[][] prerequisites, int[][] queries) {
+        Dictionary<int, List<int>> adj = new Dictionary<int, List<int>>();
+        for (int i = 0; i < numCourses; i++) {
+            adj[i] = new List<int>();
+        }
+
+        foreach (var pair in prerequisites) {
+            int prereq = pair[0], crs = pair[1];
+            adj[crs].Add(prereq);
+        }
+
+        Dictionary<int, HashSet<int>> prereqMap = new Dictionary<int, HashSet<int>>();
+
+        HashSet<int> Dfs(int crs) {
+            if (!prereqMap.ContainsKey(crs)) {
+                prereqMap[crs] = new HashSet<int>();
+                foreach (var prereq in adj[crs]) {
+                    prereqMap[crs].UnionWith(Dfs(prereq));
+                }
+                prereqMap[crs].Add(crs);
+            }
+            return prereqMap[crs];
+        }
+
+        for (int crs = 0; crs < numCourses; crs++) {
+            Dfs(crs);
+        }
+
+        List<bool> res = new List<bool>();
+        foreach (var q in queries) {
+            res.Add(prereqMap.ContainsKey(q[1]) && prereqMap[q[1]].Contains(q[0]));
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -416,6 +485,53 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<bool> CheckIfPrerequisite(int numCourses, int[][] prerequisites, int[][] queries) {
+        List<int>[] adj = new List<int>[numCourses];
+        for (int i = 0; i < numCourses; i++) {
+            adj[i] = new List<int>();
+        }
+
+        int[,] isPrereq = new int[numCourses, numCourses];
+        for (int i = 0; i < numCourses; i++) {
+            for (int j = 0; j < numCourses; j++) {
+                isPrereq[i, j] = -1;
+            }
+        }
+
+        foreach (var pair in prerequisites) {
+            int prereq = pair[0], crs = pair[1];
+            adj[crs].Add(prereq);
+            isPrereq[crs, prereq] = 1;
+        }
+
+        bool Dfs(int crs, int prereq) {
+            if (isPrereq[crs, prereq] != -1) {
+                return isPrereq[crs, prereq] == 1;
+            }
+
+            foreach (int pre in adj[crs]) {
+                if (pre == prereq || Dfs(pre, prereq)) {
+                    isPrereq[crs, prereq] = 1;
+                    return true;
+                }
+            }
+
+            isPrereq[crs, prereq] = 0;
+            return false;
+        }
+
+        List<bool> res = new List<bool>();
+        foreach (var q in queries) {
+            res.Add(Dfs(q[1], q[0]));
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -572,6 +688,56 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<bool> CheckIfPrerequisite(int numCourses, int[][] prerequisites, int[][] queries) {
+        List<HashSet<int>> adj = new List<HashSet<int>>();
+        List<HashSet<int>> isPrereq = new List<HashSet<int>>();
+        int[] indegree = new int[numCourses];
+
+        for (int i = 0; i < numCourses; i++) {
+            adj.Add(new HashSet<int>());
+            isPrereq.Add(new HashSet<int>());
+        }
+
+        foreach (var pair in prerequisites) {
+            int pre = pair[0], crs = pair[1];
+            adj[pre].Add(crs);
+            indegree[crs]++;
+        }
+
+        Queue<int> q = new Queue<int>();
+        for (int i = 0; i < numCourses; i++) {
+            if (indegree[i] == 0) {
+                q.Enqueue(i);
+            }
+        }
+
+        while (q.Count > 0) {
+            int node = q.Dequeue();
+            foreach (int neighbor in adj[node]) {
+                isPrereq[neighbor].Add(node);
+                foreach (int p in isPrereq[node]) {
+                    isPrereq[neighbor].Add(p);
+                }
+                indegree[neighbor]--;
+                if (indegree[neighbor] == 0) {
+                    q.Enqueue(neighbor);
+                }
+            }
+        }
+
+        List<bool> result = new List<bool>();
+        foreach (var query in queries) {
+            int u = query[0], v = query[1];
+            result.Add(isPrereq[v].Contains(u));
+        }
+
+        return result;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -695,6 +861,35 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<bool> CheckIfPrerequisite(int numCourses, int[][] prerequisites, int[][] queries) {
+        bool[,] adj = new bool[numCourses, numCourses];
+
+        foreach (var pair in prerequisites) {
+            int pre = pair[0], crs = pair[1];
+            adj[pre, crs] = true;
+        }
+
+        for (int k = 0; k < numCourses; k++) {
+            for (int i = 0; i < numCourses; i++) {
+                for (int j = 0; j < numCourses; j++) {
+                    adj[i, j] = adj[i, j] || (adj[i, k] && adj[k, j]);
+                }
+            }
+        }
+
+        List<bool> res = new List<bool>();
+        foreach (var query in queries) {
+            int u = query[0], v = query[1];
+            res.Add(adj[u, v]);
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/decode-string.md b/articles/decode-string.md
index c5363f71b..c86b9b8f1 100644
--- a/articles/decode-string.md
+++ b/articles/decode-string.md
@@ -143,6 +143,46 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private int i;
+
+    public string DecodeString(string s) {
+        i = 0;
+        return Helper(s);
+    }
+
+    private string Helper(string s) {
+        string res = "";
+        int k = 0;
+
+        while (i < s.Length) {
+            char c = s[i];
+
+            if (char.IsDigit(c)) {
+                k = k * 10 + (c - '0');
+            } else if (c == '[') {
+                i++;
+                string inner = Helper(s);
+                res += new string(' ', 0).PadLeft(0);
+                for (int j = 0; j < k; j++) {
+                    res += inner;
+                }
+                k = 0;
+            } else if (c == ']') {
+                return res;
+            } else {
+                res += c;
+            }
+
+            i++;
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -290,6 +330,41 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string DecodeString(string s) {
+        Stack<string> stack = new Stack<string>();
+
+        for (int i = 0; i < s.Length; i++) {
+            if (s[i] != ']') {
+                stack.Push(s[i].ToString());
+            } else {
+                string substr = "";
+                while (stack.Peek() != "[") {
+                    substr = stack.Pop() + substr;
+                }
+                stack.Pop(); // remove '['
+
+                string k = "";
+                while (stack.Count > 0 && char.IsDigit(stack.Peek()[0])) {
+                    k = stack.Pop() + k;
+                }
+
+                int repeat = int.Parse(k);
+                string expanded = new StringBuilder().Insert(0, substr, repeat).ToString();
+                stack.Push(expanded);
+            }
+        }
+
+        var result = new StringBuilder();
+        foreach (string part in stack) {
+            result.Insert(0, part);
+        }
+        return result.ToString();
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -436,6 +511,39 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string DecodeString(string s) {
+        Stack<string> stringStack = new Stack<string>();
+        Stack<int> countStack = new Stack<int>();
+        string cur = "";
+        int k = 0;
+
+        foreach (char c in s) {
+            if (char.IsDigit(c)) {
+                k = k * 10 + (c - '0');
+            } else if (c == '[') {
+                stringStack.Push(cur);
+                countStack.Push(k);
+                cur = "";
+                k = 0;
+            } else if (c == ']') {
+                string temp = cur;
+                cur = stringStack.Pop();
+                int count = countStack.Pop();
+                for (int i = 0; i < count; i++) {
+                    cur += temp;
+                }
+            } else {
+                cur += c;
+            }
+        }
+
+        return cur;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/delete-leaves-with-a-given-value.md b/articles/delete-leaves-with-a-given-value.md
index ccfb4637b..add3a0494 100644
--- a/articles/delete-leaves-with-a-given-value.md
+++ b/articles/delete-leaves-with-a-given-value.md
@@ -122,6 +122,36 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public TreeNode RemoveLeafNodes(TreeNode root, int target) {
+        if (root == null) return null;
+
+        root.left = RemoveLeafNodes(root.left, target);
+        root.right = RemoveLeafNodes(root.right, target);
+
+        if (root.left == null && root.right == null && root.val == target) {
+            return null;
+        }
+
+        return root;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -343,6 +373,62 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public TreeNode RemoveLeafNodes(TreeNode root, int target) {
+        if (root == null) return null;
+
+        Stack<TreeNode> stack = new Stack<TreeNode>();
+        HashSet<TreeNode> visited = new HashSet<TreeNode>();
+        Dictionary<TreeNode, TreeNode> parents = new Dictionary<TreeNode, TreeNode>();
+
+        stack.Push(root);
+        parents[root] = null;
+
+        while (stack.Count > 0) {
+            TreeNode node = stack.Pop();
+
+            if (node.left == null && node.right == null) {
+                if (node.val == target) {
+                    TreeNode parent = parents[node];
+                    if (parent == null) {
+                        return null;
+                    }
+                    if (parent.left == node) parent.left = null;
+                    if (parent.right == node) parent.right = null;
+                }
+            } else if (!visited.Contains(node)) {
+                visited.Add(node);
+                stack.Push(node);
+                if (node.left != null) {
+                    stack.Push(node.left);
+                    parents[node.left] = node;
+                }
+                if (node.right != null) {
+                    stack.Push(node.right);
+                    parents[node.right] = node;
+                }
+            }
+        }
+
+        return root;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -569,6 +655,62 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public TreeNode RemoveLeafNodes(TreeNode root, int target) {
+        if (root == null) return null;
+
+        Stack<TreeNode> stack = new Stack<TreeNode>();
+        TreeNode cur = root;
+        TreeNode visited = null;
+
+        while (stack.Count > 0 || cur != null) {
+            while (cur != null) {
+                stack.Push(cur);
+                cur = cur.left;
+            }
+
+            cur = stack.Peek();
+            if (cur.right != null && cur.right != visited) {
+                cur = cur.right;
+                continue;
+            }
+
+            stack.Pop();
+            if (cur.left == null && cur.right == null && cur.val == target) {
+                if (stack.Count == 0) return null;
+
+                TreeNode parent = stack.Peek();
+                if (parent.left == cur) {
+                    parent.left = null;
+                } else if (parent.right == cur) {
+                    parent.right = null;
+                }
+            } else {
+                visited = cur;
+            }
+
+            cur = null;
+        }
+
+        return root;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/delete-node-in-a-bst.md b/articles/delete-node-in-a-bst.md
index 4b086145a..0a9617193 100644
--- a/articles/delete-node-in-a-bst.md
+++ b/articles/delete-node-in-a-bst.md
@@ -153,6 +153,45 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public TreeNode DeleteNode(TreeNode root, int key) {
+        if (root == null) return null;
+
+        if (key > root.val) {
+            root.right = DeleteNode(root.right, key);
+        } else if (key < root.val) {
+            root.left = DeleteNode(root.left, key);
+        } else {
+            if (root.left == null) return root.right;
+            if (root.right == null) return root.left;
+
+            TreeNode cur = root.right;
+            while (cur.left != null) {
+                cur = cur.left;
+            }
+            root.val = cur.val;
+            root.right = DeleteNode(root.right, root.val);
+        }
+
+        return root;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -327,6 +366,46 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public TreeNode DeleteNode(TreeNode root, int key) {
+        if (root == null) return null;
+
+        if (key > root.val) {
+            root.right = DeleteNode(root.right, key);
+        } else if (key < root.val) {
+            root.left = DeleteNode(root.left, key);
+        } else {
+            if (root.left == null) return root.right;
+            if (root.right == null) return root.left;
+
+            TreeNode cur = root.right;
+            while (cur.left != null) {
+                cur = cur.left;
+            }
+            cur.left = root.left;
+            TreeNode res = root.right;
+            return res;
+        }
+
+        return root;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -622,6 +701,85 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public TreeNode DeleteNode(TreeNode root, int key) {
+        if (root == null) return null;
+
+        TreeNode parent = null;
+        TreeNode cur = root;
+
+        // Find the node to delete
+        while (cur != null && cur.val != key) {
+            parent = cur;
+            if (key > cur.val) {
+                cur = cur.right;
+            } else {
+                cur = cur.left;
+            }
+        }
+
+        if (cur == null) return root;
+
+        // Node with one or no child
+        if (cur.left == null || cur.right == null) {
+            TreeNode child = cur.left != null ? cur.left : cur.right;
+
+            if (parent == null) {
+                return child;
+            }
+
+            if (parent.left == cur) {
+                parent.left = child;
+            } else {
+                parent.right = child;
+            }
+        } else {
+            // Node with two children
+            TreeNode par = null;
+            TreeNode delNode = cur;
+            cur = cur.right;
+            while (cur.left != null) {
+                par = cur;
+                cur = cur.left;
+            }
+
+            if (par != null) {
+                par.left = cur.right;
+                cur.right = delNode.right;
+            }
+
+            cur.left = delNode.left;
+
+            if (parent == null) {
+                return cur;
+            }
+
+            if (parent.left == delNode) {
+                parent.left = cur;
+            } else {
+                parent.right = cur;
+            }
+        }
+
+        return root;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/evaluate-division.md b/articles/evaluate-division.md
index 647a8002b..9be40ad06 100644
--- a/articles/evaluate-division.md
+++ b/articles/evaluate-division.md
@@ -199,6 +199,56 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public double[] CalcEquation(List<List<string>> equations, double[] values, List<List<string>> queries) {
+        var adj = new Dictionary<string, List<(string, double)>>();
+
+        for (int i = 0; i < equations.Count; i++) {
+            string a = equations[i][0];
+            string b = equations[i][1];
+            double val = values[i];
+
+            if (!adj.ContainsKey(a)) adj[a] = new List<(string, double)>();
+            if (!adj.ContainsKey(b)) adj[b] = new List<(string, double)>();
+
+            adj[a].Add((b, val));
+            adj[b].Add((a, 1.0 / val));
+        }
+
+        double Bfs(string src, string target) {
+            if (!adj.ContainsKey(src) || !adj.ContainsKey(target)) return -1.0;
+            var queue = new Queue<(string, double)>();
+            var visited = new HashSet<string>();
+
+            queue.Enqueue((src, 1.0));
+            visited.Add(src);
+
+            while (queue.Count > 0) {
+                var (node, weight) = queue.Dequeue();
+                if (node == target) return weight;
+
+                foreach (var (nei, w) in adj[node]) {
+                    if (!visited.Contains(nei)) {
+                        visited.Add(nei);
+                        queue.Enqueue((nei, weight * w));
+                    }
+                }
+            }
+
+            return -1.0;
+        }
+
+        double[] res = new double[queries.Count];
+        for (int i = 0; i < queries.Count; i++) {
+            res[i] = Bfs(queries[i][0], queries[i][1]);
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -391,6 +441,51 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public double[] CalcEquation(List<List<string>> equations, double[] values, List<List<string>> queries) {
+        var adj = new Dictionary<string, List<(string, double)>>();
+
+        for (int i = 0; i < equations.Count; i++) {
+            string a = equations[i][0], b = equations[i][1];
+            double val = values[i];
+
+            if (!adj.ContainsKey(a)) adj[a] = new List<(string, double)>();
+            if (!adj.ContainsKey(b)) adj[b] = new List<(string, double)>();
+
+            adj[a].Add((b, val));
+            adj[b].Add((a, 1.0 / val));
+        }
+
+        double Dfs(string src, string target, HashSet<string> visited) {
+            if (!adj.ContainsKey(src) || !adj.ContainsKey(target)) return -1.0;
+            if (src == target) return 1.0;
+
+            visited.Add(src);
+
+            foreach (var (nei, weight) in adj[src]) {
+                if (!visited.Contains(nei)) {
+                    double result = Dfs(nei, target, visited);
+                    if (result != -1.0) {
+                        return weight * result;
+                    }
+                }
+            }
+
+            return -1.0;
+        }
+
+        double[] res = new double[queries.Count];
+        for (int i = 0; i < queries.Count; i++) {
+            var visited = new HashSet<string>();
+            res[i] = Dfs(queries[i][0], queries[i][1], visited);
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -666,6 +761,69 @@ class Solution {
 }
 ```
 
+```csharp
+public class UnionFind {
+    private Dictionary<string, string> parent = new Dictionary<string, string>();
+    private Dictionary<string, double> weight = new Dictionary<string, double>();
+
+    public void Add(string x) {
+        if (!parent.ContainsKey(x)) {
+            parent[x] = x;
+            weight[x] = 1.0;
+        }
+    }
+
+    public string Find(string x) {
+        if (parent[x] != x) {
+            string origParent = parent[x];
+            parent[x] = Find(origParent);
+            weight[x] *= weight[origParent];
+        }
+        return parent[x];
+    }
+
+    public void Union(string x, string y, double value) {
+        Add(x);
+        Add(y);
+        string rootX = Find(x);
+        string rootY = Find(y);
+
+        if (rootX != rootY) {
+            parent[rootX] = rootY;
+            weight[rootX] = value * weight[y] / weight[x];
+        }
+    }
+
+    public double GetRatio(string x, string y) {
+        if (!parent.ContainsKey(x) || !parent.ContainsKey(y) || Find(x) != Find(y)) {
+            return -1.0;
+        }
+        return weight[x] / weight[y];
+    }
+}
+
+public class Solution {
+    public double[] CalcEquation(List<List<string>> equations, double[] values, List<List<string>> queries) {
+        var uf = new UnionFind();
+        
+        for (int i = 0; i < equations.Count; i++) {
+            string a = equations[i][0];
+            string b = equations[i][1];
+            uf.Union(a, b, values[i]);
+        }
+
+        double[] res = new double[queries.Count];
+        for (int i = 0; i < queries.Count; i++) {
+            string a = queries[i][0];
+            string b = queries[i][1];
+            res[i] = uf.GetRatio(a, b);
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -826,6 +984,49 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public double[] CalcEquation(List<List<string>> equations, double[] values, List<List<string>> queries) {
+        var graph = new Dictionary<string, Dictionary<string, double>>();
+
+        for (int i = 0; i < equations.Count; i++) {
+            string a = equations[i][0];
+            string b = equations[i][1];
+            double val = values[i];
+
+            if (!graph.ContainsKey(a)) graph[a] = new Dictionary<string, double>();
+            if (!graph.ContainsKey(b)) graph[b] = new Dictionary<string, double>();
+
+            graph[a][b] = val;
+            graph[b][a] = 1.0 / val;
+        }
+
+        foreach (var k in graph.Keys.ToList()) {
+            foreach (var i in graph[k].Keys.ToList()) {
+                foreach (var j in graph[k].Keys.ToList()) {
+                    if (!graph[i].ContainsKey(j)) {
+                        graph[i][j] = graph[i][k] * graph[k][j];
+                    }
+                }
+            }
+        }
+
+        double[] result = new double[queries.Count];
+        for (int i = 0; i < queries.Count; i++) {
+            string a = queries[i][0];
+            string b = queries[i][1];
+            if (graph.ContainsKey(a) && graph[a].ContainsKey(b)) {
+                result[i] = graph[a][b];
+            } else {
+                result[i] = -1.0;
+            }
+        }
+
+        return result;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/extra-characters-in-a-string.md b/articles/extra-characters-in-a-string.md
index b41af1f45..6b2052693 100644
--- a/articles/extra-characters-in-a-string.md
+++ b/articles/extra-characters-in-a-string.md
@@ -104,6 +104,30 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MinExtraChar(string s, string[] dictionary) {
+        HashSet<string> words = new HashSet<string>(dictionary);
+        return Dfs(0, s, words);
+    }
+
+    private int Dfs(int i, string s, HashSet<string> words) {
+        if (i == s.Length) {
+            return 0;
+        }
+
+        int res = 1 + Dfs(i + 1, s, words);
+        for (int j = i; j < s.Length; j++) {
+            if (words.Contains(s.Substring(i, j - i + 1))) {
+                res = Math.Min(res, Dfs(j + 1, s, words));
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -220,6 +244,34 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MinExtraChar(string s, string[] dictionary) {
+        HashSet<string> words = new HashSet<string>(dictionary);
+        int n = s.Length;
+        int[] dp = new int[n + 1];
+        Array.Fill(dp, -1);
+        dp[n] = 0;
+
+        return Dfs(0, s, words, dp);
+    }
+
+    private int Dfs(int i, string s, HashSet<string> words, int[] dp) {
+        if (dp[i] != -1) return dp[i];
+
+        int res = 1 + Dfs(i + 1, s, words, dp);
+        for (int j = i; j < s.Length; j++) {
+            if (words.Contains(s.Substring(i, j - i + 1))) {
+                res = Math.Min(res, Dfs(j + 1, s, words, dp));
+            }
+        }
+
+        dp[i] = res;
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -316,6 +368,27 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MinExtraChar(string s, string[] dictionary) {
+        HashSet<string> words = new HashSet<string>(dictionary);
+        int n = s.Length;
+        int[] dp = new int[n + 1];
+
+        for (int i = n - 1; i >= 0; i--) {
+            dp[i] = 1 + dp[i + 1];
+            for (int j = i; j < n; j++) {
+                if (words.Contains(s.Substring(i, j - i + 1))) {
+                    dp[i] = Math.Min(dp[i], dp[j + 1]);
+                }
+            }
+        }
+
+        return dp[0];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -467,6 +540,43 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MinExtraChar(string s, string[] dictionary) {
+        Dictionary<int, int> dp = new Dictionary<int, int>();
+        dp[s.Length] = 0;
+        return Dfs(0, s, dictionary, dp);
+    }
+
+    private int Dfs(int i, string s, string[] dictionary, Dictionary<int, int> dp) {
+        if (dp.ContainsKey(i)) {
+            return dp[i];
+        }
+
+        int res = 1 + Dfs(i + 1, s, dictionary, dp);
+
+        foreach (string word in dictionary) {
+            if (i + word.Length > s.Length) continue;
+
+            bool flag = true;
+            for (int j = 0; j < word.Length; j++) {
+                if (s[i + j] != word[j]) {
+                    flag = false;
+                    break;
+                }
+            }
+
+            if (flag) {
+                res = Math.Min(res, Dfs(i + word.Length, s, dictionary, dp));
+            }
+        }
+
+        dp[i] = res;
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -563,6 +673,26 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MinExtraChar(string s, string[] dictionary) {
+        int n = s.Length;
+        int[] dp = new int[n + 1];
+
+        for (int i = n - 1; i >= 0; i--) {
+            dp[i] = 1 + dp[i + 1];
+            foreach (string word in dictionary) {
+                if (i + word.Length <= n && s.Substring(i, word.Length) == word) {
+                    dp[i] = Math.Min(dp[i], dp[i + word.Length]);
+                }
+            }
+        }
+
+        return dp[0];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -819,6 +949,63 @@ class Solution {
 }
 ```
 
+```csharp
+public class TrieNode {
+    public TrieNode[] Children = new TrieNode[26];
+    public bool IsWord = false;
+}
+
+public class Trie {
+    public TrieNode Root = new TrieNode();
+
+    public void AddWord(string word) {
+        TrieNode curr = Root;
+        foreach (char c in word) {
+            int idx = c - 'a';
+            if (curr.Children[idx] == null) {
+                curr.Children[idx] = new TrieNode();
+            }
+            curr = curr.Children[idx];
+        }
+        curr.IsWord = true;
+    }
+}
+
+public class Solution {
+    public int MinExtraChar(string s, string[] dictionary) {
+        Trie trie = new Trie();
+        foreach (string word in dictionary) {
+            trie.AddWord(word);
+        }
+
+        int[] dp = new int[s.Length + 1];
+        Array.Fill(dp, -1);
+
+        return Dfs(0, s, trie, dp);
+    }
+
+    private int Dfs(int i, string s, Trie trie, int[] dp) {
+        if (i == s.Length) return 0;
+        if (dp[i] != -1) return dp[i];
+
+        int res = 1 + Dfs(i + 1, s, trie, dp);
+        TrieNode curr = trie.Root;
+
+        for (int j = i; j < s.Length; j++) {
+            int idx = s[j] - 'a';
+            if (curr.Children[idx] == null) break;
+            curr = curr.Children[idx];
+            if (curr.IsWord) {
+                res = Math.Min(res, Dfs(j + 1, s, trie, dp));
+            }
+        }
+
+        dp[i] = res;
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1052,6 +1239,57 @@ class Solution {
 }
 ```
 
+```csharp
+public class TrieNode {
+    public TrieNode[] Children = new TrieNode[26];
+    public bool IsWord = false;
+}
+
+public class Trie {
+    public TrieNode Root = new TrieNode();
+
+    public void AddWord(string word) {
+        TrieNode curr = Root;
+        foreach (char c in word) {
+            int idx = c - 'a';
+            if (curr.Children[idx] == null) {
+                curr.Children[idx] = new TrieNode();
+            }
+            curr = curr.Children[idx];
+        }
+        curr.IsWord = true;
+    }
+}
+
+public class Solution {
+    public int MinExtraChar(string s, string[] dictionary) {
+        Trie trie = new Trie();
+        foreach (string word in dictionary) {
+            trie.AddWord(word);
+        }
+
+        int n = s.Length;
+        int[] dp = new int[n + 1];
+
+        for (int i = n - 1; i >= 0; i--) {
+            dp[i] = 1 + dp[i + 1];
+            TrieNode curr = trie.Root;
+
+            for (int j = i; j < n; j++) {
+                int idx = s[j] - 'a';
+                if (curr.Children[idx] == null) break;
+                curr = curr.Children[idx];
+                if (curr.IsWord) {
+                    dp[i] = Math.Min(dp[i], dp[j + 1]);
+                }
+            }
+        }
+
+        return dp[0];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/find-in-mountain-array.md b/articles/find-in-mountain-array.md
index f687ba271..c917a7507 100644
--- a/articles/find-in-mountain-array.md
+++ b/articles/find-in-mountain-array.md
@@ -78,18 +78,18 @@ public:
 /**
  * // This is the MountainArray's API interface.
  * // You should not implement it, or speculate about its implementation
- * function MountainArray() {
+ * class MountainArray {
  *     @param {number} index
  *     @return {number}
- *     this.get = function(index) {
+ *     get(index) {
  *         ...
- *     };
+ *     }
  *
  *     @return {number}
- *     this.length = function() {
+ *     length() {
  *         ...
- *     };
- * };
+ *     }
+ * }
  */
 
 class Solution {
@@ -112,6 +112,31 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * // This is MountainArray's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class MountainArray {
+ *     public int Get(int index) {}
+ *     public int Length() {}
+ * }
+ */
+
+class Solution {
+    public int FindInMountainArray(int target, MountainArray mountainArr) {
+        int n = mountainArr.Length();
+
+        for (int i = 0; i < n; i++) {
+            if (mountainArr.Get(i) == target) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -316,18 +341,18 @@ public:
 /**
  * // This is the MountainArray's API interface.
  * // You should not implement it, or speculate about its implementation
- * function MountainArray() {
+ * class MountainArray {
  *     @param {number} index
  *     @return {number}
- *     this.get = function(index) {
+ *     get(index) {
  *         ...
- *     };
+ *     }
  *
  *     @return {number}
- *     this.length = function() {
+ *     length() {
  *         ...
- *     };
- * };
+ *     }
+ * }
  */
 
 class Solution {
@@ -391,6 +416,72 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * // This is MountainArray's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class MountainArray {
+ *     public int Get(int index) {}
+ *     public int Length() {}
+ * }
+ */
+
+class Solution {
+    public int FindInMountainArray(int target, MountainArray mountainArr) {
+        int length = mountainArr.Length();
+
+        // Find Peak
+        int l = 1, r = length - 2, peak = 0;
+        while (l <= r) {
+            int m = (l + r) / 2;
+            int left = mountainArr.Get(m - 1);
+            int mid = mountainArr.Get(m);
+            int right = mountainArr.Get(m + 1);
+            if (left < mid && mid < right) {
+                l = m + 1;
+            } else if (left > mid && mid > right) {
+                r = m - 1;
+            } else {
+                peak = m;
+                break;
+            }
+        }
+
+        // Search left portion
+        l = 0;
+        r = peak - 1;
+        while (l <= r) {
+            int m = (l + r) / 2;
+            int val = mountainArr.Get(m);
+            if (val < target) {
+                l = m + 1;
+            } else if (val > target) {
+                r = m - 1;
+            } else {
+                return m;
+            }
+        }
+
+        // Search right portion
+        l = peak;
+        r = length - 1;
+        while (l <= r) {
+            int m = (l + r) / 2;
+            int val = mountainArr.Get(m);
+            if (val > target) {
+                l = m + 1;
+            } else if (val < target) {
+                r = m - 1;
+            } else {
+                return m;
+            }
+        }
+
+        return -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -600,18 +691,18 @@ public:
 /**
  * // This is the MountainArray's API interface.
  * // You should not implement it, or speculate about its implementation
- * function MountainArray() {
+ * class MountainArray {
  *     @param {number} index
  *     @return {number}
- *     this.get = function(index) {
+ *     get(index) {
  *         ...
- *     };
+ *     }
  *
  *     @return {number}
- *     this.length = function() {
+ *     length() {
  *         ...
- *     };
- * };
+ *     }
+ * }
  */
 
 class Solution {
@@ -676,6 +767,73 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * // This is MountainArray's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * class MountainArray {
+ *     public int Get(int index) {}
+ *     public int Length() {}
+ * }
+ */
+
+class Solution {
+    private Dictionary<int, int> cache = new Dictionary<int, int>();
+
+    private int Get(int index, MountainArray mountainArr) {
+        if (!cache.ContainsKey(index)) {
+            cache[index] = mountainArr.Get(index);
+        }
+        return cache[index];
+    }
+
+    private int BinarySearch(int l, int r, bool ascending, MountainArray mountainArr, int target) {
+        while (l <= r) {
+            int m = (l + r) >> 1;
+            int val = Get(m, mountainArr);
+            if (val == target) {
+                return m;
+            }
+            if ((ascending && val < target) || (!ascending && val > target)) {
+                l = m + 1;
+            } else {
+                r = m - 1;
+            }
+        }
+        return -1;
+    }
+
+    public int FindInMountainArray(int target, MountainArray mountainArr) {
+        int length = mountainArr.Length();
+
+        // Find Peak
+        int l = 1, r = length - 2, peak = 0;
+        while (l <= r) {
+            int m = (l + r) >> 1;
+            int left = Get(m - 1, mountainArr);
+            int mid = Get(m, mountainArr);
+            int right = Get(m + 1, mountainArr);
+
+            if (left < mid && mid < right) {
+                l = m + 1;
+            } else if (left > mid && mid > right) {
+                r = m - 1;
+            } else {
+                peak = m;
+                break;
+            }
+        }
+
+        // Search left portion
+        int res = BinarySearch(0, peak, true, mountainArr, target);
+        if (res != -1) return res;
+
+        // Search right portion
+        return BinarySearch(peak, length - 1, false, mountainArr, target);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/find-the-town-judge.md b/articles/find-the-town-judge.md
index 393448cd8..a1343bd35 100644
--- a/articles/find-the-town-judge.md
+++ b/articles/find-the-town-judge.md
@@ -89,6 +89,30 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int FindJudge(int n, int[][] trust) {
+        int[] incoming = new int[n + 1];
+        int[] outgoing = new int[n + 1];
+
+        foreach (int[] t in trust) {
+            int a = t[0];
+            int b = t[1];
+            outgoing[a]++;
+            incoming[b]++;
+        }
+
+        for (int i = 1; i <= n; i++) {
+            if (outgoing[i] == 0 && incoming[i] == n - 1) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -189,6 +213,28 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int FindJudge(int n, int[][] trust) {
+        int[] delta = new int[n + 1];
+
+        foreach (int[] t in trust) {
+            int a = t[0];
+            int b = t[1];
+            delta[a]--;
+            delta[b]++;
+        }
+
+        for (int i = 1; i <= n; i++) {
+            if (delta[i] == n - 1) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/greatest-common-divisor-traversal.md b/articles/greatest-common-divisor-traversal.md
index 79c11cf70..57628c98a 100644
--- a/articles/greatest-common-divisor-traversal.md
+++ b/articles/greatest-common-divisor-traversal.md
@@ -144,6 +144,53 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CanTraverseAllPairs(int[] nums) {
+        int n = nums.Length;
+        bool[] visited = new bool[n];
+        List<int>[] adj = new List<int>[n];
+        for (int i = 0; i < n; i++) {
+            adj[i] = new List<int>();
+        }
+
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if (GCD(nums[i], nums[j]) > 1) {
+                    adj[i].Add(j);
+                    adj[j].Add(i);
+                }
+            }
+        }
+
+        void DFS(int node) {
+            visited[node] = true;
+            foreach (int neighbor in adj[node]) {
+                if (!visited[neighbor]) {
+                    DFS(neighbor);
+                }
+            }
+        }
+
+        DFS(0);
+        foreach (bool v in visited) {
+            if (!v) return false;
+        }
+
+        return true;
+    }
+
+    private int GCD(int a, int b) {
+        while (b != 0) {
+            int temp = b;
+            b = a % b;
+            a = temp;
+        }
+        return a;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -189,7 +236,7 @@ class Solution:
         uf = UnionFind(len(nums))
 
         factor_index = {}  # f -> index of value with factor f
-        for i, num in enumerate(nums):
+        for i, n in enumerate(nums):
             f = 2
             while f * f <= n:
                 if n % f == 0:
@@ -206,7 +253,7 @@ class Solution:
                 else:
                     factor_index[n] = i
         
-        return uf.isConnected()    
+        return uf.isConnected()
 ```
 
 ```java
@@ -452,6 +499,87 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public class UnionFind {
+        public int Count;
+        private int[] Parent;
+        private int[] Size;
+
+        public UnionFind(int n) {
+            Count = n;
+            Parent = new int[n];
+            Size = new int[n];
+            for (int i = 0; i < n; i++) {
+                Parent[i] = i;
+                Size[i] = 1;
+            }
+        }
+
+        public int Find(int x) {
+            if (Parent[x] != x) {
+                Parent[x] = Find(Parent[x]);
+            }
+            return Parent[x];
+        }
+
+        public bool Union(int x, int y) {
+            int px = Find(x);
+            int py = Find(y);
+            if (px == py) return false;
+            Count--;
+            if (Size[px] < Size[py]) {
+                int temp = px;
+                px = py;
+                py = temp;
+            }
+            Size[px] += Size[py];
+            Parent[py] = px;
+            return true;
+        }
+
+        public bool IsConnected() {
+            return Count == 1;
+        }
+    }
+
+    public bool CanTraverseAllPairs(int[] nums) {
+        int n = nums.Length;
+        if (n == 1) return true;
+        if (Array.Exists(nums, x => x == 1)) return false;
+
+        UnionFind uf = new UnionFind(n);
+        Dictionary<int, int> factorIndex = new Dictionary<int, int>();
+
+        for (int i = 0; i < n; i++) {
+            int num = nums[i];
+            int original = num;
+            for (int f = 2; f * f <= num; f++) {
+                if (num % f == 0) {
+                    if (factorIndex.ContainsKey(f)) {
+                        uf.Union(i, factorIndex[f]);
+                    } else {
+                        factorIndex[f] = i;
+                    }
+                    while (num % f == 0) {
+                        num /= f;
+                    }
+                }
+            }
+            if (num > 1) {
+                if (factorIndex.ContainsKey(num)) {
+                    uf.Union(i, factorIndex[num]);
+                } else {
+                    factorIndex[num] = i;
+                }
+            }
+        }
+
+        return uf.IsConnected();
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -790,6 +918,86 @@ class Solution {
 }
 ```
 
+```csharp
+public class UnionFind {
+    public int[] Parent;
+    public int[] Size;
+
+    public UnionFind(int n) {
+        Parent = new int[n];
+        Size = new int[n];
+        for (int i = 0; i < n; i++) {
+            Parent[i] = i;
+            Size[i] = 1;
+        }
+    }
+
+    public int Find(int x) {
+        if (Parent[x] != x) {
+            Parent[x] = Find(Parent[x]);
+        }
+        return Parent[x];
+    }
+
+    public bool Union(int x, int y) {
+        int px = Find(x);
+        int py = Find(y);
+        if (px == py) return false;
+        if (Size[px] < Size[py]) {
+            int temp = px;
+            px = py;
+            py = temp;
+        }
+        Parent[py] = px;
+        Size[px] += Size[py];
+        return true;
+    }
+}
+
+public class Solution {
+    public bool CanTraverseAllPairs(int[] nums) {
+        int n = nums.Length;
+        if (n == 1) return true;
+        if (Array.Exists(nums, x => x == 1)) return false;
+
+        int maxVal = nums.Max();
+        int[] sieve = new int[maxVal + 1];
+        for (int i = 2; i * i <= maxVal; i++) {
+            if (sieve[i] == 0) {
+                for (int j = i * i; j <= maxVal; j += i) {
+                    if (sieve[j] == 0) sieve[j] = i;
+                }
+            }
+        }
+
+        UnionFind uf = new UnionFind(n + maxVal + 1);
+
+        for (int i = 0; i < n; i++) {
+            int num = nums[i];
+            if (sieve[num] == 0) {
+                uf.Union(i, n + num);
+                continue;
+            }
+
+            while (num > 1) {
+                int prime = sieve[num] != 0 ? sieve[num] : num;
+                uf.Union(i, n + prime);
+                while (num % prime == 0) {
+                    num /= prime;
+                }
+            }
+        }
+
+        int root = uf.Find(0);
+        for (int i = 1; i < n; i++) {
+            if (uf.Find(i) != root) return false;
+        }
+
+        return true;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1029,6 +1237,70 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CanTraverseAllPairs(int[] nums) {
+        int N = nums.Length;
+        if (N == 1) return true;
+        if (Array.Exists(nums, num => num == 1)) return false;
+
+        int MAX = nums.Max();
+        int[] sieve = new int[MAX + 1];
+        for (int p = 2; p * p <= MAX; p++) {
+            if (sieve[p] == 0) {
+                for (int mult = p * p; mult <= MAX; mult += p) {
+                    if (sieve[mult] == 0) {
+                        sieve[mult] = p;
+                    }
+                }
+            }
+        }
+
+        Dictionary<int, List<int>> adj = new Dictionary<int, List<int>>();
+        for (int i = 0; i < N; i++) {
+            int num = nums[i];
+            if (sieve[num] == 0) {
+                AddEdge(adj, i, N + num);
+                continue;
+            }
+            while (num > 1) {
+                int prime = sieve[num] != 0 ? sieve[num] : num;
+                AddEdge(adj, i, N + prime);
+                while (num % prime == 0) {
+                    num /= prime;
+                }
+            }
+        }
+
+        HashSet<int> visited = new HashSet<int>();
+        DFS(0, adj, visited);
+
+        for (int i = 0; i < N; i++) {
+            if (!visited.Contains(i)) return false;
+        }
+
+        return true;
+    }
+
+    private void AddEdge(Dictionary<int, List<int>> adj, int u, int v) {
+        if (!adj.ContainsKey(u)) adj[u] = new List<int>();
+        if (!adj.ContainsKey(v)) adj[v] = new List<int>();
+        adj[u].Add(v);
+        adj[v].Add(u);
+    }
+
+    private void DFS(int node, Dictionary<int, List<int>> adj, HashSet<int> visited) {
+        visited.Add(node);
+        if (!adj.ContainsKey(node)) return;
+        foreach (int nei in adj[node]) {
+            if (!visited.Contains(nei)) {
+                DFS(nei, adj, visited);
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1295,6 +1567,74 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CanTraverseAllPairs(int[] nums) {
+        int N = nums.Length;
+        if (N == 1) return true;
+        if (nums.Contains(1)) return false;
+
+        int MAX = nums.Max();
+        int[] sieve = new int[MAX + 1];
+        for (int p = 2; p * p <= MAX; p++) {
+            if (sieve[p] == 0) {
+                for (int composite = p * p; composite <= MAX; composite += p) {
+                    if (sieve[composite] == 0) {
+                        sieve[composite] = p;
+                    }
+                }
+            }
+        }
+
+        Dictionary<int, List<int>> adj = new Dictionary<int, List<int>>();
+        for (int i = 0; i < N; i++) {
+            int num = nums[i];
+            if (sieve[num] == 0) {
+                AddEdge(adj, i, N + num);
+                continue;
+            }
+
+            while (num > 1) {
+                int prime = sieve[num] != 0 ? sieve[num] : num;
+                AddEdge(adj, i, N + prime);
+                while (num % prime == 0) {
+                    num /= prime;
+                }
+            }
+        }
+
+        HashSet<int> visited = new HashSet<int>();
+        Queue<int> queue = new Queue<int>();
+        queue.Enqueue(0);
+        visited.Add(0);
+
+        while (queue.Count > 0) {
+            int node = queue.Dequeue();
+            if (!adj.ContainsKey(node)) continue;
+            foreach (int nei in adj[node]) {
+                if (!visited.Contains(nei)) {
+                    visited.Add(nei);
+                    queue.Enqueue(nei);
+                }
+            }
+        }
+
+        for (int i = 0; i < N; i++) {
+            if (!visited.Contains(i)) return false;
+        }
+
+        return true;
+    }
+
+    private void AddEdge(Dictionary<int, List<int>> adj, int u, int v) {
+        if (!adj.ContainsKey(u)) adj[u] = new List<int>();
+        if (!adj.ContainsKey(v)) adj[v] = new List<int>();
+        adj[u].Add(v);
+        adj[v].Add(u);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/guess-number-higher-or-lower.md b/articles/guess-number-higher-or-lower.md
index b6053e2e8..4946e4968 100644
--- a/articles/guess-number-higher-or-lower.md
+++ b/articles/guess-number-higher-or-lower.md
@@ -65,7 +65,7 @@ public:
  * @return 	     -1 if num is higher than the picked number
  *			      1 if num is lower than the picked number
  *               otherwise return 0
- * var guess = function(num) {}
+ * function guess(num) {}
  */
 
 class Solution {
@@ -82,6 +82,26 @@ class Solution {
 }
 ```
 
+```csharp
+/** 
+ * Forward declaration of guess API.
+ * @param  num   your guess
+ * @return 	     -1 if num is higher than the picked number
+ *			      1 if num is lower than the picked number
+ *               otherwise return 0
+ * int guess(int num);
+ */
+
+public class Solution : GuessGame {
+    public int GuessNumber(int n) {
+        for (int num = 1; num <= n; num++) {
+            if (guess(num) == 0) return num;
+        }
+        return n;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -181,7 +201,7 @@ public:
  * @return 	     -1 if num is higher than the picked number
  *			      1 if num is lower than the picked number
  *               otherwise return 0
- * var guess = function(num) {}
+ * function guess(num) {}
  */
 
 class Solution {
@@ -206,6 +226,26 @@ class Solution {
 }
 ```
 
+```csharp
+/** 
+ * Forward declaration of guess API.
+ * @param  num   your guess
+ * @return 	     -1 if num is higher than the picked number
+ *			      1 if num is lower than the picked number
+ *               otherwise return 0
+ * int guess(int num);
+ */
+
+public class Solution : GuessGame {
+    public int GuessNumber(int n) {
+        for (int num = 1; num <= n; num++) {
+            if (guess(num) == 0) return num;
+        }
+        return n;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -316,7 +356,7 @@ public:
  * @return 	     -1 if num is higher than the picked number
  *			      1 if num is lower than the picked number
  *               otherwise return 0
- * var guess = function(num) {}
+ * function guess(num) {}
  */
 
 class Solution {
@@ -344,6 +384,41 @@ class Solution {
 }
 ```
 
+```csharp
+/** 
+ * Forward declaration of guess API.
+ * @param  num   your guess
+ * @return 	     -1 if num is higher than the picked number
+ *			      1 if num is lower than the picked number
+ *               otherwise return 0
+ * int guess(int num);
+ */
+
+public class Solution : GuessGame {
+    public int GuessNumber(int n) {
+        int l = 1, r = n;
+        while (true) {
+            int m1 = l + (r - l) / 3;
+            int m2 = r - (r - l) / 3;
+
+            if (guess(m1) == 0) return m1;
+            if (guess(m2) == 0) return m2;
+
+            if (guess(m1) + guess(m2) == 0) {
+                l = m1 + 1;
+                r = m2 - 1;
+            }
+            else if (guess(m1) == -1) {
+                r = m1 - 1;
+            }
+            else {
+                l = m2 + 1;
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/house-robber-iii.md b/articles/house-robber-iii.md
index 08d521c95..a09238c6b 100644
--- a/articles/house-robber-iii.md
+++ b/articles/house-robber-iii.md
@@ -128,6 +128,38 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public int Rob(TreeNode root) {
+        if (root == null) return 0;
+
+        int res = root.val;
+        if (root.left != null) {
+            res += Rob(root.left.left) + Rob(root.left.right);
+        }
+        if (root.right != null) {
+            res += Rob(root.right.left) + Rob(root.right.right);
+        }
+
+        res = Math.Max(res, Rob(root.left) + Rob(root.right));
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -299,6 +331,46 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    private Dictionary<TreeNode, int> cache = new();
+
+    public int Rob(TreeNode root) {
+        return Dfs(root);
+    }
+
+    private int Dfs(TreeNode root) {
+        if (root == null) return 0;
+        if (cache.ContainsKey(root)) return cache[root];
+
+        int res = root.val;
+        if (root.left != null) {
+            res += Dfs(root.left.left) + Dfs(root.left.right);
+        }
+        if (root.right != null) {
+            res += Dfs(root.right.left) + Dfs(root.right.right);
+        }
+
+        res = Math.Max(res, Dfs(root.left) + Dfs(root.right));
+        cache[root] = res;
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -449,6 +521,40 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public int Rob(TreeNode root) {
+        var result = Dfs(root);
+        return Math.Max(result.withRoot, result.withoutRoot);
+    }
+
+    private (int withRoot, int withoutRoot) Dfs(TreeNode root) {
+        if (root == null) return (0, 0);
+
+        var left = Dfs(root.left);
+        var right = Dfs(root.right);
+
+        int withRoot = root.val + left.withoutRoot + right.withoutRoot;
+        int withoutRoot = Math.Max(left.withRoot, left.withoutRoot) + Math.Max(right.withRoot, right.withoutRoot);
+
+        return (withRoot, withoutRoot);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/insert-into-a-binary-search-tree.md b/articles/insert-into-a-binary-search-tree.md
index d8597610b..fe0604c3a 100644
--- a/articles/insert-into-a-binary-search-tree.md
+++ b/articles/insert-into-a-binary-search-tree.md
@@ -118,6 +118,37 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public TreeNode InsertIntoBST(TreeNode root, int val) {
+        if (root == null) {
+            return new TreeNode(val);
+        }
+
+        if (val > root.val) {
+            root.right = InsertIntoBST(root.right, val);
+        } else {
+            root.left = InsertIntoBST(root.left, val);
+        }
+
+        return root;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -282,6 +313,46 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for a binary tree node.
+ * 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;
+ *     }
+ * }
+ */
+public class Solution {
+    public TreeNode InsertIntoBST(TreeNode root, int val) {
+        if (root == null) {
+            return new TreeNode(val);
+        }
+
+        TreeNode cur = root;
+        while (true) {
+            if (val > cur.val) {
+                if (cur.right == null) {
+                    cur.right = new TreeNode(val);
+                    return root;
+                }
+                cur = cur.right;
+            } else {
+                if (cur.left == null) {
+                    cur.left = new TreeNode(val);
+                    return root;
+                }
+                cur = cur.left;
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/integer-break.md b/articles/integer-break.md
index eadd8856d..2330d8828 100644
--- a/articles/integer-break.md
+++ b/articles/integer-break.md
@@ -79,6 +79,28 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private int n;
+
+    public int IntegerBreak(int n) {
+        this.n = n;
+
+        int Dfs(int num) {
+            if (num == 1) return 1;
+            int res = num == n ? 0 : num;
+            for (int i = 1; i < num; i++) {
+                int val = Dfs(i) * Dfs(num - i);
+                res = Math.Max(res, val);
+            }
+            return res;
+        }
+
+        return Dfs(n);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -173,6 +195,26 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int IntegerBreak(int n) {
+        int Dfs(int num, int i) {
+            if (Math.Min(num, i) == 0) {
+                return 1;
+            }
+
+            if (i > num) {
+                return Dfs(num, num);
+            }
+
+            return Math.Max(i * Dfs(num - i, i), Dfs(num, i - 1));
+        }
+
+        return Dfs(n, n - 1);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -289,6 +331,31 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int IntegerBreak(int n) {
+        Dictionary<int, int> dp = new Dictionary<int, int>();
+        dp[1] = 1;
+
+        int Dfs(int num) {
+            if (dp.ContainsKey(num)) {
+                return dp[num];
+            }
+
+            dp[num] = (num == n) ? 0 : num;
+            for (int i = 1; i < num; i++) {
+                int val = Dfs(i) * Dfs(num - i);
+                dp[num] = Math.Max(dp[num], val);
+            }
+
+            return dp[num];
+        }
+
+        return Dfs(n);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -409,6 +476,30 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int IntegerBreak(int n) {
+        Dictionary<(int, int), int> dp = new Dictionary<(int, int), int>();
+
+        int Dfs(int num, int i) {
+            if (Math.Min(num, i) == 0) return 1;
+
+            if (dp.ContainsKey((num, i))) return dp[(num, i)];
+
+            if (i > num) {
+                dp[(num, i)] = Dfs(num, num);
+                return dp[(num, i)];
+            }
+
+            dp[(num, i)] = Math.Max(i * Dfs(num - i, i), Dfs(num, i - 1));
+            return dp[(num, i)];
+        }
+
+        return Dfs(n, n - 1);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -495,6 +586,24 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int IntegerBreak(int n) {
+        int[] dp = new int[n + 1];
+        dp[1] = 1;
+
+        for (int num = 2; num <= n; num++) {
+            dp[num] = num == n ? 0 : num;
+            for (int i = 1; i < num; i++) {
+                dp[num] = Math.Max(dp[num], dp[i] * dp[num - i]);
+            }
+        }
+
+        return dp[n];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -571,6 +680,24 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int IntegerBreak(int n) {
+        if (n <= 3) {
+            return n - 1;
+        }
+
+        int res = 1;
+        while (n > 4) {
+            res *= 3;
+            n -= 3;
+        }
+
+        return res * n;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -653,6 +780,24 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int IntegerBreak(int n) {
+        if (n <= 3) {
+            return n - 1;
+        }
+
+        int res = (int)Math.Pow(3, n / 3);
+
+        if (n % 3 == 1) {
+            return (res / 3) * 4;
+        }
+
+        return res * Math.Max(1, n % 3);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/ipo.md b/articles/ipo.md
index e71ba4c34..87670000f 100644
--- a/articles/ipo.md
+++ b/articles/ipo.md
@@ -85,8 +85,8 @@ class Solution {
      * @return {number}
      */
     findMaximizedCapital(k, w, profits, capital) {
-        const minCapital = new MinPriorityQueue({ compare: (a, b) => a[0] - b[0] }); // Min heap
-        const maxProfit = new MaxPriorityQueue({ compare: (a, b) => b - a });        // Max heap
+        const minCapital = new PriorityQueue((a, b) => a[0] - b[0]); // Min heap
+        const maxProfit = new PriorityQueue((a, b) => b - a);        // Max heap
         
         for (let i = 0; i < capital.length; i++) {
             minCapital.enqueue([capital[i], profits[i]]);
@@ -107,6 +107,39 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int FindMaximizedCapital(int k, int w, int[] profits, int[] capital) {
+        var minCapital = new List<(int c, int p)>();
+        for (int i = 0; i < capital.Length; i++) {
+            minCapital.Add((capital[i], profits[i]));
+        }
+
+        // Min-heap by capital
+        minCapital.Sort((a, b) => a.c.CompareTo(b.c));
+
+        // Max-heap by profit
+        var maxProfit = new PriorityQueue<int, int>(Comparer<int>.Create((a, b) => b.CompareTo(a)));
+        int iPtr = 0;
+
+        for (int i = 0; i < k; i++) {
+            while (iPtr < minCapital.Count && minCapital[iPtr].c <= w) {
+                maxProfit.Enqueue(minCapital[iPtr].p, minCapital[iPtr].p);
+                iPtr++;
+            }
+
+            if (maxProfit.Count == 0) {
+                break;
+            }
+
+            w += maxProfit.Dequeue();
+        }
+
+        return w;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -215,12 +248,12 @@ class Solution {
      * @return {number}
      */
     findMaximizedCapital(k, w, profits, capital) {
-        const minCapital = new MinPriorityQueue({
-            compare: (a, b) => capital[a] - capital[b],
-        });
-        const maxProfit = new MaxPriorityQueue({
-            compare: (a, b) => profits[b] - profits[a],
-        });
+        const minCapital = new PriorityQueue(
+            (a, b) => capital[a] - capital[b],
+        );
+        const maxProfit = new PriorityQueue(
+            (a, b) => profits[b] - profits[a],
+        );
 
         for (let i = 0; i < capital.length; i++) {
             minCapital.enqueue(i);
@@ -241,6 +274,34 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int FindMaximizedCapital(int k, int w, int[] profits, int[] capital) {
+        var minCapital = new PriorityQueue<int, int>(); // index with capital as priority
+        var maxProfit = new PriorityQueue<int, int>(Comparer<int>.Create((a, b) => b.CompareTo(a))); // max heap by profit
+
+        for (int i = 0; i < capital.Length; i++) {
+            minCapital.Enqueue(i, capital[i]);
+        }
+
+        for (int i = 0; i < k; i++) {
+            while (minCapital.Count > 0 && capital[minCapital.Peek()] <= w) {
+                int idx = minCapital.Dequeue();
+                maxProfit.Enqueue(profits[idx], profits[idx]);
+            }
+
+            if (maxProfit.Count == 0) {
+                break;
+            }
+
+            w += maxProfit.Dequeue();
+        }
+
+        return w;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -358,7 +419,7 @@ class Solution {
             if (maxProfit.isEmpty()) {
                 break;
             }
-            w += maxProfit.dequeue().element;
+            w += maxProfit.dequeue();
         }
         
         return w;
@@ -366,6 +427,38 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int FindMaximizedCapital(int k, int w, int[] profits, int[] capital) {
+        int n = profits.Length;
+        int[] indices = new int[n];
+        for (int i = 0; i < n; i++) {
+            indices[i] = i;
+        }
+
+        Array.Sort(indices, (a, b) => capital[a].CompareTo(capital[b]));
+
+        var maxProfit = new PriorityQueue<int, int>(Comparer<int>.Create((a, b) => b.CompareTo(a)));
+        int idx = 0;
+
+        for (int i = 0; i < k; i++) {
+            while (idx < n && capital[indices[idx]] <= w) {
+                maxProfit.Enqueue(profits[indices[idx]], profits[indices[idx]]);
+                idx++;
+            }
+
+            if (maxProfit.Count == 0) {
+                break;
+            }
+
+            w += maxProfit.Dequeue();
+        }
+
+        return w;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/island-perimeter.md b/articles/island-perimeter.md
index c4bb78ca5..bb87939fe 100644
--- a/articles/island-perimeter.md
+++ b/articles/island-perimeter.md
@@ -138,6 +138,42 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private int rows, cols;
+    private HashSet<(int, int)> visit;
+
+    public int IslandPerimeter(int[][] grid) {
+        rows = grid.Length;
+        cols = grid[0].Length;
+        visit = new HashSet<(int, int)>();
+
+        int Dfs(int i, int j) {
+            if (i < 0 || j < 0 || i >= rows || j >= cols || grid[i][j] == 0) {
+                return 1;
+            }
+            if (visit.Contains((i, j))) {
+                return 0;
+            }
+
+            visit.Add((i, j));
+            int perim = Dfs(i, j + 1) + Dfs(i + 1, j) + Dfs(i, j - 1) + Dfs(i - 1, j);
+            return perim;
+        }
+
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (grid[i][j] == 1) {
+                    return Dfs(i, j);
+                }
+            }
+        }
+
+        return 0;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -309,6 +345,56 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int IslandPerimeter(int[][] grid) {
+        int rows = grid.Length;
+        int cols = grid[0].Length;
+        var visited = new HashSet<(int, int)>();
+        int[][] directions = new int[][] {
+            new int[] { 0, 1 },
+            new int[] { 1, 0 },
+            new int[] { 0, -1 },
+            new int[] { -1, 0 }
+        };
+
+        int Bfs(int r, int c) {
+            var queue = new Queue<(int, int)>();
+            queue.Enqueue((r, c));
+            visited.Add((r, c));
+            int perimeter = 0;
+
+            while (queue.Count > 0) {
+                var (x, y) = queue.Dequeue();
+                foreach (var dir in directions) {
+                    int nx = x + dir[0];
+                    int ny = y + dir[1];
+
+                    if (nx < 0 || ny < 0 || nx >= rows || ny >= cols || grid[nx][ny] == 0) {
+                        perimeter++;
+                    } else if (!visited.Contains((nx, ny))) {
+                        visited.Add((nx, ny));
+                        queue.Enqueue((nx, ny));
+                    }
+                }
+            }
+
+            return perimeter;
+        }
+
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (grid[i][j] == 1) {
+                    return Bfs(i, j);
+                }
+            }
+        }
+
+        return 0;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -401,6 +487,29 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int IslandPerimeter(int[][] grid) {
+        int m = grid.Length;
+        int n = grid[0].Length;
+        int res = 0;
+
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (grid[i][j] == 1) {
+                    if (i + 1 >= m || grid[i + 1][j] == 0) res++;
+                    if (j + 1 >= n || grid[i][j + 1] == 0) res++;
+                    if (i - 1 < 0 || grid[i - 1][j] == 0) res++;
+                    if (j - 1 < 0 || grid[i][j - 1] == 0) res++;
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -506,6 +615,32 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int IslandPerimeter(int[][] grid) {
+        int m = grid.Length;
+        int n = grid[0].Length;
+        int res = 0;
+
+        for (int r = 0; r < m; r++) {
+            for (int c = 0; c < n; c++) {
+                if (grid[r][c] == 1) {
+                    res += 4;
+                    if (r > 0 && grid[r - 1][c] == 1) {
+                        res -= 2;
+                    }
+                    if (c > 0 && grid[r][c - 1] == 1) {
+                        res -= 2;
+                    }
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/longest-happy-string.md b/articles/longest-happy-string.md
index e5f2e0573..3b669e0e4 100644
--- a/articles/longest-happy-string.md
+++ b/articles/longest-happy-string.md
@@ -166,6 +166,45 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string LongestDiverseString(int a, int b, int c) {
+        int[] count = new int[] { a, b, c };
+        List<char> res = new List<char>();
+
+        int GetMax(int repeated) {
+            int idx = -1;
+            int maxCnt = 0;
+            for (int i = 0; i < 3; i++) {
+                if (i == repeated || count[i] == 0) continue;
+                if (maxCnt < count[i]) {
+                    maxCnt = count[i];
+                    idx = i;
+                }
+            }
+            return idx;
+        }
+
+        int repeated = -1;
+        while (true) {
+            int maxChar = GetMax(repeated);
+            if (maxChar == -1) break;
+
+            res.Add((char)(maxChar + 'a'));
+            count[maxChar]--;
+
+            if (res.Count > 1 && res[res.Count - 1] == res[res.Count - 2]) {
+                repeated = maxChar;
+            } else {
+                repeated = -1;
+            }
+        }
+
+        return new string(res.ToArray());
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -283,18 +322,18 @@ class Solution {
      */
     longestDiverseString(a, b, c) {
         const res = [];
-        const maxHeap = new MaxPriorityQueue({ priority: (x) => x[0] });
+        const maxHeap = new MaxPriorityQueue(x => x[0]);
 
         if (a > 0) maxHeap.enqueue([a, 'a']);
         if (b > 0) maxHeap.enqueue([b, 'b']);
         if (c > 0) maxHeap.enqueue([c, 'c']);
 
         while (!maxHeap.isEmpty()) {
-            const [count, char] = maxHeap.dequeue().element;
+            const [count, char] = maxHeap.dequeue();
 
             if (res.length > 1 && res[res.length - 1] === char && res[res.length - 2] === char) {
                 if (maxHeap.isEmpty()) break;
-                const [count2, char2] = maxHeap.dequeue().element;
+                const [count2, char2] = maxHeap.dequeue();
                 res.push(char2);
                 if (count2 - 1 > 0) maxHeap.enqueue([count2 - 1, char2]);
                 maxHeap.enqueue([count, char]);
@@ -309,6 +348,47 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string LongestDiverseString(int a, int b, int c) {
+        string res = "";
+        PriorityQueue<(int count, char ch), int> maxHeap = new PriorityQueue<(int, char), int>();
+
+        void AddToHeap(int count, char ch) {
+            if (count > 0) {
+                maxHeap.Enqueue((count, ch), -count);
+            }
+        }
+
+        AddToHeap(a, 'a');
+        AddToHeap(b, 'b');
+        AddToHeap(c, 'c');
+
+        while (maxHeap.Count > 0) {
+            var (count1, ch1) = maxHeap.Dequeue();
+            if (res.Length >= 2 && res[^1] == ch1 && res[^2] == ch1) {
+                if (maxHeap.Count == 0) break;
+                var (count2, ch2) = maxHeap.Dequeue();
+                res += ch2;
+                count2--;
+                if (count2 > 0) {
+                    maxHeap.Enqueue((count2, ch2), -count2);
+                }
+                maxHeap.Enqueue((count1, ch1), -count1);
+            } else {
+                res += ch1;
+                count1--;
+                if (count1 > 0) {
+                    maxHeap.Enqueue((count1, ch1), -count1);
+                }
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -448,6 +528,35 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string LongestDiverseString(int a, int b, int c) {
+        return string.Join("", Rec(a, b, c, 'a', 'b', 'c'));
+    }
+
+    private List<char> Rec(int max1, int max2, int max3, char char1, char char2, char char3) {
+        if (max1 < max2) return Rec(max2, max1, max3, char2, char1, char3);
+        if (max2 < max3) return Rec(max1, max3, max2, char1, char3, char2);
+        if (max2 == 0) {
+            int use = Math.Min(2, max1);
+            var res = new List<char>();
+            for (int i = 0; i < use; i++) res.Add(char1);
+            return res;
+        }
+
+        int use1 = Math.Min(2, max1);
+        int use2 = (max1 - use1 >= max2) ? 1 : 0;
+
+        var result = new List<char>();
+        for (int i = 0; i < use1; i++) result.Add(char1);
+        for (int i = 0; i < use2; i++) result.Add(char2);
+
+        result.AddRange(Rec(max1 - use1, max2 - use2, max3, char1, char2, char3));
+        return result;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/matchsticks-to-square.md b/articles/matchsticks-to-square.md
index c05819570..ae760c5ac 100644
--- a/articles/matchsticks-to-square.md
+++ b/articles/matchsticks-to-square.md
@@ -109,6 +109,39 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool Makesquare(int[] matchsticks) {
+        int total = 0;
+        foreach (int stick in matchsticks) {
+            total += stick;
+        }
+        if (total % 4 != 0) return false;
+
+        int target = total / 4;
+        int[] sides = new int[4];
+
+        bool Dfs(int i) {
+            if (i == matchsticks.Length) {
+                return sides[0] == sides[1] && sides[1] == sides[2] && sides[2] == sides[3];
+            }
+
+            for (int side = 0; side < 4; side++) {
+                sides[side] += matchsticks[i];
+                if (sides[side] <= target && Dfs(i + 1)) {
+                    return true;
+                }
+                sides[side] -= matchsticks[i];
+            }
+
+            return false;
+        }
+
+        return Dfs(0);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -266,6 +299,45 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool Makesquare(int[] matchsticks) {
+        int totalLength = 0;
+        foreach (int stick in matchsticks) {
+            totalLength += stick;
+        }
+
+        if (totalLength % 4 != 0) {
+            return false;
+        }
+
+        int length = totalLength / 4;
+        int[] sides = new int[4];
+        Array.Sort(matchsticks, (a, b) => b.CompareTo(a)); // Sort in descending order
+
+        bool Dfs(int i) {
+            if (i == matchsticks.Length) {
+                return true;
+            }
+
+            for (int side = 0; side < 4; side++) {
+                if (sides[side] + matchsticks[i] <= length) {
+                    sides[side] += matchsticks[i];
+                    if (Dfs(i + 1)) return true;
+                    sides[side] -= matchsticks[i];
+                }
+
+                if (sides[side] == 0) break;
+            }
+
+            return false;
+        }
+
+        return Dfs(0);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -466,6 +538,46 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool Makesquare(int[] matchsticks) {
+        int totalLength = matchsticks.Sum();
+        if (totalLength % 4 != 0) return false;
+
+        int length = totalLength / 4;
+        if (matchsticks.Max() > length) return false;
+
+        int n = matchsticks.Length;
+        int[] dp = Enumerable.Repeat(int.MinValue, 1 << n).ToArray();
+        Array.Sort(matchsticks, (a, b) => b.CompareTo(a)); // Sort descending
+
+        int Dfs(int mask) {
+            if (mask == 0) return 0;
+            if (dp[mask] != int.MinValue) return dp[mask];
+
+            for (int i = 0; i < n; i++) {
+                if ((mask & (1 << i)) != 0) {
+                    int res = Dfs(mask ^ (1 << i));
+                    if (res >= 0 && res + matchsticks[i] <= length) {
+                        dp[mask] = (res + matchsticks[i]) % length;
+                        return dp[mask];
+                    }
+                    if (mask == (1 << n) - 1) {
+                        dp[mask] = -1;
+                        return -1;
+                    }
+                }
+            }
+
+            dp[mask] = -1;
+            return -1;
+        }
+
+        return Dfs((1 << n) - 1) != -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/minimum-size-subarray-sum.md b/articles/minimum-size-subarray-sum.md
index 74be08d78..683582184 100644
--- a/articles/minimum-size-subarray-sum.md
+++ b/articles/minimum-size-subarray-sum.md
@@ -94,6 +94,28 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MinSubArrayLen(int target, int[] nums) {
+        int n = nums.Length;
+        int res = int.MaxValue;
+
+        for (int i = 0; i < n; i++) {
+            int curSum = 0;
+            for (int j = i; j < n; j++) {
+                curSum += nums[j];
+                if (curSum >= target) {
+                    res = Math.Min(res, j - i + 1);
+                    break;
+                }
+            }
+        }
+
+        return res == int.MaxValue ? 0 : res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -188,6 +210,27 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MinSubArrayLen(int target, int[] nums) {
+        int l = 0, total = 0;
+        int res = int.MaxValue;
+
+        for (int r = 0; r < nums.Length; r++) {
+            total += nums[r];
+
+            while (total >= target) {
+                res = Math.Min(res, r - l + 1);
+                total -= nums[l];
+                l++;
+            }
+        }
+
+        return res == int.MaxValue ? 0 : res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -324,6 +367,39 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MinSubArrayLen(int target, int[] nums) {
+        int n = nums.Length;
+        int[] prefixSum = new int[n + 1];
+        
+        for (int i = 0; i < n; i++) {
+            prefixSum[i + 1] = prefixSum[i] + nums[i];
+        }
+
+        int res = n + 1;
+
+        for (int i = 0; i < n; i++) {
+            int l = i, r = n;
+            while (l < r) {
+                int mid = (l + r) / 2;
+                int curSum = prefixSum[mid + 1] - prefixSum[i];
+                if (curSum >= target) {
+                    r = mid;
+                } else {
+                    l = mid + 1;
+                }
+            }
+            if (l != n) {
+                res = Math.Min(res, l - i + 1);
+            }
+        }
+
+        return res % (n + 1);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/n-queens-ii.md b/articles/n-queens-ii.md
index 1e123c887..16a94bd75 100644
--- a/articles/n-queens-ii.md
+++ b/articles/n-queens-ii.md
@@ -178,6 +178,57 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private int res = 0;
+
+    public int TotalNQueens(int n) {
+        res = 0;
+        char[][] board = new char[n][];
+        for (int i = 0; i < n; i++) {
+            board[i] = Enumerable.Repeat('.', n).ToArray();
+        }
+
+        Backtrack(0, board, n);
+        return res;
+    }
+
+    private void Backtrack(int r, char[][] board, int n) {
+        if (r == n) {
+            res++;
+            return;
+        }
+
+        for (int c = 0; c < n; c++) {
+            if (IsSafe(r, c, board)) {
+                board[r][c] = 'Q';
+                Backtrack(r + 1, board, n);
+                board[r][c] = '.';
+            }
+        }
+    }
+
+    private bool IsSafe(int r, int c, char[][] board) {
+        // Check column
+        for (int row = r - 1; row >= 0; row--) {
+            if (board[row][c] == 'Q') return false;
+        }
+
+        // Check top-left diagonal
+        for (int row = r - 1, col = c - 1; row >= 0 && col >= 0; row--, col--) {
+            if (board[row][col] == 'Q') return false;
+        }
+
+        // Check top-right diagonal
+        for (int row = r - 1, col = c + 1; row >= 0 && col < board.Length; row--, col++) {
+            if (board[row][col] == 'Q') return false;
+        }
+
+        return true;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -346,6 +397,43 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private HashSet<int> col = new HashSet<int>();
+    private HashSet<int> posDiag = new HashSet<int>();  // r + c
+    private HashSet<int> negDiag = new HashSet<int>();  // r - c
+    private int res = 0;
+
+    public int TotalNQueens(int n) {
+        res = 0;
+        Backtrack(0, n);
+        return res;
+    }
+
+    private void Backtrack(int r, int n) {
+        if (r == n) {
+            res++;
+            return;
+        }
+
+        for (int c = 0; c < n; c++) {
+            if (col.Contains(c) || posDiag.Contains(r + c) || negDiag.Contains(r - c))
+                continue;
+
+            col.Add(c);
+            posDiag.Add(r + c);
+            negDiag.Add(r - c);
+
+            Backtrack(r + 1, n);
+
+            col.Remove(c);
+            posDiag.Remove(r + c);
+            negDiag.Remove(r - c);
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -509,6 +597,42 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int TotalNQueens(int n) {
+        bool[] col = new bool[n];
+        bool[] posDiag = new bool[2 * n];
+        bool[] negDiag = new bool[2 * n];
+        int res = 0;
+
+        void Backtrack(int r) {
+            if (r == n) {
+                res++;
+                return;
+            }
+
+            for (int c = 0; c < n; c++) {
+                if (col[c] || posDiag[r + c] || negDiag[r - c + n])
+                    continue;
+
+                col[c] = true;
+                posDiag[r + c] = true;
+                negDiag[r - c + n] = true;
+
+                Backtrack(r + 1);
+
+                col[c] = false;
+                posDiag[r + c] = false;
+                negDiag[r - c + n] = false;
+            }
+        }
+
+        Backtrack(0);
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -664,6 +788,44 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int TotalNQueens(int n) {
+        int col = 0;
+        int posDiag = 0;
+        int negDiag = 0;
+        int res = 0;
+
+        void Backtrack(int r) {
+            if (r == n) {
+                res++;
+                return;
+            }
+
+            for (int c = 0; c < n; c++) {
+                if (((col & (1 << c)) != 0) || 
+                    ((posDiag & (1 << (r + c))) != 0) || 
+                    ((negDiag & (1 << (r - c + n))) != 0))
+                    continue;
+
+                col ^= (1 << c);
+                posDiag ^= (1 << (r + c));
+                negDiag ^= (1 << (r - c + n));
+
+                Backtrack(r + 1);
+
+                col ^= (1 << c);
+                posDiag ^= (1 << (r + c));
+                negDiag ^= (1 << (r - c + n));
+            }
+        }
+
+        Backtrack(0);
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/n-th-tribonacci-number.md b/articles/n-th-tribonacci-number.md
index bf04e98f7..56f6ce37a 100644
--- a/articles/n-th-tribonacci-number.md
+++ b/articles/n-th-tribonacci-number.md
@@ -48,6 +48,16 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int Tribonacci(int n) {
+        if (n == 0) return 0;
+        if (n <= 2) return 1;
+        return Tribonacci(n - 1) + Tribonacci(n - 2) + Tribonacci(n - 3);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -138,6 +148,21 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private Dictionary<int, int> dp = new Dictionary<int, int>();
+
+    public int Tribonacci(int n) {
+        if (n == 0) return 0;
+        if (n <= 2) return 1;
+        if (dp.ContainsKey(n)) return dp[n];
+
+        dp[n] = Tribonacci(n - 1) + Tribonacci(n - 2) + Tribonacci(n - 3);
+        return dp[n];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -220,6 +245,25 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int Tribonacci(int n) {
+        if (n == 0) return 0;
+        if (n <= 2) return 1;
+
+        int[] dp = new int[n + 1];
+        dp[0] = 0;
+        dp[1] = dp[2] = 1;
+
+        for (int i = 3; i <= n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
+        }
+
+        return dp[n];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -293,6 +337,21 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int Tribonacci(int n) {
+        int[] t = {0, 1, 1};
+        if (n < 3) return t[n];
+
+        for (int i = 3; i <= n; i++) {
+            t[i % 3] = t[0] + t[1] + t[2];
+        }
+
+        return t[n % 3];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/open-the-lock.md b/articles/open-the-lock.md
index 6ded4c7ee..910704fd6 100644
--- a/articles/open-the-lock.md
+++ b/articles/open-the-lock.md
@@ -159,6 +159,44 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int OpenLock(string[] deadends, string target) {
+        var dead = new HashSet<string>(deadends);
+        if (dead.Contains("0000")) return -1;
+
+        List<string> Children(string lockStr) {
+            var res = new List<string>();
+            for (int i = 0; i < 4; i++) {
+                int digit = lockStr[i] - '0';
+                string up = lockStr.Substring(0, i) + ((digit + 1) % 10) + lockStr.Substring(i + 1);
+                string down = lockStr.Substring(0, i) + ((digit + 9) % 10) + lockStr.Substring(i + 1);
+                res.Add(up);
+                res.Add(down);
+            }
+            return res;
+        }
+
+        var q = new Queue<(string, int)>();
+        q.Enqueue(("0000", 0));
+        var visited = new HashSet<string>(dead);
+
+        while (q.Count > 0) {
+            var (lockStr, turns) = q.Dequeue();
+            if (lockStr == target) return turns;
+            foreach (var child in Children(lockStr)) {
+                if (!visited.Contains(child)) {
+                    visited.Add(child);
+                    q.Enqueue((child, turns + 1));
+                }
+            }
+        }
+
+        return -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -313,6 +351,42 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int OpenLock(string[] deadends, string target) {
+        if (target == "0000") return 0;
+
+        var visited = new HashSet<string>(deadends);
+        if (visited.Contains("0000")) return -1;
+
+        var q = new Queue<string>();
+        q.Enqueue("0000");
+        visited.Add("0000");
+        int steps = 0;
+
+        while (q.Count > 0) {
+            steps++;
+            int size = q.Count;
+            for (int i = 0; i < size; i++) {
+                string lockStr = q.Dequeue();
+                for (int j = 0; j < 4; j++) {
+                    foreach (int move in new int[] {1, -1}) {
+                        int digit = (lockStr[j] - '0' + move + 10) % 10;
+                        string nextLock = lockStr.Substring(0, j) + digit.ToString() + lockStr.Substring(j + 1);
+                        if (visited.Contains(nextLock)) continue;
+                        if (nextLock == target) return steps;
+                        q.Enqueue(nextLock);
+                        visited.Add(nextLock);
+                    }
+                }
+            }
+        }
+
+        return -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -491,6 +565,51 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int OpenLock(string[] deadends, string target) {
+        if (target == "0000") return 0;
+
+        var visit = new HashSet<string>(deadends);
+        if (visit.Contains("0000")) return -1;
+
+        var begin = new HashSet<string> { "0000" };
+        var end = new HashSet<string> { target };
+        int steps = 0;
+
+        while (begin.Count > 0 && end.Count > 0) {
+            if (begin.Count > end.Count) {
+                var tempSet = begin;
+                begin = end;
+                end = tempSet;
+            }
+
+            var temp = new HashSet<string>();
+            steps++;
+
+            foreach (var lockStr in begin) {
+                for (int i = 0; i < 4; i++) {
+                    foreach (int j in new int[] { -1, 1 }) {
+                        int digit = (lockStr[i] - '0' + j + 10) % 10;
+                        string nextLock = lockStr.Substring(0, i) + digit.ToString() + lockStr.Substring(i + 1);
+
+                        if (end.Contains(nextLock)) return steps;
+                        if (visit.Contains(nextLock)) continue;
+
+                        visit.Add(nextLock);
+                        temp.Add(nextLock);
+                    }
+                }
+            }
+
+            begin = temp;
+        }
+
+        return -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/partition-to-k-equal-sum-subsets.md b/articles/partition-to-k-equal-sum-subsets.md
index 260fe7e37..d217736df 100644
--- a/articles/partition-to-k-equal-sum-subsets.md
+++ b/articles/partition-to-k-equal-sum-subsets.md
@@ -132,6 +132,38 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CanPartitionKSubsets(int[] nums, int k) {
+        int totalSum = nums.Sum();
+        if (totalSum % k != 0) return false;
+
+        int target = totalSum / k;
+        Array.Sort(nums);
+        Array.Reverse(nums);
+
+        bool[] used = new bool[nums.Length];
+
+        bool Backtrack(int i, int kRemaining, int subsetSum) {
+            if (kRemaining == 0) return true;
+            if (subsetSum == target) return Backtrack(0, kRemaining - 1, 0);
+
+            for (int j = i; j < nums.Length; j++) {
+                if (used[j] || subsetSum + nums[j] > target) continue;
+
+                used[j] = true;
+                if (Backtrack(j + 1, kRemaining, subsetSum + nums[j])) return true;
+                used[j] = false;
+            }
+
+            return false;
+        }
+
+        return Backtrack(0, k, 0);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -291,6 +323,39 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CanPartitionKSubsets(int[] nums, int k) {
+        int total = nums.Sum();
+        if (total % k != 0) return false;
+
+        Array.Sort(nums);
+        Array.Reverse(nums);
+        int target = total / k;
+        bool[] used = new bool[nums.Length];
+
+        bool Backtrack(int i, int kRemaining, int subsetSum) {
+            if (kRemaining == 0) return true;
+            if (subsetSum == target) return Backtrack(0, kRemaining - 1, 0);
+
+            for (int j = i; j < nums.Length; j++) {
+                if (used[j] || subsetSum + nums[j] > target) continue;
+
+                used[j] = true;
+                if (Backtrack(j + 1, kRemaining, subsetSum + nums[j])) return true;
+                used[j] = false;
+
+                if (subsetSum == 0) return false; // Pruning
+            }
+
+            return false;
+        }
+
+        return Backtrack(0, k, 0);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -442,6 +507,38 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CanPartitionKSubsets(int[] nums, int k) {
+        int total = nums.Sum();
+        if (total % k != 0) return false;
+
+        Array.Sort(nums);
+        Array.Reverse(nums);
+        int target = total / k;
+        int n = nums.Length;
+
+        bool Backtrack(int i, int kRemaining, int subsetSum, int mask) {
+            if (kRemaining == 0) return true;
+            if (subsetSum == target) return Backtrack(0, kRemaining - 1, 0, mask);
+
+            for (int j = i; j < n; j++) {
+                if ((mask & (1 << j)) == 0 || subsetSum + nums[j] > target) continue;
+
+                if (Backtrack(j + 1, kRemaining, subsetSum + nums[j], mask ^ (1 << j)))
+                    return true;
+
+                if (subsetSum == 0) return false;
+            }
+
+            return false;
+        }
+
+        return Backtrack(0, k, 0, (1 << n) - 1);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -641,6 +738,53 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CanPartitionKSubsets(int[] nums, int k) {
+        int total = nums.Sum();
+        if (total % k != 0) return false;
+
+        Array.Sort(nums);
+        Array.Reverse(nums);
+
+        int target = total / k;
+        int n = nums.Length;
+        bool?[] dp = new bool?[1 << n];
+
+        bool Backtrack(int i, int kRemaining, int subsetSum, int mask) {
+            if (dp[mask].HasValue) return (bool)dp[mask];
+            if (kRemaining == 0) {
+                dp[mask] = true;
+                return true;
+            }
+            if (subsetSum == target) {
+                dp[mask] = Backtrack(0, kRemaining - 1, 0, mask);
+                return (bool)dp[mask];
+            }
+
+            for (int j = i; j < n; j++) {
+                if ((mask & (1 << j)) == 0 || subsetSum + nums[j] > target) continue;
+
+                if (Backtrack(j + 1, kRemaining, subsetSum + nums[j], mask ^ (1 << j))) {
+                    dp[mask] = true;
+                    return true;
+                }
+
+                if (subsetSum == 0) {
+                    dp[mask] = false;
+                    return false;
+                }
+            }
+
+            dp[mask] = false;
+            return false;
+        }
+
+        return Backtrack(0, k, 0, (1 << n) - 1);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -764,6 +908,35 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool CanPartitionKSubsets(int[] nums, int k) {
+        int total = nums.Sum();
+        if (total % k != 0) return false;
+
+        int target = total / k;
+        int n = nums.Length;
+        int N = 1 << n;
+        int[] dp = new int[N];
+        for (int i = 1; i < N; i++) {
+            dp[i] = -1;
+        }
+
+        for (int mask = 0; mask < N; mask++) {
+            if (dp[mask] == -1) continue;
+            for (int i = 0; i < n; i++) {
+                if ((mask & (1 << i)) == 0 && dp[mask] + nums[i] <= target) {
+                    int nextMask = mask | (1 << i);
+                    dp[nextMask] = (dp[mask] + nums[i]) % target;
+                }
+            }
+        }
+
+        return dp[N - 1] == 0;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/path-with-minimum-effort.md b/articles/path-with-minimum-effort.md
index bccc0e7b9..5f151c2c8 100644
--- a/articles/path-with-minimum-effort.md
+++ b/articles/path-with-minimum-effort.md
@@ -132,7 +132,7 @@ class Solution {
         );
         dist[0][0] = 0;
 
-        const minHeap = new MinPriorityQueue({ priority: (a) => a[0] });
+        const minHeap = new MinPriorityQueue(a => a[0]);
         minHeap.enqueue([0, 0, 0]); // [diff, row, col]
 
         const directions = [
@@ -141,7 +141,7 @@ class Solution {
         ];
 
         while (!minHeap.isEmpty()) {
-            const [diff, r, c] = minHeap.dequeue().element;
+            const [diff, r, c] = minHeap.dequeue();
 
             if (r === rows - 1 && c === cols - 1) return diff;
             if (dist[r][c] < diff) continue;
@@ -169,6 +169,50 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MinimumEffortPath(int[][] heights) {
+        int rows = heights.Length, cols = heights[0].Length;
+        var directions = new int[][] {
+            new int[] { 0, 1 },
+            new int[] { 0, -1 },
+            new int[] { 1, 0 },
+            new int[] { -1, 0 }
+        };
+
+        var minHeap = new PriorityQueue<(int diff, int r, int c), int>();
+        var visited = new HashSet<(int, int)>();
+        minHeap.Enqueue((0, 0, 0), 0);
+
+        while (minHeap.Count > 0) {
+            var current = minHeap.Dequeue();
+            int diff = current.diff, r = current.r, c = current.c;
+
+            if (visited.Contains((r, c))) continue;
+            visited.Add((r, c));
+
+            if (r == rows - 1 && c == cols - 1) {
+                return diff;
+            }
+
+            foreach (var dir in directions) {
+                int newR = r + dir[0];
+                int newC = c + dir[1];
+
+                if (newR < 0 || newC < 0 || newR >= rows || newC >= cols || visited.Contains((newR, newC))) {
+                    continue;
+                }
+
+                int newDiff = Math.Max(diff, Math.Abs(heights[r][c] - heights[newR][newC]));
+                minHeap.Enqueue((newDiff, newR, newC), newDiff);
+            }
+        }
+
+        return 0;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -390,6 +434,59 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private int[][] directions = new int[][] {
+        new int[] { 0, 1 },
+        new int[] { 0, -1 },
+        new int[] { 1, 0 },
+        new int[] { -1, 0 }
+    };
+
+    public int MinimumEffortPath(int[][] heights) {
+        int rows = heights.Length;
+        int cols = heights[0].Length;
+
+        bool Dfs(int r, int c, int limit, HashSet<(int, int)> visited) {
+            if (r == rows - 1 && c == cols - 1)
+                return true;
+
+            visited.Add((r, c));
+
+            foreach (var dir in directions) {
+                int newR = r + dir[0];
+                int newC = c + dir[1];
+
+                if (newR < 0 || newC < 0 || newR >= rows || newC >= cols ||
+                    visited.Contains((newR, newC)) ||
+                    Math.Abs(heights[newR][newC] - heights[r][c]) > limit)
+                    continue;
+
+                if (Dfs(newR, newC, limit, visited))
+                    return true;
+            }
+
+            return false;
+        }
+
+        int left = 0, right = 1000000, res = right;
+
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            var visited = new HashSet<(int, int)>();
+            if (Dfs(0, 0, mid, visited)) {
+                res = mid;
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -654,6 +751,77 @@ class Solution {
 }
 ```
 
+```csharp
+public class DSU {
+    private int[] parent;
+    private int[] size;
+
+    public DSU(int n) {
+        parent = new int[n + 1];
+        size = new int[n + 1];
+        for (int i = 0; i <= n; i++) {
+            parent[i] = i;
+            size[i] = 1;
+        }
+    }
+
+    public int Find(int node) {
+        if (parent[node] != node) {
+            parent[node] = Find(parent[node]);
+        }
+        return parent[node];
+    }
+
+    public bool Union(int u, int v) {
+        int pu = Find(u);
+        int pv = Find(v);
+        if (pu == pv) return false;
+        if (size[pu] < size[pv]) {
+            (pu, pv) = (pv, pu);
+        }
+        size[pu] += size[pv];
+        parent[pv] = pu;
+        return true;
+    }
+}
+
+public class Solution {
+    public int MinimumEffortPath(int[][] heights) {
+        int rows = heights.Length;
+        int cols = heights[0].Length;
+        List<(int, int, int)> edges = new List<(int, int, int)>();
+
+        for (int r = 0; r < rows; r++) {
+            for (int c = 0; c < cols; c++) {
+                int id = r * cols + c;
+                if (r + 1 < rows) {
+                    int downId = (r + 1) * cols + c;
+                    int diff = Math.Abs(heights[r][c] - heights[r + 1][c]);
+                    edges.Add((diff, id, downId));
+                }
+                if (c + 1 < cols) {
+                    int rightId = r * cols + (c + 1);
+                    int diff = Math.Abs(heights[r][c] - heights[r][c + 1]);
+                    edges.Add((diff, id, rightId));
+                }
+            }
+        }
+
+        edges.Sort((a, b) => a.Item1.CompareTo(b.Item1));
+        DSU dsu = new DSU(rows * cols);
+
+        foreach (var (weight, u, v) in edges) {
+            dsu.Union(u, v);
+            if (dsu.Find(0) == dsu.Find(rows * cols - 1)) {
+                return weight;
+            }
+        }
+
+        return 0;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -839,6 +1007,53 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MinimumEffortPath(int[][] heights) {
+        int rows = heights.Length;
+        int cols = heights[0].Length;
+        int[] dist = Enumerable.Repeat(int.MaxValue, rows * cols).ToArray();
+        bool[] inQueue = new bool[rows * cols];
+        dist[0] = 0;
+
+        int Index(int r, int c) => r * cols + c;
+
+        Queue<int> queue = new Queue<int>();
+        queue.Enqueue(0);
+        inQueue[0] = true;
+
+        int[][] directions = new int[][] {
+            new int[] {0, 1}, new int[] {0, -1}, 
+            new int[] {1, 0}, new int[] {-1, 0}
+        };
+
+        while (queue.Count > 0) {
+            int u = queue.Dequeue();
+            inQueue[u] = false;
+            int r = u / cols, c = u % cols;
+
+            foreach (var dir in directions) {
+                int newR = r + dir[0], newC = c + dir[1];
+                if (newR >= 0 && newR < rows && newC >= 0 && newC < cols) {
+                    int v = Index(newR, newC);
+                    int weight = Math.Abs(heights[r][c] - heights[newR][newC]);
+                    int newDist = Math.Max(dist[u], weight);
+                    if (newDist < dist[v]) {
+                        dist[v] = newDist;
+                        if (!inQueue[v]) {
+                            queue.Enqueue(v);
+                            inQueue[v] = true;
+                        }
+                    }
+                }
+            }
+        }
+
+        return dist[rows * cols - 1];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/perfect-squares.md b/articles/perfect-squares.md
index ce067516a..eb92e5450 100644
--- a/articles/perfect-squares.md
+++ b/articles/perfect-squares.md
@@ -83,6 +83,25 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int NumSquares(int n) {
+        return Dfs(n);
+    }
+
+    private int Dfs(int target) {
+        if (target == 0) return 0;
+
+        int res = target;
+        for (int i = 1; i * i <= target; i++) {
+            res = Math.Min(res, 1 + Dfs(target - i * i));
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -193,6 +212,29 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private Dictionary<int, int> memo = new Dictionary<int, int>();
+
+    public int NumSquares(int n) {
+        return Dfs(n);
+    }
+
+    private int Dfs(int target) {
+        if (target == 0) return 0;
+        if (memo.ContainsKey(target)) return memo[target];
+
+        int res = target;
+        for (int i = 1; i * i <= target; i++) {
+            res = Math.Min(res, 1 + Dfs(target - i * i));
+        }
+
+        memo[target] = res;
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -279,6 +321,25 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int NumSquares(int n) {
+        int[] dp = new int[n + 1];
+        Array.Fill(dp, n);
+        dp[0] = 0;
+
+        for (int target = 1; target <= n; target++) {
+            for (int s = 1; s * s <= target; s++) {
+                int square = s * s;
+                dp[target] = Math.Min(dp[target], 1 + dp[target - square]);
+            }
+        }
+
+        return dp[n];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -403,6 +464,40 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int NumSquares(int n) {
+        Queue<int> q = new Queue<int>();
+        HashSet<int> seen = new HashSet<int>();
+        
+        int res = 0;
+        q.Enqueue(0);
+        
+        while (q.Count > 0) {
+            res++;
+            int size = q.Count;
+            for (int i = 0; i < size; i++) {
+                int cur = q.Dequeue();
+                int s = 1;
+                while (s * s + cur <= n) {
+                    int nxt = cur + s * s;
+                    if (nxt == n) {
+                        return res;
+                    }
+                    if (!seen.Contains(nxt)) {
+                        seen.Add(nxt);
+                        q.Enqueue(nxt);
+                    }
+                    s++;
+                }
+            }
+        }
+        
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -540,6 +635,37 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int NumSquares(int n) {
+        while (n % 4 == 0) {
+            n /= 4;
+        }
+
+        if (n % 8 == 7) {
+            return 4;
+        }
+
+        bool IsSquareNum(int num) {
+            int s = (int)Math.Sqrt(num);
+            return s * s == num;
+        }
+
+        if (IsSquareNum(n)) {
+            return 1;
+        }
+
+        for (int i = 1; i * i <= n; i++) {
+            if (IsSquareNum(n - i * i)) {
+                return 2;
+            }
+        }
+
+        return 3;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/permutations-ii.md b/articles/permutations-ii.md
index d4c0edd41..83aefec3b 100644
--- a/articles/permutations-ii.md
+++ b/articles/permutations-ii.md
@@ -121,6 +121,38 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> PermuteUnique(int[] nums) {
+        HashSet<string> resSet = new HashSet<string>();
+        List<List<int>> result = new List<List<int>>();
+        Backtrack(new List<int>(), nums, resSet, result);
+        return result;
+    }
+
+    private void Backtrack(List<int> perm, int[] nums, HashSet<string> resSet, List<List<int>> result) {
+        if (perm.Count == nums.Length) {
+            string key = string.Join(",", perm);
+            if (resSet.Add(key)) {
+                result.Add(new List<int>(perm));
+            }
+            return;
+        }
+
+        for (int i = 0; i < nums.Length; i++) {
+            if (nums[i] != int.MinValue) {
+                int temp = nums[i];
+                perm.Add(temp);
+                nums[i] = int.MinValue;
+                Backtrack(perm, nums, resSet, result);
+                nums[i] = temp;
+                perm.RemoveAt(perm.Count - 1);
+            }
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -268,6 +300,44 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> PermuteUnique(int[] nums) {
+        var res = new List<List<int>>();
+        var perm = new List<int>();
+        var count = new Dictionary<int, int>();
+
+        foreach (int num in nums) {
+            if (!count.ContainsKey(num)) {
+                count[num] = 0;
+            }
+            count[num]++;
+        }
+
+        void Dfs() {
+            if (perm.Count == nums.Length) {
+                res.Add(new List<int>(perm));
+                return;
+            }
+
+            foreach (var kvp in count) {
+                int num = kvp.Key;
+                if (count[num] > 0) {
+                    perm.Add(num);
+                    count[num]--;
+                    Dfs();
+                    count[num]++;
+                    perm.RemoveAt(perm.Count - 1);
+                }
+            }
+        }
+
+        Dfs();
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -413,6 +483,39 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> PermuteUnique(int[] nums) {
+        var res = new List<List<int>>();
+        var perm = new List<int>();
+        int n = nums.Length;
+        bool[] visit = new bool[n];
+        Array.Sort(nums);
+
+        void Dfs() {
+            if (perm.Count == n) {
+                res.Add(new List<int>(perm));
+                return;
+            }
+
+            for (int i = 0; i < n; i++) {
+                if (visit[i]) continue;
+                if (i > 0 && nums[i] == nums[i - 1] && !visit[i - 1]) continue;
+
+                visit[i] = true;
+                perm.Add(nums[i]);
+                Dfs();
+                perm.RemoveAt(perm.Count - 1);
+                visit[i] = false;
+            }
+        }
+
+        Dfs();
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -552,6 +655,41 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> PermuteUnique(int[] nums) {
+        var res = new List<List<int>>();
+        Array.Sort(nums);
+        Dfs(0);
+        return res;
+
+        void Dfs(int i) {
+            if (i == nums.Length) {
+                res.Add(new List<int>(nums));
+                return;
+            }
+
+            for (int j = i; j < nums.Length; j++) {
+                if (j > i && nums[j] == nums[i]) continue;
+
+                Swap(i, j);
+                Dfs(i + 1);
+            }
+
+            for (int j = nums.Length - 1; j > i; j--) {
+                Swap(i, j);
+            }
+        }
+
+        void Swap(int a, int b) {
+            int temp = nums[a];
+            nums[a] = nums[b];
+            nums[b] = temp;
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -704,6 +842,48 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<List<int>> PermuteUnique(int[] nums) {
+        int n = nums.Length;
+        Array.Sort(nums);
+        var res = new List<List<int>>();
+        res.Add(new List<int>(nums));
+
+        while (true) {
+            int i = n - 2;
+            while (i >= 0 && nums[i] >= nums[i + 1]) {
+                i--;
+            }
+
+            if (i < 0) break;
+
+            int j = n - 1;
+            while (nums[j] <= nums[i]) {
+                j--;
+            }
+
+            Swap(nums, i, j);
+
+            int left = i + 1, right = n - 1;
+            while (left < right) {
+                Swap(nums, left++, right--);
+            }
+
+            res.Add(new List<int>(nums));
+        }
+
+        return res;
+    }
+
+    private void Swap(int[] nums, int i, int j) {
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/remove-duplicates-from-sorted-array.md b/articles/remove-duplicates-from-sorted-array.md
index 57bb96cdc..7629a2ff3 100644
--- a/articles/remove-duplicates-from-sorted-array.md
+++ b/articles/remove-duplicates-from-sorted-array.md
@@ -56,6 +56,16 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int RemoveDuplicates(int[] nums) {
+        int[] unique = nums.Distinct().OrderBy(x => x).ToArray();
+        Array.Copy(unique, nums, unique.Length);
+        return unique.Length;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -135,6 +145,25 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int RemoveDuplicates(int[] nums) {
+        int n = nums.Length;
+        int l = 0, r = 0;
+
+        while (r < n) {
+            nums[l] = nums[r];
+            while (r < n && nums[r] == nums[l]) {
+                r++;
+            }
+            l++;
+        }
+
+        return l;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -206,6 +235,22 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int RemoveDuplicates(int[] nums) {
+        int l = 1;
+        for (int r = 1; r < nums.Length; r++) {
+            if (nums[r] != nums[r - 1]) {
+                nums[l] = nums[r];
+                l++;
+            }
+        }
+
+        return l;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/reverse-linked-list-ii.md b/articles/reverse-linked-list-ii.md
index 5a3d69df7..98f00e838 100644
--- a/articles/reverse-linked-list-ii.md
+++ b/articles/reverse-linked-list-ii.md
@@ -194,6 +194,57 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode ReverseBetween(ListNode head, int left, int right) {
+        ListNode dummy = new ListNode(0, head);
+        ListNode prev = dummy;
+
+        for (int i = 0; i < left - 1; i++) {
+            prev = prev.next;
+        }
+
+        ListNode sublistHead = prev.next;
+        ListNode sublistTail = sublistHead;
+        for (int i = 0; i < right - left; i++) {
+            sublistTail = sublistTail.next;
+        }
+
+        ListNode nextNode = sublistTail.next;
+        sublistTail.next = null;
+
+        ListNode reversedSublist = ReverseList(sublistHead);
+        prev.next = reversedSublist;
+        sublistHead.next = nextNode;
+
+        return dummy.next;
+    }
+
+    private ListNode ReverseList(ListNode head) {
+        if (head == null) return null;
+
+        ListNode newHead = head;
+        if (head.next != null) {
+            newHead = ReverseList(head.next);
+            head.next.next = head;
+        }
+        head.next = null;
+        return newHead;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -334,6 +385,42 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    private ListNode successor = null;
+
+    private ListNode ReverseList(ListNode node, int n) {
+        if (n == 1) {
+            successor = node.next;
+            return node;
+        }
+        ListNode newHead = ReverseList(node.next, n - 1);
+        node.next.next = node;
+        node.next = successor;
+        return newHead;
+    }
+
+    public ListNode ReverseBetween(ListNode head, int left, int right) {
+        if (left == 1) {
+            return ReverseList(head, right);
+        }
+        head.next = ReverseBetween(head.next, left - 1, right - 1);
+        return head;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -540,6 +627,58 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode ReverseBetween(ListNode head, int left, int right) {
+        ListNode dummy = new ListNode(0);
+        dummy.next = head;
+        ListNode prev = dummy;
+
+        for (int i = 0; i < left - 1; i++) {
+            prev = prev.next;
+        }
+
+        ListNode sublistHead = prev.next;
+        ListNode sublistTail = sublistHead;
+        for (int i = 0; i < right - left; i++) {
+            sublistTail = sublistTail.next;
+        }
+
+        ListNode nextNode = sublistTail.next;
+        sublistTail.next = null;
+
+        ListNode reversedSublist = ReverseList(sublistHead);
+        prev.next = reversedSublist;
+
+        sublistHead.next = nextNode;
+        return dummy.next;
+    }
+
+    private ListNode ReverseList(ListNode head) {
+        ListNode prev = null;
+        ListNode curr = head;
+        while (curr != null) {
+            ListNode temp = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = temp;
+        }
+        return prev;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -699,6 +838,44 @@ class Solution {
 }
 ```
 
+```csharp
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode ReverseBetween(ListNode head, int left, int right) {
+        ListNode dummy = new ListNode(0, head);
+        ListNode leftPrev = dummy, curr = head;
+
+        for (int i = 0; i < left - 1; i++) {
+            leftPrev = curr;
+            curr = curr.next;
+        }
+
+        ListNode prev = null;
+        for (int i = 0; i < right - left + 1; i++) {
+            ListNode tmpNext = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = tmpNext;
+        }
+
+        leftPrev.next.next = curr;
+        leftPrev.next = prev;
+
+        return dummy.next;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/reverse-string.md b/articles/reverse-string.md
index ac60401c5..6c671dd5f 100644
--- a/articles/reverse-string.md
+++ b/articles/reverse-string.md
@@ -62,6 +62,23 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public void ReverseString(char[] s) {
+        char[] tmp = new char[s.Length];
+        int n = s.Length;
+
+        for (int i = 0; i < n; i++) {
+            tmp[i] = s[n - 1 - i];
+        }
+
+        for (int i = 0; i < n; i++) {
+            s[i] = tmp[i];
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -141,6 +158,23 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public void ReverseString(char[] s) {
+        Reverse(s, 0, s.Length - 1);
+    }
+
+    private void Reverse(char[] s, int left, int right) {
+        if (left < right) {
+            Reverse(s, left + 1, right - 1);
+            char temp = s[left];
+            s[left] = s[right];
+            s[right] = temp;
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -220,6 +254,22 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public void ReverseString(char[] s) {
+        Stack<char> stack = new Stack<char>();
+
+        foreach (char c in s) {
+            stack.Push(c);
+        }
+
+        for (int i = 0; i < s.Length; i++) {
+            s[i] = stack.Pop();
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -279,6 +329,14 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public void ReverseString(char[] s) {
+        Array.Reverse(s);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -349,6 +407,21 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public void ReverseString(char[] s) {
+        int l = 0, r = s.Length - 1;
+        while (l < r) {
+            char temp = s[l];
+            s[l] = s[r];
+            s[r] = temp;
+            l++;
+            r--;
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/search-in-rotated-sorted-array-ii.md b/articles/search-in-rotated-sorted-array-ii.md
index d77b4c923..04af02db0 100644
--- a/articles/search-in-rotated-sorted-array-ii.md
+++ b/articles/search-in-rotated-sorted-array-ii.md
@@ -53,6 +53,14 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool Search(int[] nums, int target) {
+        return nums.Contains(target);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -199,6 +207,37 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool Search(int[] nums, int target) {
+        int l = 0, r = nums.Length - 1;
+        while (l <= r) {
+            int m = l + (r - l) / 2;
+            if (nums[m] == target) {
+                return true;
+            }
+
+            if (nums[l] < nums[m]) {
+                if (nums[l] <= target && target < nums[m]) {
+                    r = m - 1;
+                } else {
+                    l = m + 1;
+                }
+            } else if (nums[l] > nums[m]) {
+                if (nums[m] < target && target <= nums[r]) {
+                    l = m + 1;
+                } else {
+                    r = m - 1;
+                }
+            } else {
+                l++;
+            }
+        }
+        return false;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/search-insert-position.md b/articles/search-insert-position.md
index 225a7e0a1..7e6cbd60e 100644
--- a/articles/search-insert-position.md
+++ b/articles/search-insert-position.md
@@ -56,6 +56,19 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SearchInsert(int[] nums, int target) {
+        for (int i = 0; i < nums.Length; i++) {
+            if (nums[i] >= target) {
+                return i;
+            }
+        }
+        return nums.Length;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -158,6 +171,30 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SearchInsert(int[] nums, int target) {
+        int res = nums.Length;
+        int l = 0, r = nums.Length - 1;
+
+        while (l <= r) {
+            int mid = (l + r) / 2;
+            if (nums[mid] == target) {
+                return mid;
+            }
+            if (nums[mid] > target) {
+                res = mid;
+                r = mid - 1;
+            } else {
+                l = mid + 1;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -252,6 +289,28 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SearchInsert(int[] nums, int target) {
+        int l = 0, r = nums.Length - 1;
+
+        while (l <= r) {
+            int mid = (l + r) / 2;
+            if (nums[mid] == target) {
+                return mid;
+            }
+            if (nums[mid] > target) {
+                r = mid - 1;
+            } else {
+                l = mid + 1;
+            }
+        }
+
+        return l;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -335,6 +394,25 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SearchInsert(int[] nums, int target) {
+        int l = 0, r = nums.Length;
+
+        while (l < r) {
+            int m = l + (r - l) / 2;
+            if (nums[m] >= target) {
+                r = m;
+            } else {
+                l = m + 1;
+            }
+        }
+
+        return l;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -388,6 +466,15 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SearchInsert(int[] nums, int target) {
+        int idx = Array.BinarySearch(nums, target);
+        return idx >= 0 ? idx : ~idx;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/simplify-path.md b/articles/simplify-path.md
index 23fe29c96..ae0ecb3ee 100644
--- a/articles/simplify-path.md
+++ b/articles/simplify-path.md
@@ -105,6 +105,32 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string SimplifyPath(string path) {
+        Stack<string> stack = new Stack<string>();
+        string cur = "";
+
+        foreach (char c in path + "/") {
+            if (c == '/') {
+                if (cur == "..") {
+                    if (stack.Count > 0) stack.Pop();
+                } else if (cur != "" && cur != ".") {
+                    stack.Push(cur);
+                }
+                cur = "";
+            } else {
+                cur += c;
+            }
+        }
+
+        var result = new List<string>(stack);
+        result.Reverse();
+        return "/" + string.Join("/", result);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -205,6 +231,29 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string SimplifyPath(string path) {
+        Stack<string> stack = new Stack<string>();
+        string[] parts = path.Split('/');
+
+        foreach (string part in parts) {
+            if (part == "..") {
+                if (stack.Count > 0) {
+                    stack.Pop();
+                }
+            } else if (part != "" && part != ".") {
+                stack.Push(part);
+            }
+        }
+
+        var result = new List<string>(stack);
+        result.Reverse();
+        return "/" + string.Join("/", result);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/single-threaded-cpu.md b/articles/single-threaded-cpu.md
index 5b7005989..16f487b94 100644
--- a/articles/single-threaded-cpu.md
+++ b/articles/single-threaded-cpu.md
@@ -109,12 +109,12 @@ class Solution {
      * @return {number[]}
      */
     getOrder(tasks) {
-        const available = new MinPriorityQueue({
-            compare: (a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]
-        });
-        const pending = new MinPriorityQueue({
-            compare: (a, b) => a[0] - b[0]
-        });
+        const available = new PriorityQueue(
+            (a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]
+        );
+        const pending = new PriorityQueue(
+            (a, b) => a[0] - b[0]
+        );
 
         tasks.forEach(([enqueueTime, processTime], i) => {
             pending.enqueue([enqueueTime, processTime, i]);
@@ -143,6 +143,42 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int[] GetOrder(int[][] tasks) {
+        var available = new PriorityQueue<(int procTime, int index), (int procTime, int index)>();
+        var pending = new PriorityQueue<(int startTime, int procTime, int index), int>();
+
+        int n = tasks.Length;
+        for (int i = 0; i < n; i++) {
+            pending.Enqueue((tasks[i][0], tasks[i][1], i), tasks[i][0]);
+        }
+
+        long time = 0;
+        int[] res = new int[n];
+        int idx = 0;
+
+        while (pending.Count > 0 || available.Count > 0) {
+            while (pending.Count > 0 && pending.Peek().startTime <= time) {
+                var task = pending.Dequeue();
+                available.Enqueue((task.procTime, task.index), (task.procTime, task.index));
+            }
+
+            if (available.Count == 0) {
+                time = pending.Peek().startTime;
+                continue;
+            }
+
+            var next = available.Dequeue();
+            time += next.procTime;
+            res[idx++] = next.index;
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -259,9 +295,9 @@ class Solution {
         tasks.sort((a, b) => a[0] - b[0]);
 
         const res = [];
-        const minHeap = new MinPriorityQueue({ compare: (a, b) => 
+        const minHeap = new PriorityQueue((a, b) => 
             a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]
-        });
+        );
 
         let i = 0, time = tasks[0][0];
         while (minHeap.size() || i < n) {
@@ -282,6 +318,44 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int[] GetOrder(int[][] tasks) {
+        int n = tasks.Length;
+        int i = 0;
+        for (; i < n; i++) {
+            tasks[i] = new int[] { tasks[i][0], tasks[i][1], i }; // {enqueueTime, processingTime, index}
+        }
+
+        Array.Sort(tasks, (a, b) => a[0].CompareTo(b[0])); // sort by enqueueTime
+
+        int[] res = new int[n];
+        var minHeap = new PriorityQueue<(int procTime, int index), (int procTime, int index)>();
+
+        int idx = 0;
+        i = 0;
+        long time = tasks[0][0];
+
+        while (minHeap.Count > 0 || i < n) {
+            while (i < n && tasks[i][0] <= time) {
+                minHeap.Enqueue((tasks[i][1], tasks[i][2]), (tasks[i][1], tasks[i][2]));
+                i++;
+            }
+
+            if (minHeap.Count == 0) {
+                time = tasks[i][0];
+            } else {
+                var task = minHeap.Dequeue();
+                time += task.procTime;
+                res[idx++] = task.index;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -430,14 +504,14 @@ class Solution {
             return a - b;
         });
 
-        const minHeap = new MinPriorityQueue({
-            compare: (a, b) => {
+        const minHeap = new PriorityQueue(
+            (a, b) => {
                 if (tasks[a][1] !== tasks[b][1]) {
                     return tasks[a][1] - tasks[b][1];
                 }
                 return a - b;
             }
-        });
+        );
 
         const res = [];
         let time = 0;
@@ -463,6 +537,48 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int[] GetOrder(int[][] tasks) {
+        int n = tasks.Length;
+        int[] indices = new int[n];
+        int i = 0;
+        for (; i < n; i++) {
+            indices[i] = i;
+        }
+
+        Array.Sort(indices, (a, b) =>
+            tasks[a][0] != tasks[b][0] ? tasks[a][0].CompareTo(tasks[b][0]) : a.CompareTo(b)
+        );
+
+        var minHeap = new PriorityQueue<int, (int procTime, int index)>();
+
+        int[] result = new int[n];
+        long time = 0;
+        int resIndex = 0;
+        i = 0;
+
+        while (minHeap.Count > 0 || i < n) {
+            while (i < n && tasks[indices[i]][0] <= time) {
+                int idx = indices[i];
+                minHeap.Enqueue(idx, (tasks[idx][1], idx));
+                i++;
+            }
+
+            if (minHeap.Count == 0) {
+                time = tasks[indices[i]][0];
+            } else {
+                int nextIndex = minHeap.Dequeue();
+                time += tasks[nextIndex][1];
+                result[resIndex++] = nextIndex;
+            }
+        }
+
+        return result;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/sort-an-array.md b/articles/sort-an-array.md
index 265db6b33..6b34f49d2 100644
--- a/articles/sort-an-array.md
+++ b/articles/sort-an-array.md
@@ -261,7 +261,7 @@ public class Solution {
 
 ### Time & Space Complexity
 
-* Time complexity: $O(n)$ in average case, $O(n ^ 2)$ in worst case.
+* Time complexity: $O(n \log n)$ in average case, $O(n ^ 2)$ in worst case.
 * Space complexity: $O(\log n)$ for recursive stack.
 
 ---
@@ -1369,4 +1369,4 @@ public class Solution {
 ### Time & Space Complexity
 
 * Time complexity: $O(n \log n)$ in average case, $O(n ^ 2)$ in worst case.
-* Space complexity: $O(1)$
\ No newline at end of file
+* Space complexity: $O(1)$
diff --git a/articles/split-array-largest-sum.md b/articles/split-array-largest-sum.md
index dccf649c5..617691f9b 100644
--- a/articles/split-array-largest-sum.md
+++ b/articles/split-array-largest-sum.md
@@ -113,6 +113,36 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SplitArray(int[] nums, int k) {
+        int n = nums.Length;
+        return Dfs(nums, 0, k, n);
+    }
+
+    private int Dfs(int[] nums, int i, int m, int n) {
+        if (i == n) {
+            return m == 0 ? 0 : int.MaxValue;
+        }
+        if (m == 0) {
+            return int.MaxValue;
+        }
+
+        int res = int.MaxValue;
+        int curSum = 0;
+        for (int j = i; j <= n - m; j++) {
+            curSum += nums[j];
+            int next = Dfs(nums, j + 1, m - 1, n);
+            if (next != int.MaxValue) {
+                res = Math.Min(res, Math.Max(curSum, next));
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -231,7 +261,7 @@ class Solution {
      */
     splitArray(nums, k) {
         const n = nums.length;
-        const dp = Array.from({ length: n }, () => Array(m + 1).fill(-1));
+        const dp = Array.from({ length: n }, () => Array(k + 1).fill(-1));
 
         const dfs = (i, m) => {
             if (i === n) {
@@ -259,6 +289,50 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private int[,] dp;
+
+    public int SplitArray(int[] nums, int k) {
+        int n = nums.Length;
+        dp = new int[n, k + 1];
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j <= k; j++) {
+                dp[i, j] = -1;
+            }
+        }
+
+        return Dfs(nums, 0, k, n);
+    }
+
+    private int Dfs(int[] nums, int i, int m, int n) {
+        if (i == n) {
+            return m == 0 ? 0 : int.MaxValue;
+        }
+        if (m == 0) {
+            return int.MaxValue;
+        }
+        if (dp[i, m] != -1) {
+            return dp[i, m];
+        }
+
+        int res = int.MaxValue;
+        int curSum = 0;
+        for (int j = i; j <= n - m; j++) {
+            curSum += nums[j];
+            int next = Dfs(nums, j + 1, m - 1, n);
+            if (next != int.MaxValue) {
+                res = Math.Min(res, Math.Max(curSum, next));
+            }
+        }
+
+        dp[i, m] = res;
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -368,6 +442,37 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SplitArray(int[] nums, int k) {
+        int n = nums.Length;
+        int[,] dp = new int[n + 1, k + 1];
+
+        for (int i = 0; i <= n; i++) {
+            for (int j = 0; j <= k; j++) {
+                dp[i, j] = int.MaxValue;
+            }
+        }
+
+        dp[n, 0] = 0;
+
+        for (int m = 1; m <= k; m++) {
+            for (int i = n - 1; i >= 0; i--) {
+                int curSum = 0;
+                for (int j = i; j < n - m + 1; j++) {
+                    curSum += nums[j];
+                    if (dp[j + 1, m - 1] != int.MaxValue) {
+                        dp[i, m] = Math.Min(dp[i, m], Math.Max(curSum, dp[j + 1, m - 1]));
+                    }
+                }
+            }
+        }
+
+        return dp[0, k];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -485,6 +590,36 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SplitArray(int[] nums, int k) {
+        int n = nums.Length;
+        int[] dp = new int[n + 1];
+        int[] nextDp = new int[n + 1];
+        Array.Fill(dp, int.MaxValue);
+        dp[n] = 0;
+
+        for (int m = 1; m <= k; m++) {
+            Array.Fill(nextDp, int.MaxValue);
+            for (int i = n - 1; i >= 0; i--) {
+                int curSum = 0;
+                for (int j = i; j < n - m + 1; j++) {
+                    curSum += nums[j];
+                    if (dp[j + 1] != int.MaxValue) {
+                        nextDp[i] = Math.Min(nextDp[i], Math.Max(curSum, dp[j + 1]));
+                    }
+                }
+            }
+            var temp = dp;
+            dp = nextDp;
+            nextDp = temp;
+        }
+
+        return dp[0];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -639,6 +774,43 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SplitArray(int[] nums, int k) {
+        int l = 0, r = 0, res = 0;
+        foreach (int num in nums) {
+            l = Math.Max(l, num);
+            r += num;
+        }
+        res = r;
+
+        while (l <= r) {
+            int mid = l + (r - l) / 2;
+            if (CanSplit(nums, k, mid)) {
+                res = mid;
+                r = mid - 1;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return res;
+    }
+
+    private bool CanSplit(int[] nums, int k, int largest) {
+        int subarray = 1, curSum = 0;
+        foreach (int num in nums) {
+            curSum += num;
+            if (curSum > largest) {
+                subarray++;
+                if (subarray > k) return false;
+                curSum = num;
+            }
+        }
+        return true;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -852,6 +1024,60 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private int[] prefix;
+    private int n;
+
+    public int SplitArray(int[] nums, int k) {
+        n = nums.Length;
+        prefix = new int[n + 1];
+        for (int i = 0; i < n; i++) {
+            prefix[i + 1] = prefix[i] + nums[i];
+        }
+
+        int l = int.MinValue, r = 0;
+        foreach (int num in nums) {
+            l = Math.Max(l, num);
+            r += num;
+        }
+
+        int res = r;
+        while (l <= r) {
+            int mid = l + (r - l) / 2;
+            if (CanSplit(mid, k)) {
+                res = mid;
+                r = mid - 1;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return res;
+    }
+
+    private bool CanSplit(int largest, int k) {
+        int subarrays = 0, i = 0;
+        while (i < n) {
+            int l = i + 1, r = n;
+            while (l <= r) {
+                int mid = l + (r - l) / 2;
+                if (prefix[mid] - prefix[i] <= largest) {
+                    l = mid + 1;
+                } else {
+                    r = mid - 1;
+                }
+            }
+            subarrays++;
+            i = r;
+            if (subarrays > k) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/sqrtx.md b/articles/sqrtx.md
index 13d854b33..bc2e10fa7 100644
--- a/articles/sqrtx.md
+++ b/articles/sqrtx.md
@@ -82,6 +82,23 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MySqrt(int x) {
+        if (x == 0) return 0;
+
+        int res = 1;
+        for (int i = 1; i <= x; i++) {
+            if ((long)i * i > x) {
+                return res;
+            }
+            res = i;
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -130,6 +147,14 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MySqrt(int x) {
+        return (int)Math.Sqrt(x);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -236,6 +261,31 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MySqrt(int x) {
+        int l = 0, r = x;
+        int res = 0;
+
+        while (l <= r) {
+            int m = l + (r - l) / 2;
+            long sq = (long)m * m;
+
+            if (sq > x) {
+                r = m - 1;
+            } else if (sq < x) {
+                l = m + 1;
+                res = m;
+            } else {
+                return m;
+            }
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -307,6 +357,20 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MySqrt(int x) {
+        if (x < 2) {
+            return x;
+        }
+
+        int l = MySqrt(x >> 2) << 1;
+        int r = l + 1;
+        return (long)r * r > x ? l : r;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -370,6 +434,18 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int MySqrt(int x) {
+        long r = x;
+        while (r * r > x) {
+            r = (r + x / r) >> 1;
+        }
+        return (int)r;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/stone-game-iii.md b/articles/stone-game-iii.md
index e95a8e508..781024036 100644
--- a/articles/stone-game-iii.md
+++ b/articles/stone-game-iii.md
@@ -144,6 +144,40 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string StoneGameIII(int[] stoneValue) {
+        int n = stoneValue.Length;
+        int?[,] dp = new int?[n, 2];
+
+        int Dfs(int i, int alice) {
+            if (i >= n) return 0;
+            if (dp[i, alice].HasValue) return dp[i, alice].Value;
+
+            int res = alice == 1 ? int.MinValue : int.MaxValue;
+            int score = 0;
+
+            for (int j = i; j < Math.Min(i + 3, n); j++) {
+                if (alice == 1) {
+                    score += stoneValue[j];
+                    res = Math.Max(res, score + Dfs(j + 1, 0));
+                } else {
+                    score -= stoneValue[j];
+                    res = Math.Min(res, score + Dfs(j + 1, 1));
+                }
+            }
+
+            dp[i, alice] = res;
+            return res;
+        }
+
+        int result = Dfs(0, 1);
+        if (result == 0) return "Tie";
+        return result > 0 ? "Alice" : "Bob";
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -277,6 +311,33 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string StoneGameIII(int[] stoneValue) {
+        int n = stoneValue.Length;
+        Dictionary<int, int> dp = new Dictionary<int, int>();
+
+        int Dfs(int i) {
+            if (i >= n) return 0;
+            if (dp.ContainsKey(i)) return dp[i];
+
+            int res = int.MinValue, total = 0;
+            for (int j = i; j < Math.Min(i + 3, n); j++) {
+                total += stoneValue[j];
+                res = Math.Max(res, total - Dfs(j + 1));
+            }
+
+            dp[i] = res;
+            return res;
+        }
+
+        int result = Dfs(0);
+        if (result == 0) return "Tie";
+        return result > 0 ? "Alice" : "Bob";
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -384,6 +445,29 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string StoneGameIII(int[] stoneValue) {
+        int n = stoneValue.Length;
+        int[] dp = new int[n + 1];
+        for (int i = 0; i <= n; i++) dp[i] = int.MinValue;
+        dp[n] = 0;
+
+        for (int i = n - 1; i >= 0; i--) {
+            int total = 0;
+            for (int j = i; j < Math.Min(i + 3, n); j++) {
+                total += stoneValue[j];
+                dp[i] = Math.Max(dp[i], total - dp[j + 1]);
+            }
+        }
+
+        int result = dp[0];
+        if (result == 0) return "Tie";
+        return result > 0 ? "Alice" : "Bob";
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -483,6 +567,28 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public string StoneGameIII(int[] stoneValue) {
+        int n = stoneValue.Length;
+        int[] dp = new int[4];
+
+        for (int i = n - 1; i >= 0; i--) {
+            int total = 0;
+            dp[i % 4] = int.MinValue;
+
+            for (int j = i; j < Math.Min(i + 3, n); j++) {
+                total += stoneValue[j];
+                dp[i % 4] = Math.Max(dp[i % 4], total - dp[(j + 1) % 4]);
+            }
+        }
+
+        if (dp[0] == 0) return "Tie";
+        return dp[0] > 0 ? "Alice" : "Bob";
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/sum-of-all-subset-xor-totals.md b/articles/sum-of-all-subset-xor-totals.md
index b1f8dc9ae..b35c24e37 100644
--- a/articles/sum-of-all-subset-xor-totals.md
+++ b/articles/sum-of-all-subset-xor-totals.md
@@ -98,6 +98,31 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    private int res = 0;
+
+    public int SubsetXORSum(int[] nums) {
+        Backtrack(0, new List<int>(), nums);
+        return res;
+    }
+
+    private void Backtrack(int i, List<int> subset, int[] nums) {
+        int xorr = 0;
+        foreach (int num in subset) {
+            xorr ^= num;
+        }
+        res += xorr;
+
+        for (int j = i; j < nums.Length; j++) {
+            subset.Add(nums[j]);
+            Backtrack(j + 1, subset, nums);
+            subset.RemoveAt(subset.Count - 1);
+        }
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -173,6 +198,21 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SubsetXORSum(int[] nums) {
+        return Dfs(0, 0, nums);
+    }
+
+    private int Dfs(int i, int total, int[] nums) {
+        if (i == nums.Length) {
+            return total;
+        }
+        return Dfs(i + 1, total ^ nums[i], nums) + Dfs(i + 1, total, nums);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -270,6 +310,27 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SubsetXORSum(int[] nums) {
+        int n = nums.Length;
+        int res = 0;
+
+        for (int mask = 0; mask < (1 << n); mask++) {
+            int xorr = 0;
+            for (int i = 0; i < n; i++) {
+                if ((mask & (1 << i)) != 0) {
+                    xorr ^= nums[i];
+                }
+            }
+            res += xorr;
+        }
+
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -333,6 +394,18 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public int SubsetXORSum(int[] nums) {
+        int res = 0;
+        foreach (int num in nums) {
+            res |= num;
+        }
+        return res << (nums.Length - 1);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/verifying-an-alien-dictionary.md b/articles/verifying-an-alien-dictionary.md
index 7ab6ac58d..86694cf0a 100644
--- a/articles/verifying-an-alien-dictionary.md
+++ b/articles/verifying-an-alien-dictionary.md
@@ -84,6 +84,35 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool IsAlienSorted(string[] words, string order) {
+        int[] orderIndex = new int[26];
+        for (int i = 0; i < order.Length; i++) {
+            orderIndex[order[i] - 'a'] = i;
+        }
+
+        string[] sortedWords = (string[])words.Clone();
+        Array.Sort(sortedWords, (w1, w2) => {
+            for (int i = 0; i < Math.Min(w1.Length, w2.Length); i++) {
+                if (w1[i] != w2[i]) {
+                    return orderIndex[w1[i] - 'a'] - orderIndex[w2[i] - 'a'];
+                }
+            }
+            return w1.Length - w2.Length;
+        });
+
+        for (int i = 0; i < words.Length; i++) {
+            if (!words[i].Equals(sortedWords[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -201,6 +230,37 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public bool IsAlienSorted(string[] words, string order) {
+        Dictionary<char, int> orderIndex = new Dictionary<char, int>();
+        for (int i = 0; i < order.Length; i++) {
+            orderIndex[order[i]] = i;
+        }
+
+        for (int i = 0; i < words.Length - 1; i++) {
+            string w1 = words[i];
+            string w2 = words[i + 1];
+
+            for (int j = 0; j < w1.Length; j++) {
+                if (j == w2.Length) {
+                    return false;
+                }
+
+                if (w1[j] != w2[j]) {
+                    if (orderIndex[w1[j]] > orderIndex[w2[j]]) {
+                        return false;
+                    }
+                    break;
+                }
+            }
+        }
+
+        return true;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/word-break-ii.md b/articles/word-break-ii.md
index c075d2b67..45660e5f9 100644
--- a/articles/word-break-ii.md
+++ b/articles/word-break-ii.md
@@ -131,6 +131,35 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<string> WordBreak(string s, List<string> wordDict) {
+        HashSet<string> wordSet = new HashSet<string>(wordDict);
+        List<string> res = new List<string>();
+        List<string> cur = new List<string>();
+
+        void Backtrack(int i) {
+            if (i == s.Length) {
+                res.Add(string.Join(" ", cur));
+                return;
+            }
+
+            for (int j = i; j < s.Length; j++) {
+                string word = s.Substring(i, j - i + 1);
+                if (wordSet.Contains(word)) {
+                    cur.Add(word);
+                    Backtrack(j + 1);
+                    cur.RemoveAt(cur.Count - 1);
+                }
+            }
+        }
+
+        Backtrack(0);
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -401,6 +430,66 @@ class Solution {
 }
 ```
 
+```csharp
+public class TrieNode {
+    public Dictionary<char, TrieNode> children = new Dictionary<char, TrieNode>();
+    public bool isWord = false;
+}
+
+public class Trie {
+    public TrieNode root = new TrieNode();
+
+    public void AddWord(string word) {
+        TrieNode curr = root;
+        foreach (char c in word) {
+            if (!curr.children.ContainsKey(c)) {
+                curr.children[c] = new TrieNode();
+            }
+            curr = curr.children[c];
+        }
+        curr.isWord = true;
+    }
+}
+
+public class Solution {
+    public List<string> WordBreak(string s, List<string> wordDict) {
+        Trie trie = new Trie();
+        foreach (string word in wordDict) {
+            trie.AddWord(word);
+        }
+
+        List<string> res = new List<string>();
+
+        void Backtrack(int index, List<string> path) {
+            if (index == s.Length) {
+                res.Add(string.Join(" ", path));
+                return;
+            }
+
+            TrieNode node = trie.root;
+            StringBuilder word = new StringBuilder();
+
+            for (int i = index; i < s.Length; i++) {
+                char c = s[i];
+                if (!node.children.ContainsKey(c)) break;
+
+                word.Append(c);
+                node = node.children[c];
+
+                if (node.isWord) {
+                    path.Add(word.ToString());
+                    Backtrack(i + 1, path);
+                    path.RemoveAt(path.Count - 1);
+                }
+            }
+        }
+
+        Backtrack(0, new List<string>());
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -561,6 +650,40 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<string> WordBreak(string s, List<string> wordDictList) {
+        HashSet<string> wordDict = new HashSet<string>(wordDictList);
+        Dictionary<int, List<string>> cache = new Dictionary<int, List<string>>();
+
+        List<string> Backtrack(int i) {
+            if (i == s.Length) return new List<string> { "" };
+            if (cache.ContainsKey(i)) return cache[i];
+
+            List<string> res = new List<string>();
+            for (int j = i; j < s.Length; j++) {
+                string w = s.Substring(i, j - i + 1);
+                if (!wordDict.Contains(w)) continue;
+
+                List<string> substrings = Backtrack(j + 1);
+                foreach (string substr in substrings) {
+                    string sentence = w;
+                    if (!string.IsNullOrEmpty(substr)) {
+                        sentence += " " + substr;
+                    }
+                    res.Add(sentence);
+                }
+            }
+
+            cache[i] = res;
+            return res;
+        }
+
+        return Backtrack(0);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -676,6 +799,34 @@ class Solution {
 }
 ```
 
+```csharp
+public class Solution {
+    public List<string> WordBreak(string s, List<string> wordDictList) {
+        HashSet<string> wordSet = new HashSet<string>(wordDictList);
+        int n = s.Length;
+        List<string>[] dp = new List<string>[n + 1];
+        for (int i = 0; i <= n; i++) {
+            dp[i] = new List<string>();
+        }
+        dp[0].Add("");
+
+        for (int i = 1; i <= n; i++) {
+            for (int j = 0; j < i; j++) {
+                string word = s.Substring(j, i - j);
+                if (wordSet.Contains(word)) {
+                    foreach (string sentence in dp[j]) {
+                        string space = string.IsNullOrEmpty(sentence) ? "" : " ";
+                        dp[i].Add(sentence + space + word);
+                    }
+                }
+            }
+        }
+
+        return dp[n];
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -965,6 +1116,68 @@ class Solution {
 }
 ```
 
+```csharp
+public class TrieNode {
+    public Dictionary<char, TrieNode> Children = new Dictionary<char, TrieNode>();
+    public bool IsWord = false;
+}
+
+public class Trie {
+    public TrieNode Root = new TrieNode();
+
+    public void AddWord(string word) {
+        TrieNode curr = Root;
+        foreach (char c in word) {
+            if (!curr.Children.ContainsKey(c)) {
+                curr.Children[c] = new TrieNode();
+            }
+            curr = curr.Children[c];
+        }
+        curr.IsWord = true;
+    }
+}
+
+public class Solution {
+    private Dictionary<int, List<string>> cache = new Dictionary<int, List<string>>();
+
+    public List<string> WordBreak(string s, List<string> wordDict) {
+        Trie trie = new Trie();
+        foreach (string word in wordDict) {
+            trie.AddWord(word);
+        }
+        return Backtrack(0, s, trie.Root, trie);
+    }
+
+    private List<string> Backtrack(int index, string s, TrieNode root, Trie trie) {
+        if (index == s.Length) return new List<string> { "" };
+        if (cache.ContainsKey(index)) return cache[index];
+
+        List<string> res = new List<string>();
+        TrieNode curr = root;
+
+        for (int i = index; i < s.Length; i++) {
+            char c = s[i];
+            if (!curr.Children.ContainsKey(c)) break;
+
+            curr = curr.Children[c];
+            if (curr.IsWord) {
+                List<string> suffixes = Backtrack(i + 1, s, root, trie);
+                foreach (string suffix in suffixes) {
+                    if (suffix == "") {
+                        res.Add(s.Substring(index, i - index + 1));
+                    } else {
+                        res.Add(s.Substring(index, i - index + 1) + " " + suffix);
+                    }
+                }
+            }
+        }
+
+        cache[index] = res;
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/python/0020-valid-parentheses.py b/python/0020-valid-parentheses.py
index 4d0ae3424..ce3bf39cd 100644
--- a/python/0020-valid-parentheses.py
+++ b/python/0020-valid-parentheses.py
@@ -1,13 +1,13 @@
 class Solution:
     def isValid(self, s: str) -> bool:
-        Map = {")": "(", "]": "[", "}": "{"}
+        bracketMap = {")": "(", "]": "[", "}": "{"}
         stack = []
 
         for c in s:
-            if c not in Map:
+            if c not in bracketMap:
                 stack.append(c)
                 continue
-            if not stack or stack[-1] != Map[c]:
+            if not stack or stack[-1] != bracketMap[c]:
                 return False
             stack.pop()