Commit #120 - Modified 6 file(s) - 12.06.2023 @16:41

Author: JRS296

Daily Questions/SnapShot Array.java

@@ -0,0 +1,68 @@
+//Attempt #1 - 5mins
+//Link: https://leetcode.com/problems/snapshot-array/description/
+
+class SnapshotArray {
+    int arr[];
+    HashMap<Integer,int[]> snapMap = new HashMap<Integer,int[]>();
+    int ID = 0;
+
+    public SnapshotArray(int length) {
+        arr = new int[length];
+    }
+    
+    public void set(int index, int val) {
+        arr[index] = val;
+    }
+    
+    public int snap() {
+        int arrCopy[] = arr.clone();
+        snapMap.put(ID++, arrCopy);
+        return ID-1;
+    }
+    
+    public int get(int index, int snap_id) {
+        int arr[] = snapMap.get(snap_id);
+        return arr[index];
+    }
+}
+
+/*
+MLE - 69/74
+ */
+
+//Optimal Soln - using treemap
+
+class SnapshotArray {
+    TreeMap<Integer, Integer>[] Tm;
+    int snap_id = 0;
+    public SnapshotArray(int length) {
+        Tm = new TreeMap[length];
+        for (int i = 0; i < length; i++) {
+            Tm[i] = new TreeMap<Integer, Integer>();
+            Tm[i].put(0, 0);
+        }
+    }
+
+    public void set(int index, int val) {
+        Tm[index].put(snap_id, val);
+    }
+
+    public int snap() {
+        return snap_id++;
+    }
+
+    public int get(int index, int snap_id) {
+        return Tm[index].floorEntry(snap_id).getValue();
+    }
+}
+
+/*
+Runtime
+67 ms
+Beats
+54.5%
+Memory
+77.6 MB
+Beats
+57.61%
+ */

Daily Questions/Summary Ranges.java

@@ -0,0 +1,33 @@
+//Attempt #1 - 20mins
+//Link: https://leetcode.com/problems/summary-ranges/description/
+
+class Solution {
+    public List<String> summaryRanges(int[] nums) {
+       ArrayList<String> al=new ArrayList<>();
+        
+        for(int i=0;i<nums.length;i++){
+            int start=nums[i];
+            while(i+1<nums.length && nums[i]+1==nums[i+1])
+                i++;
+            
+            if(start!=nums[i]){
+                al.add(Integer.toString(start)+"->"+Integer.toString(nums[i]));
+            }
+            else{
+                al.add(Integer.toString(start));
+            }
+        }
+        return al;
+    }
+}
+
+/*
+Runtime
+6 ms
+Beats
+33.52%
+Memory
+40.9 MB
+Beats
+73.61%
+ */

Things to Do.txt

@@ -1,10 +1,6 @@
 Things to Do:
 
 1) Find Optimal way to create subarrays 
-2) Finish Txt file for Collections + Study
-3) Finish Txt File for Arrays
-4) Suffix Trees, Quick Select Sort, KMP Algo 
-5) Quick Sort, Merge Sort and Binary Search - Thoroughly
 6) implement Linked List
 7) Prepare Notes for Linked Lists
 8) Copy List with Random Pointer

Trees (Binary Trees)/G L R VVV - Balanced Binary Tree.java

@@ -0,0 +1,24 @@
+class Solution {
+     public boolean isBalanced(TreeNode root) {
+         return getHeight(root) != -1;
+     }
+
+     private int getHeight(TreeNode root) {
+         if (root == null) {
+             return 0;
+         }
+         int leftHeight = getHeight(root. left);
+         if (leftHeight == -1) {
+             return -1;
+         }
+         int rightHeight = getHeight(root.right);
+         if (rightHeight == -1) {
+             return -1;
+         }
+         // The height difference between the left and right subtrees is greater than 1, and return -1 means that it is no longer a balanced tree
+         if (Math. abs(leftHeight - rightHeight) > 1) {
+             return -1;
+         }
+         return Math.max(leftHeight, rightHeight) + 1;
+     }
+}

Trees (Binary Trees)/G L R VVV - Diameter of a Tree.java

@@ -0,0 +1,32 @@
+class Solution {
+    public int diameterOfBinaryTree(TreeNode root) {
+
+        // Create an array to hold the diameter of the tree
+        int diameter[] = new int[1];
+
+        // Recursively calculate the height of the tree and update the diameter array
+        height(root,diameter);
+        //System.out.println(Arrays.toString(diameter));
+
+        // Return the diameter of the tree
+      return diameter[0];
+    }
+
+    public int height(TreeNode root, int diameter[]){
+        
+        // Base case: if the root is null, the height is 0
+        if(root == null){
+            return 0;
+        }
+
+        // Recursively calculate the height of the left and right subtrees
+        int left = height(root.left,diameter);
+        int right = height(root.right,diameter);
+
+        // Update the diameter array by taking the maximum diameter that passes through the current node
+        diameter[0] = Math.max(diameter[0],left + right);
+
+        // Return the maximum depth of the current node by adding 1 to the maximum depth of its deepest subtree
+        return Math.max(left,right)+1;
+    }
+}

Trees (Binary Trees)/G L R VVV - Subtree of Another Tree.java

@@ -0,0 +1,16 @@
+public class Solution {
+    public boolean isSubtree(TreeNode s, TreeNode t) {
+        if (s == null) return false;
+        if (isSame(s, t)) return true;
+        return isSubtree(s.left, t) || isSubtree(s.right, t);
+    }
+    
+    private boolean isSame(TreeNode s, TreeNode t) {
+        if (s == null && t == null) return true;
+        if (s == null || t == null) return false;
+        
+        if (s.val != t.val) return false;
+        
+        return isSame(s.left, t.left) && isSame(s.right, t.right);
+    }
+}