Maximum number of given operations to remove the entire string

// Java implementation of the approach
import java.io.*;
import java.util.*;

class GFG {
    // Use modified KMP to find valid deletion
    public static List<Integer> KMP(StringBuilder s)
    {
        int n = s.length();
        Integer[] temp = new Integer[n];
        Arrays.fill(temp, 0);
        List<Integer> pi = Arrays.asList(temp);

        for (int i = 1; i < n; i++) {
            int j = pi.get(i - 1);

            if (s.charAt(i) == s.charAt(j)) {
                pi.set(i, j + 1);
            }
            else {
                while (j > 0
                       && s.charAt(i) != s.charAt(j)) {
                    j = pi.get(j - 1);
                }

                if (s.charAt(i) == s.charAt(j)) {
                    pi.set(i, j + 1);
                }
                else {
                    pi.set(i, 0);
                }
            }
        }

        // Store all possible length deletion
        // which follow the given condition that
        // Remove a prefix of the string str[0…i]
        // only if it is equal to the sub-string
        // str[(i + 1)…(2 * i + 1)].
        List<Integer> res = new ArrayList<Integer>();

        for (int i = 0; i < n; i++) {
            if (i + 1 - pi.get(i) == pi.get(i)) {
                res.add(pi.get(i));
            }
        }

        return res;
    }

    // Function to find all maximum possible deletion
    public static int solve(int i, int n, int[] dp,
                            List<List<Integer> > arr)
    {
        if (i >= n)
            return 0;
        if (arr.get(i).size() == 0)
            return 1;

        if (dp[i] != -1)
            return dp[i];

        int res = 0;

        // Iterate over each index and go for ever possible
        // length of deletion at index i
        for (int jump : arr.get(i)) {
            res = Math.max(res,
                           1 + solve(i + jump, n, dp, arr));
        }

        // Store the maximum possible deletion
        // at index i into res and return the res.
        return dp[i] = res;
    }

    public static int deleteString(StringBuilder s,
                                   List<List<Integer> > arr)
    {
        int n = s.length();

        int[] dp = new int[n + 1];

        // For memoization
        Arrays.fill(dp, -1);

        // Iterate over all the index and find
        // What are the possible deletion that can be
        // Perform starting from index i
        for (int i = 0; i < n; i++) {
            StringBuilder sub
                = new StringBuilder(s.substring(i));
            arr.add(KMP(sub));
        }

        // Function call for finding the maximum deletion
        // operation required
        return solve(0, n, dp, arr);
    }

    public static void main(String[] args)
    {
        StringBuilder s = new StringBuilder("abababab");

        // For storing all possible length deletion at index
        // i
        List<List<Integer> > arr
            = new ArrayList<List<Integer> >();

        // Function call
        System.out.println(deleteString(s, arr));
    }
}