.

Author: 15-Ab

2024 January/Daily 05-01-24.md

@@ -0,0 +1,63 @@
+## Today's 05-01-24 [Problem Link](https://leetcode.com/problems/longest-increasing-subsequence/description/?envType=daily-question&envId=2024-01-05)
+
+# Intuition
+<!-- Describe your first thoughts on how to solve this problem. -->
+- Dynamic Programming
+- - Algorithm must uses dynamic programming to efficiently update and maintain the longest increasing subsequence.
+- Greedy Choice
+- - The algorithm must makes a greedy choice to update the current longest increasing subsequence (a) based on the incoming elements from the input array (nums).
+
+
+# Approach
+<!-- Describe your approach to solving the problem. -->
+- ArrayList a
+- - I used 'a' to store the current longest increasing subsequence.
+- - It starts as an empty ArrayList.
+- Iterating through nums
+- - My code iterates through each element 's' in the input array nums.
+- - For each element :
+- - - If a is empty or s is greater than the last element in a, add s to a (greedy choice as it contributes to increasing subsequence).
+- - - Otherwise, found the correct position for s in a using the bs function, and update the element at that position with s.
+- Binary Search Function 'bs':
+- - The 'bs' function performs a binary search on the sorted ArrayList 'a' to find the index of 's' or the index where 's' should be inserted.
+- - If 's' is found, it returns the index. If not found, it returns the negation of the insertion point. This insertion point is used to update the current increasing subsequence.
+- Return Result :
+- - Finally, I returned the length of the longest increasing subsequence is the size of the ArrayList a.
+---
+- If you're still having trouble understanding what the binary search functions does here, I would suggest you to please go through this site  [search here for binarySearch](https://docs.oracle.com/javase%2F7%2Fdocs%2Fapi%2F%2F/java/util/Collections.html)
+---
+Have a look at the code , still have any confusion then please let me know in the comments
+Keep Solving.:)
+# Complexity
+- Time complexity : $$O(l*log(l))$$
+<!-- Add your time complexity here, e.g. $$O(n)$$ -->
+
+- Space complexity : $$O(l)$$
+<!-- Add your space complexity here, e.g. $$O(n)$$ -->
+$$l$$ : length of array.
+# Code
+```
+class Solution {
+    public int lengthOfLIS(int[] nums) {
+        
+        ArrayList<Integer> a = new ArrayList<>();
+        for( int s : nums){
+            if( a.isEmpty() || s > a.get( a.size() - 1) ){
+                a.add(s);
+            } 
+            else{
+                a.set( bs(a, s) , s);
+            }
+        }
+        return a.size();
+    }
+
+    static int bs( ArrayList<Integer> a, int s){
+        int in = Collections.binarySearch(a, s);
+        if( in < 0){
+            return - in - 1;
+        }
+        return in;
+    }
+}
+```

README.md

@@ -5,75 +5,66 @@ This is my attempt to make the coding experience easier for you guys so that you
 
 ## Always here to assist you guys.
 
-## Today's 04-01-24 [Problem Link](https://leetcode.com/problems/minimum-number-of-operations-to-make-array-empty/description/)
+## Today's 05-01-24 [Problem Link](https://leetcode.com/problems/longest-increasing-subsequence/description/?envType=daily-question&envId=2024-01-05)
 
 # Intuition
 <!-- Describe your first thoughts on how to solve this problem. -->
-- Frequency Count :
-- - The code starts by creating a HashMap (m) to store the frequency of each number in the given array. This is crucial for determining how many times each number appears in the array.
+- Dynamic Programming
+- - Algorithm must uses dynamic programming to efficiently update and maintain the longest increasing subsequence.
+- Greedy Choice
+- - The algorithm must makes a greedy choice to update the current longest increasing subsequence (a) based on the incoming elements from the input array (nums).
 
-- Divisibility by 3 :
-- - The primary goal is to minimize the operations needed to make all elements 0. The code examines the frequency of each number and calculates the minimum operations required based on certain conditions.
 
 # Approach
 <!-- Describe your approach to solving the problem. -->
