Create Q-08: Longest Arithmetic Subsequence.java

Author: py3-coder

DP LIS Pattern/Q-08: Longest Arithmetic Subsequence.java

@@ -0,0 +1,114 @@
+/*
+1027. Longest Arithmetic Subsequence
+
+Given an array nums of integers, return the length of the longest arithmetic subsequence in nums.
+Note that:
+A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.
+A sequence seq is arithmetic if seq[i + 1] - seq[i] are all the same value (for 0 <= i < seq.length - 1).
+
+Example 1:
+Input: nums = [3,6,9,12]
+Output: 4
+Explanation:  The whole array is an arithmetic sequence with steps of length = 3.
+
+Example 2:
+Input: nums = [9,4,7,2,10]
+Output: 3
+Explanation:  The longest arithmetic subsequence is [4,7,10].
+
+Example 3:
+Input: nums = [20,1,15,3,10,5,8]
+Output: 4
+Explanation:  The longest arithmetic subsequence is [20,15,10,5].
+ 
+
+Constraints:
+
+2 <= nums.length <= 1000
+0 <= nums[i] <= 500
+*/
+class Solution {
+    static HashMap<String,Integer> map;
+    public int longestArithSeqLength(int[] nums) {
+        // Recursion::1.
+        //return solveRec(nums,0,501,-1,0);
+
+        // Recursion Modiied::2
+        // return solve(Integer.MIN_VALUE,Integer.MIN_VALUE,nums,0);
+
+        // map =new HashMap<>();
+        // return solveMemo(Integer.MIN_VALUE,Integer.MIN_VALUE,nums,0);
+        return solveTab(nums);
+        
+    }
+    public static int solveRec(int[] nums,int indx,int diff,int prev,int len){
+        //base case:::
+        if(indx>=nums.length) return 0;
+        if(diff==501){
+            int pick=0;
+            if(len<1){
+                pick =1+solveRec(nums,indx+1,diff,indx,len+1);
+            }else {
+                pick =1+solveRec(nums,indx+1,nums[indx]-nums[prev],indx,len+1);
+            }
+            int notpick =solveRec(nums,indx+1,diff,prev,len);
+            return Math.max(pick,notpick);
+        }else{
+            int pick=0;
+            if(nums[indx]-nums[prev]==diff){
+                pick =1+solveRec(nums,indx+1,diff,indx,len+1);
+            }
+            int notpick =solveRec(nums,indx+1,diff,prev,len);
+            return Math.max(pick,notpick);
+        }
+    }
+    public static int solve(int prev,int diff,int[] nums,int indx){
+        if(indx==nums.length) return 0;
+        int pick=0;
+        int notpick=0;
+
+        if(prev==Integer.MIN_VALUE){
+            pick =1+solve(nums[indx],diff,nums,indx+1);
+        }else if(diff==Integer.MIN_VALUE || diff == nums[indx]-prev){
+            pick=1+solve(nums[indx],nums[indx]-prev,nums,indx+1);
+        }
+        notpick =solve(prev,diff,nums,indx+1);
+        return Math.max(pick,notpick);
+    }
+    public static int solveMemo(int prev,int diff,int[] nums,int indx){
+        if(indx==nums.length) return 0;
+
+        String key =indx+"-"+prev+"-"+diff;
+        if(map.containsKey(key)){
+            return map.get(key);
+        }
+        int pick=0;
+        int notpick=0;
+
+        if(prev==Integer.MIN_VALUE){
+            pick =1+solveMemo(nums[indx],diff,nums,indx+1);
+        }else if(diff==Integer.MIN_VALUE || diff == nums[indx]-prev){
+            pick=1+solveMemo(nums[indx],nums[indx]-prev,nums,indx+1);
+        }
+        notpick =solveMemo(prev,diff,nums,indx+1);
+        map.put(key,Math.max(pick,notpick));
+        return Math.max(pick,notpick);
+    }
+    public static int solveTab(int[] nums){
+        int n=nums.length;
+        
+        if(n<=2) return n;
+        Map<Integer, Integer>[] dp = new HashMap[n];
+        int longest=2;
+        for(int i=0;i<n;i++){
+            dp[i] =new HashMap<>();
+            for(int j=0;j<i;j++){
+                int diff =nums[i]-nums[j];
+                dp[i].put(diff,dp[j].getOrDefault(diff,1)+1);
+                longest =Math.max(longest,dp[i].get(diff));
+            }
+        }
+        return longest;
+    }
+
+}