动态规划：62. 不同路径

62. 不同路径

题目描述：

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

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

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

 

解题思路1：

动态规划的三个步骤：

1. 定义数组元素的含义；创建一个二维数组sig[m][n]

2. 找出数组之间的关系；

想象以下，机器器⼈人要怎么样才能到达 (i, j) 这个位置？由于机器人可以向下⾛走或者向右⾛走，所以有两种⽅式到达；

一种是从 (i-1, j) 这个位置⾛走⼀一步到达；一种是从(i, j - 1) 这个位置走⼀步到达；

因为是计算所有可能的步骤，所以是把所有可能⾛走的路路径都加起来，所以关系式是 dp[i] [j] = dp[i-1] [j]+ dp[i] [j-1]

3. 找出初始值；

dp[0] [0….n-1] = 1; // 相当于最上⾯面⼀⾏行，机器器人只能一直往左⾛；
dp[0…m-1] [0] = 1; // 相当于最左⾯面⼀列列，机器器人只能一直往下⾛。

 

class Solution {
public:
    int uniquePaths(int m, int n) 
    {
        //int sig[m][n];
        /*  动态创建一个二维数组，考虑内存释放，否则会泄露*/
        int** sig=new int* [m];
        for(int i=0;i<m;i++)
        {
            sig[i]=new int[n];
        }

        for (int i=0; i<m; i++)
        {
            sig[i][0]=1;
        }
        for (int i=0; i<n; i++)
        {
            sig[0][i]=1;
        }

        for (int i=1; i<m; i++)
            for (int j=1; j<n; j++)
            {
                sig[i][j] = sig[i-1][j] + sig[i][j-1];
            }
        return sig[m-1][n-1];
    }
};

 

 

解题思路1：优化

 注意一维二维和三维数组的动态内存分配；

//一维数组动态内存分配
int *dp = (int *)malloc(sizeof(int) * n);

int* dp = new int[n]; 


// 二维数组动态申请，b数组大小为： n*p 
int **b = new int*[n]; 
for(int i=0; i<n; i++) 
{
    b[i] = new int[p];
}

 // 三维数组动态申请, c数组大小为： m*n*p: 
int ***c = new int **[m]; 
for(int i=0; i<m; i++) 
{
    c[i]=new int *[n]; 
    for(int j=0; j<n; j++)
    { 
        c[i][j] = new int [p]; 
    }
} 

 

用一维数组代替二维数组，省去了很多无需保存的数据。

class Solution {
public:
    int uniquePaths(int m, int n) 
    {
        //std::vector<int> dp(n);
        //int *dp = (int *)malloc(sizeof(int) * n);
        //一维数组动态申请，a数组大小为： n 
        int* dp = new int[n]; 

        if (m <= 0 || n <= 0)
        {
            return 0;
        }

        for (int i=0; i<n; i++)
        {
            dp[i] = 1;
        }

        for (int i=1; i<m; i++)
        {
            dp[0] = 1;
            for (int j=1; j<n; j++)
            {
                dp[j] = dp[j-1] + dp[j];
            }
        } 
        return dp[n-1];
    }
};