Merge pull request #1195 from ShrujanKotturi/main

Updated remaining C# solutions

Author: Ahmad-A0

Diff for: README.md

@@ -0,0 +1,43 @@
+public class Solution
+{
+    // T: O(M*N) | S: O(M*N)
+    public bool IsMatch(string s, string p)
+    {
+        // Top down
+        var cache = new Dictionary<(int, int), bool>();
+
+        bool dfs(int i, int j)
+        {
+            if (cache.ContainsKey((i, j)))
+                return cache[(i, j)];
+            if (i >= s.Length && j >= p.Length)
+                return true;
+            if (j >= p.Length)
+                return false;
+
+            var match = i < s.Length && (s[i] == p[j] || p[j] == '.');
+            if (j + 1 < p.Length && p[j + 1] == '*')
+            {
+                cache.TryAdd((i, j), false);
+                cache[(i, j)] = (match && dfs(i + 1, j)) || //use *
+                  dfs(i, j + 2); //dont use *
+                return cache[(i, j)];
+            }
+
+            if (match)
+            {
+                cache.TryAdd((i, j), false);
+                cache[(i, j)] = dfs(i + 1, j + 1);
+                return cache[(i, j)];
+
+            }
+
+            cache.TryAdd((i, j), false);
+            cache[(i, j)] = false;
+            return cache[(i, j)];
+
+        }
+
+        return dfs(0, 0);
+    }
+}

Diff for: csharp/10-Regular-Expression-Matching.cs

@@ -0,0 +1,49 @@
+public class Solution
+{
+    private PriorityQueue<int, int> pq;
+
+    // T: O(NLogN)
+    public int LastStoneWeight(int[] stones)
+    {
+        pq = new PriorityQueue<int, int>(new MaxHeapComparer());
+
+        AddStones(stones);
+        ComputeLastStoneWeight();
+
+        return pq.Count == 0 ? 0 : pq.Dequeue();
+    }
+
+
+    private void AddStones(int[] stones)
+    {
+        foreach (var stone in stones)
+        {
+            // T: Heapify is O(N) for every enqueued item
+            pq.Enqueue(stone, stone);
+        }
+    }
+
+    // T: O(NLogN), to get max value its O(LogN) and we perform this for N items => O(NLogN)
+    private void ComputeLastStoneWeight()
+    {
+        while (pq.Count > 1)
+        {
+            var y = pq.Dequeue();
+            var x = pq.Dequeue();
+
+            if (x != y)
+            {
+                var diff = y - x;
+                pq.Enqueue(diff, diff);
+            }
+        }
+    }
+
+    public class MaxHeapComparer : IComparer<int>
+    {
+        public int Compare(int x, int y)
+        {
+            return y - x;
+        }
+    }
+}

Diff for: csharp/1046-Last-Stone-Weight.cs

