LeetCode //C - 62. Unique Paths

62. Unique Paths

There is a robot on an m x n grid. The robot is initially located at the top-left corner (i.e., grid[0][0]). The robot tries to move to the bottom-right corner (i.e., grid[m - 1][n - 1]). The robot can only move either down or right at any point in time.

Given the two integers m and n, return the number of possible unique paths that the robot can take to reach the bottom-right corner.

The test cases are generated so that the answer will be less than or equal to 2 ∗ 1 0 9 2 * 10^9 2∗109.

Example 1:

Input: m = 3, n = 7
Output: 28

Example 2:

Input: m = 3, n = 2
Output: 3
Explanation: From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:

  1. Right -> Down -> Down
  2. Down -> Down -> Right
  3. Down -> Right -> Down
Constraints:
  • 1 <= m, n <= 100

From: LeetCode

Link: 62. Unique Paths


Solution:

Ideas:
  1. Initialization: A 1-dimensional array dp[] with n elements is created. Since the robot can only move right or down, there is exactly one way to reach any cell in the first row of the grid (by moving right at every step). Therefore, the dp[] array is initialized with 1s.

  2. Dynamic Programming: The code then iterates through the grid row by row, starting from the second row (since the first row is already initialized). For each cell (i, j) (excluding those in the first row and column), the number of unique paths to that cell is the sum of the unique paths to the cell directly above it (i - 1, j) and the cell to the left of it (i, j - 1). This is because the robot can only arrive at (i, j) from these two adjacent cells.

  3. Filling the dp[] Array: For each row, the code updates the dp[] array in place. Each dp[j] will hold the count of unique paths to reach the cell (i, j). The update is done by adding the number of paths to the cell to the left (dp[j - 1]) to the current value of dp[j], which before the update holds the number of paths to the cell above.

  4. Result: After filling in the dp[] array for all rows, the last element of the dp[] array (dp[n - 1]) will contain the number of unique paths to reach the bottom-right corner of the grid.

Caode:
c 复制代码
int uniquePaths(int m, int n) {
    // We only need one row to store the previous results
    int dp[n];
    
    // Initialize the first row to 1's since there's only one way to reach any cell in the first row
    for (int i = 0; i < n; i++) {
        dp[i] = 1;
    }
    
    // Build the number of ways to get to each cell
    // We start at 1 since the first row is already initialized
    for (int i = 1; i < m; i++) {
        // We start at 1 here as well since there's only one way to reach any cell in the first column
        for (int j = 1; j < n; j++) {
            // The number of ways to get to the current cell is the sum of the ways to get to the cell above and the cell to the left
            dp[j] += dp[j - 1];
        }
    }
    
    // The bottom-right corner will have our answer
    return dp[n - 1];
}
相关推荐
NAGNIP2 小时前
大模型框架性能优化策略:延迟、吞吐量与成本权衡
算法
美团技术团队3 小时前
LongCat-Flash:如何使用 SGLang 部署美团 Agentic 模型
人工智能·算法
Fanxt_Ja7 小时前
【LeetCode】算法详解#15 ---环形链表II
数据结构·算法·leetcode·链表
侃侃_天下7 小时前
最终的信号类
开发语言·c++·算法
茉莉玫瑰花茶8 小时前
算法 --- 字符串
算法
博笙困了8 小时前
AcWing学习——差分
c++·算法
NAGNIP8 小时前
认识 Unsloth 框架:大模型高效微调的利器
算法
NAGNIP8 小时前
大模型微调框架之LLaMA Factory
算法
echoarts8 小时前
Rayon Rust中的数据并行库入门教程
开发语言·其他·算法·rust
Python技术极客8 小时前
一款超好用的 Python 交互式可视化工具,强烈推荐~
算法