2017美团---网格走法数目

题目描述

有一个X*Y的网格，小团要在此网格上从左上角到右下角，只能走格点且只能向右或向下走。请设计一个算法，计算小团有多少种走法。给定两个正整数int x,int y，请返回小团的走法数目。

输入描述:

输入包括一行，逗号隔开的两个正整数x和y，取值范围[1,10]。

输出描述:

输出包括一行，为走法的数目。

示例1

输入

3 2

输出

10

题目链接：https://www.nowcoder.com/practice/e27b9fc9c0ec4a17a5064fb6f5ab13e4?tpId=85&tqId=29883&tPage=1&rp=1&ru=/ta/2017test&qru=/ta/2017test/question-ranking

题解：利用深搜，很蒙蔽的过了，这段代码可以说是java版的深搜模板。只能往右和往下走，不用标记数组，穷举出所有的走法情况，并计算走法总数可得最终解。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line = in.readLine();
        String[] pos = line.split(" ");
        int x = Integer.parseInt(pos[0]);
        int y = Integer.parseInt(pos[1]);
        int cnt = dfs(0, 0, x, y, 0);
        System.out.println(cnt);
    }
    public static int dfs(int x, int y, int end_x, int end_y, int cnt) {
        if(x == end_x && y == end_y) {
            cnt++;
            return cnt;
        }
        int res = 0;
        for(int i = 0; i < 2; i++) {//循环往右和往下走
            int next_x, next_y;
            if(i == 0) {//往下走
                next_x = x + 1;
                next_y = y;
            }
            else {//往右走
                next_x = x;
                next_y = y + 1;
            }
            if(next_x <= end_x && next_y <= end_y) {//只要不出边界，则进dfs
                cnt = dfs(next_x, next_y, end_x, end_y, cnt);
            }
        }
        return cnt;
    }
}

借鉴：

法一：由裴波那挈数列引申出的dp思想，由于只能往右和往下走，所以这里有dp方程式：dp[m][n] = dp[m-1][n] + dp[m][n-1]。

        int[][] dp = new int[x + 1][y + 1];
        for(int i = 0; i <= x; i++) {//初始化
            dp[i][0] = 1;
        }
        for(int i = 0; i <= y; i++) {//初始化
            dp[0][i] = 1;
        }
        for(int i = 1; i <= x; i++) {
            for(int j = 1; j <= y; j++) {//穷举不需要判断if
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        System.out.println(dp[x][y]);

法二：为了节省上面dp数组的空间，这里直接用递归解决，思想还是上面的dp思想，可以从两个方向入手，第一个是从最初始到最终行和列，递归返回的时候是从最终行和列返回的；第二个是从最终行和列到最初始，递归返回的时候是从最初始返回的。但是两个的递归结束条件一定要用||连接，而不要用&&连接，因为||是为了防止出界。一旦任意一个坐标走到边界处就表示该return了。

第一个：

    public static int dfs(int x, int y, int end_x, int end_y, int cnt) {
        if(x == end_x || y == end_y) {
            cnt++;
            return cnt;
        }
        else {
            return dfs(x + 1, y, end_x, end_y, cnt) + dfs(x, y + 1, end_x, end_y, cnt);
        }
    }

第二个：

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