[csharp] Missing solutions

Author: ShrujanKotturi

csharp/10-Regular-Expression-Matching.cs

@@ -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);
+    }
+}

csharp/1046-Last-Stone-Weight.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;
+        }
+    }
+}

csharp/105-Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal.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;
+    }
+}

csharp/127-Word-Ladder.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;
+    }
+}

csharp/131-Palindrome-Partitioning.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;
+    }
+}

csharp/1584-Min-Cost-to-Connect-All-Points.cs

@@ -0,0 +1,60 @@
+public class Solution
+{
+    //T: O(N^2 LogN)
+    public int MinCostConnectPoints(int[][] points)
+    {
+        //creating the ajacency list.
+        var N = points.Length;
+        var dictionary = new Dictionary<int, List<Tuple<int, int>>>(); //Cost and Node
+
+        if (N == 1)
+            return 0;
+
+        for (var i = 0; i < N; i++)
+        {
+            dictionary.Add(i, new List<Tuple<int, int>>());
+        }
+
+        for (var i = 0; i < N; i++)
+        {
+            var x1 = points[i][0];
+            var y1 = points[i][1];
+
+            for (var j = i + 1; j < N; j++)
+            {
+                var x2 = points[j][0];
+                var y2 = points[j][1];
+
+                var dist = Math.Abs(x2 - x1) + Math.Abs(y1 - y2);
+
+                dictionary[j].Add(new Tuple<int, int>(dist, i));
+                dictionary[i].Add(new Tuple<int, int>(dist, j));
+
+            }
+        }
+
+        var res = 0;
+        //Prim's
+        var visited = new HashSet<int>();
+        var minHeap = new PriorityQueue<(int, int), int>(); // Cost and Node
+        minHeap.Enqueue((0, 0), 0);
+
+        while (minHeap.Count > 0)
+        {
+            var (cost, point) = minHeap.Dequeue();
+            if (visited.Contains(point))
+                continue;
+            res += cost;
+            visited.Add(point);
+            var adj = dictionary[point];
+
+            for (var i = 0; i < adj.Count; i++)
+            {
+                if (!visited.Contains(adj[i].Item2))
+                    minHeap.Enqueue((adj[i].Item1, adj[i].Item2), adj[i].Item1);
+            }
+        }
+
+        return res;
+    }
+}

csharp/1899-Merge-Triplets-to-Form-Target-Triplet.cs

@@ -0,0 +1,23 @@
+public class Solution
+{
+    //T: O(N)
+    public bool MergeTriplets(int[][] triplets, int[] target)
+    {
+        var hashSet = new HashSet<(int, int)>();
+
+        foreach (var t in triplets)
+        {
+            if (t[0] > target[0] || t[1] > target[1] || t[2] > target[2])
+                continue;
+
+            for (var i = 0; i < t.Length; i++)
+            {
+                if (t[i] == target[i])
+                    hashSet.Add((i, t[i]));
+            }
+        }
+
+        return hashSet.Count == 3;
+    }
+
+}