动态规划（进阶）--矩阵类动态规划

前言：最近开始学习数据结构与算法，顺便刷leetcode，无意间发现了一个我觉得讲解的比较好的网页，并且会那leetcode里面的题目当做例题，如有需要，奉上网址：五分钟学算法
一、概念
1.回顾
核心步骤：拆解问题–定义状态
2.概念
矩阵类动态规划，也可以叫做坐标类动态规划，一般这类问题都会给你一个矩阵，矩阵里面有着一些信息，然后你需要根据这些信息求解问题。
你可以把整个矩阵当成一个图，矩阵里面的每个位置上的元素当成是图上的节点，然后每个节点的邻居就是其相邻的上下左右的位置，我们遍历矩阵其实就是遍历图，在遍历的过程中会有一些临时的状态，也就是子问题的答案，我们记录这些答案，从而推得我们最后想要的答案。
二、例题
1.不同路径（LeetCode 第 62 号问题）

递推方程

dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

class Solution {
public:
    int uniquePaths(int m, int n) {
        int dp[100][100];
        for(int i=0;i<m;i++)
            dp[i][0]=1;
        for(int j=0;j<n;j++)
            dp[0][j]=1;
        for(int i=1;i<m;i++)
            for(int j=1;j<n;j++)
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
        return dp[m-1][n-1];
    }
};

2.不同路径II（LeetCode 第 63 号问题）
递推方程

dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

相对于上一题多了障碍物的限制条件

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        if(obstacleGrid.size()==0||obstacleGrid[0].size()==0)
            return 0;
        if(obstacleGrid[0][0]==1)
            return 0;
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        long long dp[100][100];
        dp[0][0]=1;
        for(int i=1;i<m;i++)
            dp[i][0]=(obstacleGrid[i][0]==1)? 0:dp[i-1][0];
        for(int i=1;i<n;i++)
            dp[0][i]=(obstacleGrid[0][i]==1)? 0:dp[0][i-1];
        for(int i=1;i<m;i++)
            for(int j=1;j<n;j++)
            {
                dp[i][j]=(obstacleGrid[i][j]==1)? 0:dp[i-1][j]+dp[i][j-1];
            }

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

3.最小路径和（LeetCode 第 64 号问题）
递推方程dp[i][j] = Math.min(dp[i - 1][j] + dp[i][j - 1]) + grid[i][j]

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m=grid.size();
        int n=grid[0].size();
        for(int i=1;i<m;i++)
            grid[i][0]+=grid[i-1][0];
        for(int j=1;j<n;j++)
            grid[0][j]+=grid[0][j-1];
        for(int i=1;i<m;i++)
            for(int j=1;j<n;j++)
            {
                grid[i][j]+=min(grid[i-1][j],grid[i][j-1]);
            }

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

4.最大正方形（LeetCode 第 221 号问题）
递推方程dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if(matrix.size()==0||matrix[0].size()==0)
            return 0;
        int m=matrix.size();
        int n=matrix[0].size();
        int maxlength=0;
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
            {
                if(matrix[i][j]=='1')
                {
                    if(i!=0&&j!=0)     
                        matrix[i][j]=min(matrix[i-1][j]-'0',min(matrix[i][j-1]-'0',matrix[i-1][j-1]-'0'))+1+'0';
                }
                    
                maxlength=(maxlength>matrix[i][j]-'0')?maxlength:matrix[i][j]-'0';
            }
        return maxlength*maxlength;
    }
};