动态规划

1. 算法思想

动态规划和贪婪算法类似，也是将问题的求解过程看成一系列决策的过程。不同的是，贪婪算法中每一次根据贪婪准则做出的决策时一个不可撤回的决策，而动态规划中的每一步决策还要考虑每个最优决策序列中是否包含一个最优子序列，因此动态规划通常用于求解一个问题在某种意义下的最优解。

2. 应用

2.1 最长回文子串

https://leetcode-cn.com/problems/longest-palindromic-substring/

思路分析：

1. 将大问题分解 -->如果一个字符串是回文串，那么它的去掉头尾的子串也会是回文串
2. 构建关系： b[i][j] =b[i+1][j-1]&&(b[i]==b[j]) ---->b[i][j]表示 i 到 j 的子串是否为回文串
3. 边界条件：
   长度为1的子串是回文串
   长度为2的子串 ：两个字符相等为回文串 否则不是

class Solution {
public:
    string longestPalindrome(string s) {
        int n=s.size();
        if(n==1)
            return s;
        vector<vector<bool>> b(n,vector<bool>(n));
        for(int i=0;i<n;i++){
            b[i][i]=true;
        }
        int maxq=0,maxL=1;
        for(int L=2;L<=n;L++){
            for(int i=0;i<n;i++){
                int j=i+L-1;
                if(j<n){
                    if(L==2){
                        if(s[i]==s[j]){
                            b[i][j]=true;
                        }else{
                            b[i][j]=false;
                        }
                    }else{
                        b[i][j]=b[i+1][j-1]&&(s[i]==s[j]);
                    }
                }else{
                    break;
                }
                if(b[i][j]&&L>maxL)
                {
                    maxL=L;
                    maxq=i;
                }
            }
        }
        return s.substr(maxq,maxL);
    }
};

2.2 爬楼梯

https://leetcode-cn.com/problems/climbing-stairs/submissions/

思路分析：

1. 将大问题分解 ----> 爬到第n层有两种方式，从第n-1层、从第n-2层爬上来即第n层的问题变为第n-1和第n-2的问题
2. 递推公式：dp[n]=dp[n-1]+dp[n-2]
3. 边界条件：
   第0层 dp[0]=1; \\为什么楼梯会有第0层
   第1层 dp[1]=1;

class Solution {
public:
    int climbStairs(int n) {
        int *dp=new int[n+1];
        dp[0]=1;
        dp[1]=1;
        for(int i=2;i<=n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
};

2.3 最大子序和

https://leetcode-cn.com/problems/maximum-subarray/submissions/

思路分析：

1. 确定数组元素含义：---->表示以该元素为终点，最大的子序列和
2. 递推公式：dp[i]=max(dp[i-1]+nums[i],nums[i]);
3. 边界条件：dp[0]=nums[0];

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int n=nums.size();
        vector<int> dp(n);
        dp[0]=nums[0];
        int maxsum=dp[0];
        for(int i=1;i<n;i++)
        {
            
            dp[i]=max(dp[i-1]+nums[i],nums[i]);
            if(dp[i]>maxsum)
                maxsum=dp[i];
        }
        return maxsum;
    }
};

2.4 礼物的最大价值

https://leetcode-cn.com/problems/li-wu-de-zui-da-jie-zhi-lcof/

思路分析：每拿到一个礼物，它的最大价值就等于从上面或左面的价值中最大的一个加上自身价值。

1. 数组元素—>到达该格点所拿到的最大价值
2. 递推关系—>dp[i][j]=max(dp[i-1][j],dp[i][j-1])+grid[i][j];
3. 边界条件：
   dp[0][0]=grid[0][0]
   当位于左边界（ j = 0 ）或上边界（i = 0）时，只能从左边（上边）走到，即:
   dp[0][j]=dp[0][j-1]+grid[i][j]; dp[i][0]=dp[i-1][0]+grid[i][j];

class Solution {
public:
    int maxValue(vector<vector<int>>& grid) {
        int price=grid[0][0],row=grid.size(),line=grid[0].size();
        vector<vector<int>> dp(row,vector<int>(line));
        dp[0][0]=grid[0][0];
        for(int j=0;j<line;j++)
        {
            for(int i=0;i<row;i++)
            {
                if(j==0&&i==0){
                    dp[0][0]=grid[0][0];
                }else if(j==0){
                    dp[i][j]=dp[i-1][j]+grid[i][j];
                }else if(i==0){
                    dp[i][j]=dp[i][j-1]+grid[i][j];
                }else{
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1])+grid[i][j];
                }
            }
        }
        return dp[row-1][line-1];
    }
};

2.5 n个骰子的点数

https://leetcode-cn.com/problems/nge-tou-zi-de-dian-shu-lcof/

思路分析：

1. 数组元素含义：dp[i][j]表示总共有 i 个骰子，总点数为 j 的所有可能总数
2. 递推关系: 设第 i 个骰子的点数为 k 所有dp[i-1][j-k]等于dp[i][j]
3. 边界条件：只有一个骰子时，扔出1~6的清空都为1；即dp[1][1~6]=1;

class Solution {
public:
    vector<double> dicesProbability(int n) {
        vector<vector<int>> dp(n+1,vector<int>(6*n+1));
        int sumcount=pow(6,n);
        for(int i=1;i<=6;i++)
            dp[1][i]=1;
        for(int i=2;i<=n;i++)
        {
            for(int j=i;j<=6*i;j++)
            {
                for(int k=1;k<=min(6,j);k++)
                    dp[i][j]+=dp[i-1][j-k];
            }
        }
        vector<double> res;
        for(int i=n;i<=6*n;i++)
            res.push_back(dp[n][i]/(1.0*sumcount));
        return res;
    }
};

3. 总结

3.1 基本步骤

1. 确定数组元素含义
2. 推导递推关系
3. 确定边界条件

3.2

1. 如何确定dp数组是关键
2. 动态规划可能并不是最优解，要根据情况灵活选择
3. 没有3