简单算法

我们首先来分析这个问题

• 对于第一行的所有网格，有且只有一种走法能到达他们，以第一行第三列的网格为例，只有【start -》右-》右】这一种走法，因为一旦往下走就没法再回头了。
• 对于第一列的所有网格同样道理，只有一种走法能到达他们，就是一直往下走。
• 对于其它非第一行且非第一列的网格 到达他们的走法 = 到达他左边网格的走法 + 到达他上面网格的走法（因为只能通过他们左边或上面的网格到达他们）

接着来抽象为函数

• 我们可以把网格看成坐标，start = （0， 0），finish = (m - 1, n -1);
• 到达每一个网格（坐标）的路径数为f(x,y)
• 根据我们上面的分析可知 f(0,y) = f(x,0) = 1
• f(x,y) = f(x-1)(y) + f(x)(y-1) 注意这里x和y都不为0

第一种解法 递归

 public int f(int x, int y) {
        if (x == 0 || y == 0) {
            return 1;
        }
        return f(x - 1, y) + f(x, y - 1);
 }

第二种解法 动态规划

public static int dp(int m, int n){
        int [][] arrs = new int[m][n];
        for(int x = 0; x < m; x ++){
            for(int y = 0; y < n; y++){
                if(x == 0 || y == 0){
                    arrs[x][y] = 1;
                }else{
                    arrs[x][y] = arrs[x-1][y] + arrs[x][y-1];
                }
            }
        }
      return arrs[m - 1][n -1];
    }

第三种解法 BFS

我们一般使用栈来实现BFS 思路很简单
首先需要定义一个坐标类Coords 接着把起点入栈
1：栈顶元素出栈
2：如果栈顶的坐标可以往右或者往下前进，则把下(down)和右（right）坐标入栈
3：如果栈顶的点是终点，则sum计数加1
循环上述过程，一直到栈为空，sum的值就是总路径数

    class Coord{
        int x = 0;
        int y = 0;
    }

    public int f(int m, int n){
        int sum = 0;
        Stack<Coord> stack = new Stack<>();
        Coord coord = new Coord();
        stack.push(coord);
        while(!stack.isEmpty()){
            Coord temp = stack.pop();
            int x = temp.x;
            int y = temp.y;
            if(x < m-1){
                Coord down = new Coord();
                next.x = x + 1;
                next.y = y;
                stack.push(down);
            }
            if(y < n-1){
                Coord right= new Coord();
                next.x = x;
                next.y = y + 1;
                stack.push(right);
            }
            if(x == m -1 && y == n - 1){
                sum++;
            }
        }
        return sum;
    }