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;
    }