@@ -0,0 +1,38 @@
+/**
+ * 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 BuildTree(int[] preorder, int[] inorder)
+    {
+        return BuildTreeHelper(0, 0, inorder.Length - 1, preorder, inorder);
+    }
+
+    private TreeNode BuildTreeHelper(int preStart, int inStart, int inEnd, int[] preorder, int[] inorder)
+    {
+        if (preorder.Length == 0 && inorder.Length == 0)
+            return null;
+
+        if (preStart > preorder.Length - 1 || inStart > inEnd)
+            return null;
+
+        var rootNode = new TreeNode(preorder[preStart]);
+        var mid = Array.IndexOf(inorder, preorder[preStart]);
+
+        rootNode.left = BuildTreeHelper(preStart + 1, inStart, mid - 1, preorder, inorder);
+        rootNode.right = BuildTreeHelper(preStart + mid - inStart + 1, mid + 1, inEnd, preorder, inorder);
+
+        return rootNode;
+    }
+}

Diff for: csharp/105-Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal.cs

@@ -0,0 +1,40 @@
+/**
+ * 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
+{
+
+    //T: O(N) and S: O(H)
+    public bool IsBalanced(TreeNode root)
+    {
+        return checkHeight(root) != int.MinValue;
+    }
+
+    private int checkHeight(TreeNode root)
+    {
+        if (root == null)
+            return -1;
+        var leftHeight = checkHeight(root.left);
+        if (leftHeight == int.MinValue) return leftHeight;
+
+        var rightHeight = checkHeight(root.right);
+        if (rightHeight == int.MinValue) return rightHeight;
+
+        var heightDiff = leftHeight - rightHeight;
+        if (Math.Abs(heightDiff) > 1)
+            return int.MinValue;
+        else
+            return Math.Max(leftHeight, rightHeight) + 1;
+
+    }
+}

Diff for: csharp/110-Balanced-Binary-Tree.cs

@@ -0,0 +1,73 @@
+public class Solution
+{
+    //T: O(N^2*M) where N is the length of the word, M is total no. of words
+    //S: O(N^2*M) where N is the length of the word, M is total no. of words
+    public int LadderLength(string beginWord, string endWord, IList<string> wordList)
+    {
+        if (!wordList.Contains(endWord))
+        {
+            return 0;
+        }
+
+        var nei = new Dictionary<string,
+          HashSet<string>>();
+        if (!wordList.Contains(beginWord))
+            wordList.Add(beginWord);
+
+        foreach (var word in wordList)
+        {
+            for (var j = 0; j < word.Length; j++)
+            {
+                var pattern = word.Substring(0, j) + "*" + word.Substring(j + 1);
+                nei.TryAdd(pattern, new HashSet<string>());
+                nei[pattern].Add(word);
+            }
+        }
+
+        foreach (var neiWord in nei.Keys)
+        {
+            foreach (var val in nei[neiWord])
+            {
+                Console.WriteLine("neiWord : " + neiWord + " val : " + val);
+            }
+        }
+
+        var visited = new HashSet<string>();
+        visited.Add(beginWord);
+
+        var queue = new Queue<string>();
+        queue.Enqueue(beginWord);
+
+        var result = 1;
+
+        while (queue.Count > 0)
+        {
+            var count = queue.Count;
+            for (var i = 0; i < count; i++)
+            {
+                var item = queue.Dequeue();
+                if (string.Equals(item, endWord))
+                    return result;
+
+                for (var j = 0; j < item.Length; j++)
+                {
+                    var pattern = item.Substring(0, j) + "*" + item.Substring(j + 1);
+                    foreach (var neiWord in nei[pattern])
+                    {
+                        if (!visited.Contains(neiWord))
+                        {
+                            queue.Enqueue(neiWord);
+                            visited.Add(neiWord);
+
+                        }
+                    }
+
+                }
+
+            }
+            result += 1;
+        }
+
+        return 0;
+    }
+}

Diff for: csharp/127-Word-Ladder.cs

@@ -0,0 +1,46 @@
+public class Solution
+{
+    //O(N.2^N)
+    public IList<IList<string>> Partition(string s)
+    {
+        var result = new List<IList<string>>();
+        var stack = new List<string>();
+
+        void dfs(int i)
+        {
+            if (i >= s.Length)
+            {
+                result.Add(stack.ToList());
+                return;
+            }
+
+            for (var j = i; j < s.Length; j++)
+            {
+                if (IsPalindrome(s, i, j))
+                {
+                    stack.Add(s.Substring(i, j - i + 1));
+                    dfs(j + 1);
+                    stack.RemoveAt(stack.Count - 1);
+                }
+            }
+
+        }
+
+        dfs(0);
+
+        return result;
+    }
+
+    public bool IsPalindrome(string s, int l, int r)
+    {
+        while (l < r)
+        {
+            if (s[l] != s[r])
+                return false;
+            l++;
+            r--;
+        }
+
+        return true;
+    }
+}