Maximum score of deleting an element from an Array based on given condition

// Java implementation to find the
// maximum score of the deleting a
// element from an array
import java.util.*;

class GFG{

// Function to find the maximum
// score of the deleting an element
// from an array
static int findMaximumScore(int []a, int n)
{
    
    // Creating a map to keep
    // the frequency of numbers
    @SuppressWarnings("unchecked")
    HashMap<Integer,
            Integer> freq = new HashMap();

    // Loop to iterate over the
    // elements of the array
    for(int i = 0; i < n; i++) 
    {
        if(freq.containsKey(a[i]))
        {
            freq.put(a[i], 
                     freq.get(a[i]) + 1);
        }
        else
        {
            freq.put(a[i], 1);
        }
    }

    // Creating a DP array to keep
    // count of max score at ith element
    // and it will be filled
    // in the bottom Up manner
    int []dp = new int[Arrays.stream(a).max().getAsInt() + 1];
    dp[0] = 0;
    dp[1] = freq.get(1);

    // Loop to choose the elements of the
    // array to delete from the array
    for(int i = 2; i < dp.length; i++)
        dp[i] = Math.max(dp[i - 1],
                         dp[i - 2] + 
                       freq.get(i) * i);

    return dp[dp.length - 1];
}

// Driver Code
public static void main(String[] args)
{
    int n;
    n = 3;
    int []a = { 1, 2, 3 };

    // Function call
    System.out.print(findMaximumScore(a, n));
}
}

// This code is contributed by 29AjayKumar

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {

    // Function to find the maximum score of deleting an
    // element from an array
    static int solve(ArrayList<Integer> arr, int i)
    {
        if (i >= arr.size()) // if i is greater than size of array
        {
            return 0;
        }
        
        // current 'i' on which we are standing
        int currValue = arr.get(i);
        int currSum = arr.get(i);
        int index = i + 1;
        
        // while it is the same as the current value, include in our sum
        while (index < arr.size()
               && arr.get(index) == currValue) {
            currSum += arr.get(i);
            index++;
        }
         
        // Now, we have to skip all the elements, whose value is equal to
        // currValue + 1
        while (index < arr.size()
               && arr.get(index) == currValue + 1) {
            index++;
        }
        
        //And lastly, we have two choices-
        //whether to include the sum of this current element 
        // in our answer
        // or not include the sum of current element in our answer
        // so we explore all possibility and take maximum of them
        return Math.max(currSum + solve(arr, index),
                        solve(arr, i + 1));
    }
    
    // If we decide to take the curr element in our answer, then upto the 
    // elemet we skip the next value, we paas that index
    // but if decided no to make this vurrent element then simply paas
    // i + 1
    static int findMaximumScore(ArrayList<Integer> arr)
    {
        int n = arr.size();
        
        // sort the array to get rid of all arr[i] - 1 elements
        Collections.sort(arr);

        return solve(arr, 0);
    }
    
    // Driver Code
    public static void main(String[] args)
    {
        int n = 3;
        ArrayList<Integer> a
            = new ArrayList<>(Arrays.asList(1, 2, 3));

        // Function Call
        System.out.println(findMaximumScore(a));
    }
}