我写了一个密码 Reversing a subarray to maximize sum of even-indexed elements of given array ```
public static int max_reverse_sub(int a[]){

    int a_len = a.length;
    int b[][] = new int[a_len][a_len];
    int custom_sum = 0;
    for(int k = 0 ; k < a.length ; k = k + 2){

        custom_sum  = custom_sum + a[k];

    }
    int i = 0;
    int j = 0;
    int i_keep = 0;
    int j_keep = 0;
    int max = Integer.MIN_VALUE;
    for(i = 0 ; i < a_len ; i++){

        for(j = i ; j < a_len ; j++){

        if(b[i][j] == 0){

        if(i == j){
            b[i][j] = custom_sum;
        }
        else{

            if((j - i) % 2 == 0){
                b[i][j] = Math.max(b[i][j - 1], b[i + 1][j]);

            }
            else{
                int m1= Math.max(b[i][j - 1], b[i + 1][j]);
                b[i][j] = Math.max(m1 , first_to_end(a, i, j, custom_sum));

            }
        }
    }
            if(b[i][j] > max)
                max = b[i][j];

        }

    }
    return max;

}

数组 `b[][]` 是我的 `dp` .  `b[i][j]` is元素 `i` 至 `j` 选择倒车。它工作，但不是在最佳时间。我还写了一个 `max_reverse_sub` 名为的方法 `first_to_end` 如下所示。

public static int first_to_end(int a[] , int i , int j , int sum){

    int keep = sum;
    for(int k = i ; k <= j ; k++){

        if(k % 2 == 0){

            keep = keep - a[k];
        }
        else{

            keep = keep + a[k];
        }

    }
    if(keep > sum)
        return keep;
    return sum;

}

它计算新的 `i` 至 `j` 元素if `j - i` 是 `odd` 因为我们得到了一个新的总和，当它反向。我认为我的问题是使用这种方法，因为它在 `o(n)` 当我在我的方法中使用它时 `o(n^3)` .
下面是一个更好的例子：

Input: arr[] = {1, 2, 1, 2, 1}
Output: 5
Explanation:
Sum of intial even-indexed elements = a[0] + a[2] + a[4] = 1 + 1 + 1 = 3
Reversing subarray {1, 2, 1, 2} modifies the array to {2, 1, 2, 1, 1}.
Hence, the maximized sum = 2 + 2 + 1 = 5

你能找到解决问题的办法吗 `Dp` 在o（n^2）或更好的时间找到它？如果你有什么问题可以问我。