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];
}
相关推荐
星梦清河几秒前
宋红康 JVM 笔记 Day15|垃圾回收相关算法
jvm·笔记·算法
货拉拉技术10 分钟前
揭秘语音交互的核心技术
算法
矛取矛求40 分钟前
日期类的实现
开发语言·c++·算法
正在起飞的蜗牛1 小时前
【C语言】函数指针的使用分析:回调、代码逻辑优化、代码架构分层
c语言·架构
在下雨5991 小时前
项目讲解1
开发语言·数据结构·c++·算法·单例模式
Jayyih1 小时前
嵌入式系统学习Day36(简单的网页制作)
学习·算法
饭碗的彼岸one2 小时前
C++ 并发编程:异步任务
c语言·开发语言·c++·后端·c·异步
脑洞代码2 小时前
20250909的学习笔记
算法
Christo32 小时前
TFS-2003《A Contribution to Convergence Theory of Fuzzy c-Means and Derivatives》
人工智能·算法·机器学习
黑菜钟2 小时前
代码随想录第七天|● 454.四数相加II ● 383. 赎金信 ● 15. 三数之和 18.四数之和
c++·算法·leetcode