算法：动态规划

动态规划解决问题的步骤

(1)将原问题分解为子问题

• 把原问题分解为若干个子问题，子问题和原问题形式相同或类似，只不过规模变小了。子问题都解决，原问题即解决(数字三角形例）
• 子问题的解一旦求出就会被保存，所以每个子问题只需求 解一次。

(2)

能用动规解决的问题的特点

1) 问题具有最优子结构性质。如果问题的最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构性质。比如说在背包问题中，最高总价值 = max（选择不放该物品时达到的总价值，决定放该物品时背包剩余容量能达到的最大价值 + 该物品价值），显然，最高总价值的解一定包含“选择不放该物品时达到的总价值“和“决定放该物品时背包剩余容量能达到的最大价值“两个问题其中一个的最优解。


2) 无后效性。当前的若干个状态值一旦确定，则此后过程的演变就只和这若干个状态的值有关，和之前是采取哪种手段或经过哪条路径演变到当前的这若干个状态，没有关系。

问题实例

• 斐波那契数列
  最简单的动态规划算法解决问题，其实就是斐波那契数列。我们将总问题分解为若干子问题，然后得出状态转移方程（就是通过一个子问题的解可以计算另一个子问题的解）。和暴力算法相比，动态规划的优势就在于可以直接使用已经计算过的自问题的解，而不是重新计算一遍。就像斐波那契数列，我们使用已经计算好的前两项来计算当前项。当然，看起来如果问题是计算斐波那契数列中的某一项，两种算法没多大区别。但是，如果问题是计算斐波那契数列的某几项，使用递推的方式就要显著优于对每一项的暴力计算。因为暴力计算中存在重复计算子问题的情况。

• 最长子序列，最长子串，最长回文串
  
  最长回文串问题的求解如下

class Solution {
    public String longestPalindrome(String s) {
        StringBuilder b = new StringBuilder(s);         
        String sr = b.reverse().toString();
        System.out.print(sr);
        int length = s.length();
        int[][] dp = new int[length][length];
        int[][] begin = new int[length][length];
        int[][] beginr = new int[length][length];
        for(int i=0;i<length;i++){
            for(int j=0;j<length;j++){
                if(s.charAt(i) == sr.charAt(j)){
                    if(i==0 || j==0){
                        dp[i][j]=1;
                        begin[i][j] = i;
                        beginr[i][j] = j;
                    }else{
                        dp[i][j] = dp[i-1][j-1] + 1;                        
                        if(dp[i-1][j-1]==0){
                            begin[i][j] = i;
                            beginr[i][j] = j;
                        }else{
                            begin[i][j] = begin[i-1][j-1];
                            beginr[i][j] = beginr[i-1][j-1];
                        }
                    }
                }else{
                    dp[i][j]=0;
                    begin[i][j] = 0;
                    beginr[i][j] = 0;
                }
            }
        }
        while(true){
            int max=0;
            int pos_begin = -1;
            int pos_beginr = -1;
            int max_i= -1;
            int max_j = -1;
            for(int i=0;i<length;i++){
                for(int j=0;j<length;j++){   
                    if(dp[i][j]>max){
                        max = dp[i][j];
                        pos_begin = begin[i][j];
                        pos_beginr = beginr[i][j];
                        max_i = i;
                        max_j = j;
                    }
                }
            }
            if(max==0){
                break;
            }
            if(pos_beginr == (length-pos_begin-max)){
                return  s.substring(pos_begin,pos_begin+max); 
            }else{
                dp[max_i][max_j]=0;
            }
        }
        return "";

    }
}