1218. Longest Arithmetic Subsequence of Given Difference

class Solution {
    public int longestSubsequence(int[] arr, int difference) 
    {

//        int n = arr.length;

        int result = 1;
        int[] dp=new int[40001];
        
        for(int i:arr)
        {
            dp[i+20000]=dp[i - difference + 20000] + 1;
            result = Math.max(result, dp[i + 20000]);
        }
        return result;


        /*
        int result = 0;
        HashMap<Integer, Integer> map = new HashMap<>();

        for(int i=0; i<n; i++)
        {
            result = Math.max(result, map.getOrDefault(arr[i] - difference,  0) + 1);

            map.put(arr[i], map.getOrDefault(arr[i] - difference,  0) + 1);
        }
        return result;

        */


        /*
        int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;

        for(int num : arr)
        {
            if(num < min)
            {
                min = num;

            }

            if(num > max)
            {
                max = num;

            }
        }

        int result = 0, expect, seqcount;
        int length = max-min + 1;
        int[] count = new int[length];


        for(int i : arr)
        {
            seqcount = count[i-min] + 1;

            if(seqcount > result)
            {
                result = seqcount;

            }

            expect = i + difference - min;

            if(expect >-1 && expect < length)
            {
                count[expect] = seqcount;

            }
        }

        return result;

        */


        /*
        int result = 1;
        HashMap<Integer, Integer> dp = new HashMap<>();

        for(int i : arr)
        {
            int prev = dp.getOrDefault(i-difference, 0);
            dp.put(i, prev+1);
            result = Math.max(result, dp.get(i));

        }

        return result;

        */

        
    }
}