动态规划

动态规划具备了以下三个特点

1. 把原来的问题分解成了几个相似的子问题。
2. 所有的子问题都只需要解决一次。
3. 储存子问题的解。

动态规划的本质，是对问题状态的定义和状态转移方程的定义(状态以及状态之间的递推关系)

字符串分割

：link
题目描述：
给定一个字符串s和一组单词dict，判断s是否可以用空格分割成一个单词序列，使得单词序列中所有的单词都是dict中的单词（序列可以包含一个或多个单词）。
例如:给定s=“leetcode”；
dict=[“leet”, “code”].
返回true，因为"leetcode"可以被分割成"leet code".
状态：F(i):字符串前i个字符是否可以被分割
状态转移方程：
F(i): j<i&&F(j)&&[j+1,i)是否可以在字典中找到
初始状态：
F(0):true
返回结果：F(s.size())
代码

class Solution {
public:
   
    bool wordBreak(string s, unordered_set<string> &dict) {
        //要想判断这个字符串能不能被分隔，就得先判断它前面的是否可以分割，在前面可以分割的基础上再试着判断后面的
      
        vector<bool> arr(s.size()+1,0);//用来存放第几位是可以分割的
        arr[0]=true;
         
        for(int i=1;i<=s.size();i++)
        {
            for(int j=i-1;j>=0;--j)
            {
                if(arr[j]&&dict.find(s.substr(j,i-j))!=dict.end())
                {
                    arr[i]=true;
                    break;
                }
            }
        }
        return arr[s.size()];        
    }
};

三角矩阵

link
题目描述：

思路一：
从上往下走
由于只能往下走或者往右下走，所以它的路径最小就是上一层合理的最小的加上当前层即F[i][j]+=min(F[i-1][j],F[i-1][j-1];当i=0时，只能取F[i-1][j],当i==j时只能取F[i-1][j-1];最后要求的最短路径就是最后一层的最小数

class Solution {
public:
    int minimumTotal(vector<vector<int> > &triangle) {
      if(triangle.empty())
          return 0;
     
      int min_e;
        for(int i=1;i<triangle.size();++i)
        {
            for(int j=0;j<=i;++j)
            {
              if(j==0)
                min_e=triangle[i-1][j];
                
               else if(j==i)
               min_e=triangle[i-1][j-1];
               else
                   min_e=min(triangle[i-1][j],triangle[i-1][j-1]);
               
                triangle[i][j]+=min_e;             
            }
        }
        int n=triangle.size()-1;
     
 int min=triangle[n][0];       
for(int i=0;i<=n;++i)
{
    if(triangle[n][i]<min)
        min=triangle[n][i];
}
 return min;
    }
};

思路二：
既然可以从上往下走，那就可以从下往上走，而且从下往上不会出现越界
F[i][j]+=min(F[i+1][j],F[i+1][j+1];
直接将最终结果加到F[0][0]上

class Solution {
public:
    int minimumTotal(vector<vector<int> > &triangle) {
      if(triangle.empty())
          return 0;
       for(int i=triangle.size()-2;i>=0;--i)
       {
           for(int j=0;j<=i;j++)
           {
               triangle[i][j]+=min(triangle[i+1][j],triangle[i+1][j+1]);
           }
       }
        return triangle[0][0];
    }
};

有障碍物的路径总数

link
题目描述：

思路：F[i][j]=（F[i-1][j]+F[i][j-1]）or {0，if(arr[i][j]==0)}；
特殊处理：
初始化为全0
F[i][0]=1or {0,如果这一列有一个障碍物}
F[0][j]=1 or {0,如果这一列有一个障碍物}
返回结果
F[n-1][m-1]

class Solution {
public:
    /**
     * 
     * @param obstacleGrid int整型vector<vector<>> 
     * @return int整型
     */
    int uniquePathsWithObstacles(vector<vector<int> >& obstacleGrid) {
        // write code here
        int n=obstacleGrid.size();int m=obstacleGrid[n-1].size();
        
       vector< vector<int>> ans(n,vector<int> (m,0));
        for(int i=0;i<n;++i)
        {
            if(obstacleGrid[i][0]==1)
                break;
            ans[i][0]=1;
        }
          for(int j=0;j<m;++j)
        {
            if(obstacleGrid[0][j]==1)
                break;
            ans[0][j]=1;
        }
        for(int i=1;i<n;++i)
        {
            for(int j=1;j<m;++j)
            {
                if(obstacleGrid[i][j]==1)
                    ans[i][j]=0;
                else
                    ans[i][j]=ans[i-1][j]+ans[i][j-1];               
            }
        }

      
        return ans[n-1][m-1];
    }
};

带权值的最小路径和

link
题目描述：

思路：
F[i][j]=F[i][j]+min(F[i-1][j],F[i][j-1]);
特殊处理：
F[i][0]=F[i][0]+F[i-1][0];
F[0][j]=F[0][j]+F[0][j-1];
返回结果：
F[m-1][n-1];

class Solution {
public:
    /**
     * 
     * @param grid int整型vector<vector<>> 
     * @return int整型
     */
    int minPathSum(vector<vector<int> >& grid) {
        // write code here
        int m=grid.size();
        if(grid.empty())
            return 0;
        int n=grid[0].size();
        vector<vector<int> >ans(grid);
        for(int j=1;j<n;++j)
        {
            ans[0][j]+=ans[0][j-1];
        }
        for(int i=1;i<m;i++)
        {
            ans[i][0]+=ans[i-1][0];
        }
        for(int i=1;i<m;++i)
            for(int j=1;j<n;++j)
            {
                ans[i][j]+=min(ans[i-1][j],ans[i][j-1]);
            }
        return ans[m-1][n-1];
    }
};