拿走瓶子，动态规划

1884 · 拿走瓶子

有一排有编号的瓶子，现在你需要将这些瓶子全部拿走。
你每次只可以拿走连续的若干个瓶子，并且需要保证瓶子的编号是一个“回文串”。
回文串指的是正着和反着读都一样的串，例如“121”和“4664”。
返回拿走所有瓶子所需要的最少次数。

想多了，你就永远做不出来，我之前一直纠结，如果第i个和第j个数字一样，最少次数有没有可能不是从i+j到j-1的最小次数，而是中间某个相同的数k,从i+1->k 加上k+1->j的最小，最后证明可能是我想多了，下面给出代码：

public class Solution {

    private int[][]  result = new int[500][500];
    /**
     * @param arr: the array of bottles
     * @return: the minimum number of times you can take all the bottles
     */
    public int takeAwayTheBottle(int[] arr) {
        // Write your code here.
        //dp[i][j]表示从i到j的回文数
        return dp(0,arr.length-1,arr);
    }

    public int dp(int i, int j, int[] arr) {
        if(result[i][j] != 0) {
            return result[i][j];
        }
        if(i == j){
            result[i][j] = 1;
            return result[i][j];
        }
        if(arr[i] == arr[j]) {
            if(i == j-1) {
                result[i][j] = 1;
            }else{
                result[i][j] = dp(i+1,j-1,arr);
            }
            return result[i][j];
        }
        if(i == j-1) {
            result[i][j] = 2;
            return result[i][j];
        }
        for(int k=i;k<=j-1;k++){
            if(result[i][k] == 0) {
                result[i][k] = dp(i,k,arr);
            }
            if(result[k+1][j] == 0) {
                result[k+1][j] = dp(k+1,j,arr);
            }
            if(result[i][j] == 0) {
                result[i][j] = 99999;
            }
            result[i][j] = Math.min(result[i][j],result[i][k]+result[k+1][j]);
        }
        return result[i][j];
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] arr = new int[]{1,2,3,5,3,1};
        System.out.println(solution.takeAwayTheBottle(arr));
    }

}