Merge pull request #1958 from kiryl-labada/main

Update C# solutions

Author: tahsintunan

csharp/0110-balanced-binary-tree.cs

@@ -11,30 +11,24 @@
  *     }
  * }
  */
-public class Solution
-{
+public class Solution {
+    private bool _result = true;
 
-    //T: O(N) and S: O(H)
-    public bool IsBalanced(TreeNode root)
-    {
-        return checkHeight(root) != int.MinValue;
+    public bool IsBalanced(TreeNode root) {
+        Dfs(root);
+        return _result;
     }
 
-    private int checkHeight(TreeNode root)
-    {
-        if (root == null)
+    private int Dfs(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 leftDepth = Dfs(root.left);
+        var rightDepth = Dfs(root.right);
 
-        var heightDiff = leftHeight - rightHeight;
-        if (Math.Abs(heightDiff) > 1)
-            return int.MinValue;
-        else
-            return Math.Max(leftHeight, rightHeight) + 1;
+        _result = _result && (Math.Abs(rightDepth - leftDepth) <= 1);
 
+        return Math.Max(leftDepth, rightDepth) + 1;
     }
-}
+}

csharp/0146-lru-cache.cs

@@ -1,92 +1,39 @@
-public class Node
-{
-    public int val;
-    public int key;
-    public Node prev;
-    public Node next;
+public class LRUCache {
+    private Dictionary<int, LinkedListNode<(int key, int value)>> _dict = new();
+    private LinkedList<(int key, int value)> _values = new();
 
-    public Node(int key, int val)
-    {
-        this.key = key;
-        this.val = val;
-        prev = null;
-        next = null;
-    }
-}
+    private int _capacity; 
 
-public class LRUCache
-{
-    private Dictionary<int, Node> keyValue = new();
-    private int _capacity;
-    private Node left;
-    private Node right;
-
-    //T: O(1), S: O(Capacity)
-    public LRUCache(int capacity)
-    {
+    public LRUCache(int capacity) {
         _capacity = capacity;
-        left = new Node(0, 0);
-        right = new Node(0, 0);
-        // left : LRU, right : MRU (Most recently used)
-        left.next = right;
-        right.prev = left;
     }
+    
+    public int Get(int key) {
+        if (!_dict.ContainsKey(key)) {
+            return -1;
+        }
 
-    //Remove from list
-    private void remove(Node node)
-    {
-        var prev = node.prev;
-        var next = node.next;
-
-        prev.next = next;
-        next.prev = prev;
-    }
-
-    // Insert at right
-    private void insert(Node node)
-    {
-        var next = right;
-        var prev = right.prev;
-
-        node.next = next;
-        next.prev = node;
-        prev.next = node;
-        node.prev = prev;
+        var node = _dict[key];
+        _values.Remove(node);
+        _values.AddFirst(node);
 
+        return node.Value.value;
     }
-
-    public int Get(int key)
-    {
-        if (!keyValue.ContainsKey(key))
-            return -1;
-        // we need to update this to be MRU
-        var node = keyValue[key];
-        remove(node);
-        insert(node);
-        return node.val;
-    }
-
-    public void Put(int key, int value)
-    {
-        if (keyValue.ContainsKey(key))
-        {
-            var node = keyValue[key];
-            keyValue.Remove(key);
-            remove(node);
+    
+    public void Put(int key, int value) {
+        if (!_dict.ContainsKey(key) && _dict.Count >= _capacity) {
+            var node = _values.Last;
+            _dict.Remove(node.Value.key);
+            _values.Remove(node);
         }
 
-        var newNode = new Node(key, value);
-        keyValue.Add(key, newNode);
-        insert(newNode);
-
-        if (keyValue.Count > _capacity)
-        {
-            // remove  from the list and delete the LRU from dictionary
-            var lru = left.next;
-            remove(lru);
-            keyValue.Remove(lru.key);
+        var existingNode = _dict.GetValueOrDefault(key);
+        if (existingNode != null) {
+            _values.Remove(existingNode);
         }
 
+        _values.AddFirst((key, value));
+        _dict[key] = _values.First;
     }
 }
 
@@ -95,4 +42,4 @@ public void Put(int key, int value)
  * LRUCache obj = new LRUCache(capacity);
  * int param_1 = obj.Get(key);
  * obj.Put(key,value);
- */
+ */

csharp/0199-binary-tree-right-side-view.cs

@@ -12,34 +12,19 @@
  * }
  */
 public class Solution {
+    private List<int> _result = new();
+
     public IList<int> RightSideView(TreeNode root) {
-        var result = new List<int>();
-        if(root == null) 
-            return result;
-        var q = new Queue<TreeNode>();
-        q.Enqueue(root);
-        
-        // traverse the tree using BFS
-        while(true) {
-            var count = q.Count;
-            if(count == 0) break;
-            
-            for(var i = 0; i < count; i++) {
-                var cur = q. Dequeue();
-                
-                if(cur.left != null)
-                    q.Enqueue(cur.left);
-                if(cur.right != null) 
-                    q.Enqueue(cur.right);
-                
-                
-                // only add the last node from each level, i.e the rightmost node
-                if(i == count - 1) {
-                    result.Add(cur.val);
-                }
-            }
-        }
-        
-        return result;
+        Dfs(root, 0);
+        return _result;
     }
-}
+
+    private void Dfs(TreeNode root, int level) {
+        if (root == null) return;
+        if (level >= _result.Count) _result.Add(root.val);
+
+        // At first visit right node
+        Dfs(root.right, level + 1);
+        Dfs(root.left, level + 1);
+    }
+}

csharp/0572-subtree-of-another-tree.cs

@@ -1,6 +1,6 @@
 /**
  * Definition for a binary tree node.
- * public class TreeNode  {
+ * public class TreeNode {
  *     public int val;
  *     public TreeNode left;
  *     public TreeNode right;
@@ -12,34 +12,18 @@
  * }
  */
 public class Solution {
-    public bool IsSameTree(TreeNode one, TreeNode another)     {
-        if (one == null || another == null)
-            return one == another;
-        
-        return
-            one.val == another.val &&
-            IsSameTree(one.left, another.left) &&
-            IsSameTree(one.right, another.right);
-    }
     public bool IsSubtree(TreeNode root, TreeNode subRoot) {
-        if (subRoot == null) return true;
-        if (root == null) return false;
-
-        var nodeToVisit = new Queue<TreeNode>();
+        if (root == null) return root == subRoot;
+        if (root.val == subRoot?.val && IsSameTree(root, subRoot)) return true;
 
-        nodeToVisit.Enqueue(root);
-
-        while (nodeToVisit.Count > 0) {
-            var cur = nodeToVisit.Dequeue();
-            var isSame = IsSameTree(cur, subRoot);
-            if (isSame) return true;
+        return IsSubtree(root.left, subRoot) || IsSubtree(root.right, subRoot);
+    }
 
-            if (cur.left != null)
-                nodeToVisit.Enqueue(cur.left);
-            if (cur.right != null)
-                nodeToVisit.Enqueue(cur.right);
-        }
+    public bool IsSameTree(TreeNode p, TreeNode q) {
+        if (p == null || q == null) return p == q;
 
-        return false;
+        return p.val == q.val 
+            && IsSameTree(p.left, q.left) 
+            && IsSameTree(p.right, q.right);
     }
-}
+}

csharp/0973-k-closest-points-to-origin.cs

@@ -1,44 +1,21 @@
 public class Solution {
-    // Closest to origin minHeap
-    private PriorityQueue<int[], double> pq;
-    private int size;
-    // T: O(Max(M, KLogM)), S: O(k)
     public int[][] KClosest(int[][] points, int k) {
-        pq = new PriorityQueue<int[], double>();
-        size = k;
-        
-        AddToPriorityQueue(points);
-        
-        return Closest();
-    }
-    
-    public class MaxHeap : IComparer<double>{
-        public int Compare(double x, double y){
-            if( x< y) return 1;å
-            else if (x > y) return -1;
-            else return 0;
-        }
-    }
-    
-    // T: O(M)
-    private void AddToPriorityQueue(int[][] points){
-        foreach(var point in points){
-            //var value = (double) Math.Sqrt(point[0]*point[0] + point[1]*point[1]);
-            var value = (double) point[0]*point[0] + point[1]*point[1];
-            pq.Enqueue(point, value);
-        
-           
-        }
-    }
-    
-    // T: O(KLogM)
-    private int[][] Closest(){
-        var result = new List<int[]>();
-        while(size > 0){
-            result.Add(pq.Dequeue());
-            size--;
+        var items = points.Select(point => {
+            long x = point[0];
+            long y = point[1];
+
+            return (point, x * x + y * y);
+        });
+
+        int[][] result = new int[k][];
+        // T: O(n)
+        PriorityQueue<int[], long> queue = new(items);
+
+        // T: O(k log(n))
+        for (int i = 0; i < k; i++) {
+            result[i] = queue.Dequeue();
         }
-        
-        return result.ToArray();
+
+        return result;
     }
 }