一个m * n的网格，从最左上角出发，每次只能向右或者向下移动一格，问有多少种不同的方法可以到达最右下角的格子

格子路径

题目：
在一个 2×2 的栅格中，从左上角出来，只能向右或向下移动，总共有 6 条路径可以到达栅格的右下角：

求m*n的网格中，有多少条移动路径？
以一个 20×20 的栅格为例，它有137846528820条移动路径。

1、第一个思路：（暴力破解）m*n的网格总共需要向右走n步 向下走m步，因此只需要从m+n步中选出m步向下或n步向右，因此**C(m+n,m)**种。
2、第二个思路：（动态规划）
首先考虑子问题，如在题目中一步可以到达(2,2)点的点只有两个，分别是(2,1)和(1,2)，

• 则到达(2,2)点的路径数也就是到达(2,1)点的路径数+到达(1,2)点的路径数，

• 而到达(2,1)点的路径数等于到达(1,1)点的路径数+到达(2,0)点的路径数。

• 因此一般地，到达点(x,y)的路径数等于到达(x-1,y)的路径数+到达(x,y-1)的路径数

• 边界条件是，一旦 x 或者 y 的坐标为零，则到达该点的路径只有一条。

• 因此，我们将该动态规划问题的状态转移方程表述如下：

•   		p(x−1,y)+p(x,y−1)  (x,y>0)
  

• p(x,y)=

•   		1 (x=0 或 y=0)
  

  下面代码即为求出C(m+n,m)，如果m与n小可以直接求，但是m与n过大的话，long存储不了太大的数字，因此需要另想办法，下面代码就是我想出的方法，
  可能存在一些bug。
  可恶，突然想起来能用import java.math.BigInteger;
  这样就简单多了，我还是一个菜菜…

import java.util.Scanner;
public static void main(String[] args){
        long sum=1l;
        long tem=1l;
        Scanner input=new Scanner(System.in);
        int m=input.nextInt();
        int n=input.nextInt();
        //现以找m步向下为例
        for(int i=m+n,j=m;i>m;i--,j--){
            sum*=i;
            if(sum%j==0) sum/=j;
            else tem*=j;
        }
        sum/=tem;
        System.out.println(sum);
    }
  /*
    递归太慢求不出答案
    static int sum(int m, int n)
    {
        if (m == 0||n==0)
            return 1;
        int total = sum(m - 1, n) + sum(m, n - 1);
        return total;
    }	*/

运行结果：

附：递归方法太慢，我得不出结果。
我又来更新内容了

//方法1：暴力破解
public class solve {
 //求阶乘 n! 使用 BigInteger
 	public BigInteger factorial(int n) {
 		BigInteger prod = BigInteger.ONE;
 		for (int i = 2; i <= n; i++)
 			prod = prod.multiply(BigInteger.valueOf(i));
		return prod;
 	}
 //C(n,k)=n!/k!*(n-k)!=n(n-1)(n-2)...(n-k+1)/k!
 	public BigInteger comb(int n, int k) {
 		BigInteger product = BigInteger.ONE;
 		for (int i = 0; i < k; i++)
 			product = product.multiply(BigInteger.valueOf(n - i));
 		return product.divide(factorial(k));
 	}
 	public String run1() {
 	return comb(40, 20).toString();
 	}
 	//方法 2：动态规划
 	public BigInteger path(int x, int y) {
 		if (x == 0 || y == 0)
 			return BigInteger.ONE;
 		else
 			return path(x - 1, y).add(path(x, y - 1));
 	}
 	//(20,20)太耗时,用(15,15)测试一下
	 public String run2() {
 		return path(15, 15).toString();
 	}
 	public static void main(String[] args) {
		 System.out.println(new solve().run1());
	// System.out.println(new solve().run2());
 	} 
 }