-- HashMap for Frequency :
-- - Iterate through the input array (nums).
-Use a HashMap (m) to store the frequency of each number in the array.
-- Calculate Operations :
-- - Iterate through the keys of the HashMap (m).
-- - For each key 'k' observe it's occurence :
-- - - If the occurrence is 1, return -1 (as it's not possible to make it 0 by subtracting 2 or 3).
-- - - if occurence of number is divisible by 3, total operations = occurences/3 
-- - - if occurence of number is of form 3*n + 1, let's try to break it down
-- - - - 3*n + 1 = 3*(n-1) + 4 = 3*(n-1) + 2*(2) -> n-1+2 operations = n+1 
-- - - if occurence of number is of form 3*n + 2, let's try to break it down
-- - - - 3*n + 2 = 3*(n) + 2*(1) -> n+1 operations 
+- ArrayList a
+- - I used 'a' to store the current longest increasing subsequence.
+- - It starts as an empty ArrayList.
+- Iterating through nums
+- - My code iterates through each element 's' in the input array nums.
+- - For each element :
+- - - If a is empty or s is greater than the last element in a, add s to a (greedy choice as it contributes to increasing subsequence).
+- - - Otherwise, found the correct position for s in a using the bs function, and update the element at that position with s.
+- Binary Search Function 'bs':
+- - The 'bs' function performs a binary search on the sorted ArrayList 'a' to find the index of 's' or the index where 's' should be inserted.
+- - If 's' is found, it returns the index. If not found, it returns the negation of the insertion point. This insertion point is used to update the current increasing subsequence.
 - Return Result :
-- - Return the total number of operations needed to make all numbers in the array divisible by 3. 
+- - Finally, I returned the length of the longest increasing subsequence is the size of the ArrayList a.
+---
+- If you're still having trouble understanding what the binary search functions does here, I would suggest you to please go through this site  [search here for binarySearch](https://docs.oracle.com/javase%2F7%2Fdocs%2Fapi%2F%2F/java/util/Collections.html)
 ---
 Have a look at the code , still have any confusion then please let me know in the comments
 Keep Solving.:)
-
 # Complexity
-- Time complexity : $$O(l)$$
+- Time complexity : $$O(l*log(l))$$
 <!-- Add your time complexity here, e.g. $$O(n)$$ -->
 
-- Space complexity : $$O(u)$$
-
-$$l$$ : size of array
-$$u$$ : number of unique letters in array
+- Space complexity : $$O(l)$$
 <!-- Add your space complexity here, e.g. $$O(n)$$ -->
-
+$$l$$ : length of array.
 # Code
 ```
 class Solution {
-    public int minOperations(int[] nums) {
-        boolean haveone = false;
-        HashMap<Integer, Integer> m = new HashMap<>();
-        for( int i = 0; i < nums.length; i++){
-            m.put( nums[i], m.getOrDefault(nums[i], 0) + 1);
-        }
-        int operations = 0;
-
-        // if occurence of number is divisible by 3, total operations = occurences/3 
-        // if occurence of number is of form 3*n + 1, let's try to break it down
-        //  3*n + 1 = 3*(n-1) + 4 = 3*(n-1) + 2*(2) -> n-1+2 operations = n+1 
-        // if occurence of number is of form 3*n + 2, let's try to break it down
-        //  3*n + 2 = 3*(n) + 2*(1) -> n+1 operations 
-  
-        for( int k : m.keySet()){
-            if( m.get(k) == 1){
-                return -1;
-            }
-            if( m.get(k) % 3 == 0){
-                operations += m.get(k)/3;
-            }
+    public int lengthOfLIS(int[] nums) {
+        
+        ArrayList<Integer> a = new ArrayList<>();
+        for( int s : nums){
+            if( a.isEmpty() || s > a.get( a.size() - 1) ){
+                a.add(s);
+            } 
             else{
-                operations += m.get(k)/3 + 1;
+                a.set( bs(a, s) , s);
             }
         }
-        return operations;
+        return a.size();
+    }
+
+    static int bs( ArrayList<Integer> a, int s){
+        int in = Collections.binarySearch(a, s);
+        if( in < 0){
+            return - in - 1;
+        }
+        return in;
     }
 }
 ```