62.Unique Paths---dp

题目链接

题目大意：给一个m*n的方格，从左上角走到右下角，中间无任何障碍，问有多少种走法。

法一：DFS，超时，简单模板深搜，无任何剪枝，结果一半的数据超时。代码如下：

     public int uniquePaths(int m, int n) {
         int f[][] = {{0, 1}, {1, 0}};
         boolean vis[][] = new boolean[m][n];
         return dfs(m, n, 0, 0, 0, f, vis);
     }
     public static int dfs(int m, int n, int x, int y, int cnt, int f[][], boolean vis[][]) {
         if(x == m - 1 && y == n - 1) {
             System.out.println("answer:" + cnt);
             cnt++;
             return cnt;
         }
         for(int i = 0; i < 2; i++) {
             int cnt_x = x + f[i][0];
             int cnt_y = y + f[i][1];
             if(cnt_x < m && cnt_y < n && vis[cnt_x][cnt_y] == false) {
                 vis[cnt_x][cnt_y] = true;
                 cnt = dfs(m, n, cnt_x, cnt_y, cnt, f, vis);
                 vis[cnt_x][cnt_y] = false;
             }
         }
         return cnt;
     }

法二（借鉴）：很简单的dp，dp[i][j]表示当终点坐标是[i,j]时，所有可能的路径总数代码如下（耗时1ms）：

     public int uniquePaths(int m, int n) {
         int dp[][] = new int[m][n];
         //初始化
         //对于第一列和第一行，走的路径数应该初始化为1
         for(int i = 0; i < m; i++) {
             dp[i][0] = 1;
         }
         for(int i =0 ; i < n; i++) {
             dp[0][i] = 1;
         }
         //计算dp
         //对于dp[i][j]，每一个坐标[i,j]，都可以由其左侧和上侧走一步而来。类似于杨辉三角
         for(int i = 1; i < m; i++) {
             for(int j = 1; j < n; j++) {
                 dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
             }
         }
         return dp[m - 1][n - 1];
     }

法三（借鉴）：一维dp，还不是很懂，是怎么来的，暂且记一下。代码如下（耗时0ms）：

 public int uniquePaths(int m, int n) {
         int dp[] = new int[n];
         //初始化，dp[i]表示某一行第i列的路径总数
         for(int i = 0; i < n; i++) {
             dp[i] = 1;
         }
         //外层循环是每一行，第1行计算了，第2行就是利用了第1行的值，所以这里也是左+上的和得到当前值，只是节约了空间
         for(int i = 1; i < m; i++) {
             //对于每一行，逐一判定每一列的路径值。
             for(int j = 1; j < n; j++) {
                 dp[j] += dp[j - 1];
             }
         }
         //两层循环后，得到的最终的值就是所有路径的结果值。
         return dp[n - 1];
     }

法四（借鉴）：数学方法，由左上到右下，向下要走m-1步，向右要走n-1步，也就是要走C(m+n-2, m-1)或C(m+n-2, n-1)步。而C(m, n) = A(m, n)/n!，又A(m, n)=m!/(m-n)!。则C(m+n-2, m-1)=m*(m+1)*(m+2)...*(m+n-2)/1*2*3...*(n-1)。代码如下：

     public int uniquePaths(int m, int n) {
         double res = 1;
                 //计算组合数
         for(int i = 1; i <= n - 1; i++) {
             res = res * (m + i - 1) / i;
         }
         return (int)res;
     }