刷了几个月leetcode了，来记录一下，分一分类（3）

从左上角到右下角的路径

62. 不同路径 这个系列最简单的题目了

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

问总共有多少条不同的路径？

例如，上图是一个7 x 3 的网格。有多少可能的路径？

说明：m 和 n 的值均不超过 100。

很简单基础的动态规划

int uniquePaths(int m, int n) {
        vector<vector<int>> c(m,vector<int>(n,0));
        for(int j=0;j<n;j++){
            c[0][j]=1;
        }
        for(int i=0;i<m;i++){
            c[i][0]=1;
        }
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                c[i][j]=c[i-1][j]+c[i][j-1];
            }
        }
        return c[m-1][n-1];
    }

63. 不同路径 II比62多了障碍物，不过仍然很简单，碰到障碍物时处理一下就可以了

int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        vector<vector<long>> c(m,vector<long>(n,0));
        for(int j=0;j<n;j++){
            if(obstacleGrid[0][j]==1){
                break;
            }
            c[0][j]=1;
        }
        for(int i=0;i<m;i++){
            if(obstacleGrid[i][0]==1){
                break;
            }
            c[i][0]=1;
        }
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                if(obstacleGrid[i][j]==1){
                    c[i][j]=0;
                }
                else c[i][j]=c[i-1][j]+c[i][j-1];
            }
        }
        return c[m-1][n-1];
    }

64. 最小路径和 是62的变种，相当于是机器人走的格子加了权重

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

此外还有从顶向下的题目，如：

120. 三角形最小路径和

给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。

例如，给定三角形：

[
     [2],
    [3,4],
   [6,5,7],
  [4,1,8,3]
]
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

像三角这样的题目，从下往上遍历会方便很多

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

讲个不怎么搭边的

119. 杨辉三角 II

给定一个非负索引 k，其中 k ≤ 33，返回杨辉三角的第 k 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

示例:

输入: 3
输出: [1,3,3,1]

输出杨辉三角的某一行也可以从后面开始写，避免覆盖

vector<int> getRow(int rowIndex) {
        vector<int> temp(rowIndex+1,1);
        for(int i=0;i<=rowIndex;i++){
            for(int j=i-1;j>=1;j--){
                temp[j]=temp[j]+temp[j-1];
            }
        }
        return temp;
    }

还有像

74. 搜索二维矩阵，也能从后面开始搜索

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。
示例 1:

输入:
matrix = [
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]
target = 3
输出: true

bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if(matrix.empty()||matrix[0].size()==0)return false;
        int i=0,j=matrix[0].size()-1;
        while(i<matrix.size()&&j>=0){
            if(matrix[i][j]==target){
                return true;
            }
            else if(matrix[i][j]<target){
                i++;
            }else{
                j--;
            }
        }
        return false;
    }