*Maximum Length Palindromic Sub-Sequence of an Array.

/* Write a function to compute the maximum length palindromic sub-sequence of an array.
A palindrome is a sequence which is equal to its reverse.
A sub-sequence of an array is a sequence which can be constructed by removing elements of the array.
Ex: Given [4,1,2,3,4,5,6,5,4,3,4,4,4,4,4,4,4] should return 10 (all 4's) */
class Interview {
public static int maxLengthPalindrome(int[] values) {
//ur implementation here
}

解法一：

Implemtation is recursive, and it's much worse than O(n^2). Should use recursive with memorization, then can improve to O(n^2).
However, recursive memorization doesn't improve over bottom-up and it has costly overhead. Bottom-up is better in this problem.

public class Solution {
public static void main(String[] args) {
int arr[] = new int[] {4,1,2,3,4,5,6,5,4,3,4,4,4,4,4,4,4};
System.out.println(maxLengthPalindrome(arr, 0, arr.length-1));
}

public static int maxLengthPalindrome(int[] values, int i, int j) {
//check if indexes cross each other
//return 1 if index overlap for else condition below
//return 0 if index i<j for condition if below
if(j<=i) return j-i+1;
if(values[i]==values[j]) return 2 + maxLengthPalindrome(values, i+1, j-1);
else return Math.max(maxLengthPalindrome(values, i+1, j), maxLengthPalindrome(values, i, j-1));
}
}

解法二：

The code with the memoization technique which produces O(n^2) complexity is

public int dpLps(int[] a, int i, int j, Integer[][] lps) {
if (i > j)
return 0;
if (lps[i][j] == null) {
if (i == j)
lps[i][j] = 1;
else {
if (a[i] == a[j])
lps[i][j] = 2 + dpLps(a, i + 1, j - 1, lps);
else
lps[i][j] = Math.max(dpLps(a, i + 1, j, lps),
dpLps(a, i, j - 1, lps));
}
}
return lps[i][j];
}

you have to call the function as,

dpLps(a, 0, a.length - 1,new Integer[a.length][a.length])