本文共 2498 字，大约阅读时间需要 8 分钟。

������������

���������������������������������

���������m���n���������������������������������������������������������������������������������������������������������������������������������������������������������

���������������������

������������������������������������m + n - 2���������������������������������������������n���m������������������m-1���������������������������C(m+n-2, m-1)���

������������������������

������������dp������������dp[i][j]������������(i, j)���������������������������������dp[0][0] = 1������������������������������������������dp������������

���������������������������

������������������������������������������������������������������������������������������������������������������������������������

���������������������������

������������������������������������������������������������������������������������

���������������

#include 
   
    
int uniquePaths(int m, int n) {
    if (m == 0 || n == 0) return 0;
    
    // ���������������������������
    int total_steps = m + n - 2;
    int choose = total_steps;
    int back = m - 1;
    
    // ���������������������������������
    long result = 1;
    for (int i = 1; i <= back; ++i) {
        result *= (total_steps - back + i);
        result /= i;
    }
    return result;
}
int main() {
    // ������������
    printf("m=3,n=2: %d\n", uniquePaths(3,2));
    printf("m=7,n=3: %d\n", uniquePaths(7,3));
    return 0;
}
   

���������������������������������������������

������������������������1���������������0������������������������������������������������������������������������������������������

������������������������

������������dp������dp[i][j]������������(i, j)���������������������������������������������dp[i][j] = 0������������dp[i][j] = dp[i-1][j] + dp[i][j-1]���

���������������

int uniquePathsWithObstacles(int** obstacleGrid, int m, int n) {
    if (m == 0 || n == 0) return 0;
    // ���������DP���
    int dp[m][n];
    int sum;
    for (int i=0; i

���������������������������������

���m x n���������������������������������������������������������������������������������������

������������������������

������dp������dp[i][j]������������(i, j)���������������������dp[i][j] = grid[i][j] + min(dp[i][j-1], dp[i-1][j])���

���������������

int minPathSum(int** grid, int m, int n) {
    if (m == 0 || n == 0) return 0;
    int dp[m][n];
    for (int i=0; i

������������������������������������������������������������������������������������������������������������������������������������