july

Author: 15-Ab

July/Daily 11-07-23.md

@@ -0,0 +1,82 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Keep a record of distance of target node from itself to root node, then traverse distances.
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+
+Create a hashmap to store the distances of nodes in the path of target node to root node.
+
+Then traverse from root node to check if asked distance(k) is equal to distance between target and that node. If not, then check node.left as well as node.right , after calling the same traverse function with incrementing distance by 1 . ( as by intuition we will be going away from target.) 
+( But if we move closer to target node then don't worry , I have included the if statement to check is traversed node is in hashmap, if yes then update distance to the value of distance of that node in hashmap.)
+
+# Complexity
+- Time complexity: $$O(n)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity: $$O(n)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {
+        List<Integer> li = new ArrayList<>();
+        HashMap< TreeNode, Integer> dist = new HashMap<>();
+
+        getDists( root, target, dist);
+        traverse( root, k, 0, dist, li);
+
+        return li;
+        
+    }
+
+    static void getDists( TreeNode root, TreeNode target, HashMap< TreeNode, Integer> dist){
+
+        if( root == null){
+            return;
+        }
+        if( root == target){
+            dist.put(root, 0);
+            return;
+        }
+
+        getDists(root.left, target, dist);
+        if( dist.containsKey(root.left)){
+            dist.put(root, dist.get(root.left) + 1);
+            return;
+        }
+
+        getDists(root.right, target, dist);
+        if( dist.containsKey(root.right)){
+            dist.put(root, dist.get(root.right) + 1);
+            return;
+        }
+
+    }
+
+    static void traverse( TreeNode root, int k, int distance, HashMap< TreeNode, Integer> dist, List<Integer> li){
+        if( root == null){
+            return;
+        }
+        if( dist.containsKey(root)){
+            distance = dist.get(root);
+        }
+        if( distance == k){
+            li.add(root.val);
+        }
+
+        traverse(root.left, k, distance + 1, dist, li);
+        traverse(root.right, k, distance + 1, dist, li);
+    }
+}
+```

July/Daily 12-07-23.md

@@ -0,0 +1,61 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Visualise a little, it is just those nodes of the graph which aren't part of any cycle.
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+For every node check if it is part of any cycle or not ( used a separate function for that ).
+
+Used enum for storing the states of nodes, it was usefull in checking the presence of cycles.
+
+Add all the nodes to answer list which aren't part of any cycles.
+
+# Complexity
+- Time complexity  : $$O( |V| + |E| )$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity :  $$O( |V| + |E| )$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    enum States {        // These are special class that are used for storing cases // Ex: How are you : Good - Bad - Average ... it is just for example
+    //Initial,
+    Visiting, 
+    Visited
+}
+    public List<Integer> eventualSafeNodes(int[][] graph) {
+        List<Integer> li = new ArrayList<>();
+        States[] state = new States[graph.length];
+
+        for( int i = 0; i < graph.length; i++){     // for every node check if it is part of any cycle or not 
+            if( !formsCycle( graph, i, state)){
+                li.add(i);
+            }
+        }
+        return li;
+        
+    }
+
+    public boolean formsCycle( int[][] g, int n, States[] state){
+
+        if( state[n] == States.Visiting){         // if we recursively reach the node which was in our path then we have found a cycle , so return true
+            return true;
+        }
+        if( state[n] == States.Visited){          // it means we reached a terminal node , so return false
+            return false;
+        }
+
+        state[n] = States.Visiting;       // initialise state[0] to be as a visiting state
+        for( int e : g[n]){               // for every outgoing edge of present node , check if the forms a cycle or not
+            if( formsCycle( g, e, state)){
+                return true;
+            }
+        }
+        state[n] = States.Visited;      // this code will execute if we reach terminal node
+
+        return false;
+    }
+}
+```

July/Daily 13-07-23.md

@@ -0,0 +1,74 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Intuition was pretty similar to 'Find Eventual Safe States(802)(Yesterday's daily challenge)'. 
+
+Simply they don't have to form cycles.
+
+Anyway it required a visualisation that courses that was prerequisite of other course(s) must have to be completed before, and in order to do that they must be not required to complete those courses whom they are prerequisite of. 
+
+
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+Used List to store courses and their prerequisite(s).
+
+For every course check if it is part of any loop or not ( used a separate function for that ).
+
+Used enum for storing the status of course, it was usefull in checking the presence of loops.
+
+[ If something is not understandable, then please let me know in comments, I will explain that further. ]    :)
+
+# Complexity 
+ 
+- Time complexity : $$O( ∣N∣ + ∣P∣ )$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity : $$O( ∣N∣ + ∣P∣ )$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+where , N = numCourses : P = prerequisites.length ( rows )
+# Code
+```
+enum Course{
+    Completing,
+    Completed
+}
+
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        Course[] courses = new Course[numCourses];
+        List<Integer>[] li = new List[numCourses];
+        for( int i = 0; i < numCourses; i++){
+            li[i] = new ArrayList<>();
+        }
+        for( int[] pre : prerequisites){
+            li[ pre[0]].add( pre[1]);
+        }
+        for( int i = 0; i < numCourses; i++){
+            if( checkLoop( i, li, courses)){
+                return false;
+            }
+        }
+        return true;
+    }
+
+    boolean checkLoop( int a, List<Integer>[] li, Course[] c){
+
+        if( c[a] == Course.Completing){
+            return true;
+        }
+        if( c[a] == Course.Completed){
+            return false;
+        }
+
+        c[a] = Course.Completing;
+        for( int p : li[a]){
+            if( checkLoop( p, li, c)){
+                return true;
+            }
+        }
+        c[a] = Course.Completed;
+        return false;
+     }
+}
+```

July/Daily 14-07-23.md

@@ -0,0 +1,83 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+A simple use of hashmap.
+
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+Create a hashmap which will store numbers with their respective series possible till now, and for each numbers check if their previous elements were present in array or not, if yes then increse their count, otherwise let it be 1.
+
+Let me explain by a example :  a = [1,5,7,8,5,3,4,2,1], difference = -2
+Let max store the maximum length and initially its value is 0.
+
+Star with first element : 1
+As ( 1 - (-2 ) ) isn't present in hashmap ( since it is the first element in our hashmap), so its length ( 0 + 1) = 1 
+Included in hashmap : (1, 1)
+As 1 > max : max = 1
+
+Second element : 5
+As ( 5 - (-2) ) isn't present in hashmap, so its length = ( 0 + 1) = 1 
+Included in hashmap : (5, 1)
+As 1 isn't greater than max, so no change in max
+
+Third element : 7
+As ( 7 - (-2) ) isn't present in hashmap, so its length = ( 0 + 1) = 1 
+Included in hashmap : (7, 1)
+As 1 isn't greater than max, so no change in max
+
+Fourth element : 8
+As ( 8 - (-2) ) isn't present in hashmap, so its length = ( 0 + 1) = 1 
+Included in hashmap : (8, 1)
+As 1 isn't greater than max, so no change in max
+
+Fifth element : 5
+As ( 5 - (-2) ) = (7) is present in hashmap, so its length = ( length(7) + 1) = ( 1 + 1) = 2
+Included in hashmap : (5, 2)
+As 2 > max : max = 2
+
+Sixth element : 3
+As ( 3 - (-2) ) = (5) is present in hashmap, so its length = ( length(5) + 1 ) = ( 2 + 1) = 3
+Included in hashmap : (3, 3)
+As 3 > max : max = 3
+
+Seventh element : 4
+As ( 4 - (-2) ) isn't present in hashmap, so its length = ( 0 + 1) = 1 
+Included in hashmap : (4, 1)
+As 1 isn't greater than max, so no change in max
+
+Eigth element : 2
+As ( 2 - (-2) ) = (4) is present in hashmap, so its length = ( length(4) + 1 ) = ( 1 + 1) = 2
+Included in hashmap : (2, 2)
+As 2 isn't greater than max, so no change in max
+
+Ninth element : 1
+As (1 - (-2) ) = (3) is present in hashmap, so its length = ( length(3) + 1 ) = ( 3 + 1) = 4
+Included in hashmap : (1, 4)
+As 4 > max : max = 4
+
+After iterating over all numbers, answer is received as max.
+
+
+# Complexity
+- Time complexity:
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity:
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    public int longestSubsequence(int[] arr, int difference) {
+
+        int max = 0;
+        HashMap<Integer, Integer> m = new HashMap<>();
+        for( int i : arr){
+            m.put(i, m.getOrDefault( i - difference, 0) + 1); // if the previous possible element of the sequence is present already in hashmap then add thats length to the current element length + 1, otherwise 1
+            max = Math.max( max, m.get(i)); // updating max value if length is greater than max
+        }
+        return max;
+        
+    }
+}
+```

July/Daily 15-07-23.md

@@ -0,0 +1,60 @@
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+Have to check each rows, seemed complex but breaked it down.
+
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+Sort events on the basis of their end date.
+
+Create a matrix which will store maximum values that can be achieved till now.
+
+Now iterate over each sorted events :
+
+if an event is found that started before ( previous variable in code ) the current iterating event then check that if its value can be added to current
+else add the value of that event or previous row value in matrix, whichever  is greater.
+
+The last element of our created matrix will contain the answer.
+
+Look at the code and still if you have any confusion then please let me know in comments. :)
+
+# Complexity
+- Time complexity : $$O(n*(logn)*k)$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity: $$O(nk)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+
+# Code
+```
+class Solution {
+    public int maxValue(int[][] events, int k) {
+
+        Arrays.sort( events, ( int[] e1, int[] e2) -> e1[1] - e2[1]);        //sorting events on the basis of their end date
+        int len = events.length;
+        int[][] m = new int[len+1][ k+1]; // create a matrix which will store maximum values that can be achieved till now 
+        for( int i = 0; i < len; i++){
+            int startday = events[i][0], value = events[i][2];
+            int previous = findprevious( events, i, startday);               // previous will store any event that start date is before the current event
+            for( int j = 1; j <= k; j++){
+                m[ i+1][j] = Math.max( value + m[previous][j-1], m[i][j]);   // if a event has started and ended before current event then add that value to the value of current event ; return which is bigger this updated value or the value at previous event
+            }
+        }
+        return m[len][k];
+    }
+
+    public int findprevious( int[][] events, int beforethis, int startday){   // binary search to find previous event
+        int l = 0, b = beforethis;
+        while( l < b){
+            int m = ( l + b)/2;
+            if( events[m][1] >= startday){
+                b = m;
+            }
+            else{
+                l = m + 1;
+            }
+        }
+        return l;
+    }
+}
+```