走方格的方案数

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m=sc.nextInt();
        int n=sc.nextInt();
        //格子数+1是线
        int [][]a=new int[m+1][n+1];
        for(int i =0;i<m+1;i++){
            a[i][0]=1;
        }
        for(int i =0;i<n+1;i++){
            a[0][i]=1;
        }
        for(int i =1;i<m+1;i++){
            for(int j=1;j<n+1;j++){
                a[i][j]=a[i-1][j]+a[i][j-1];
            }
        }
       System.out.print(a[m][n]);
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] dp = new int[m][n];
        dp[0][0] = 2;
        
        for(int i = 1 ;i < n;i++){
            dp[0][i] = dp[0][i-1] + 1;
        }

        for(int i = 1 ;i < m;i++){
            dp[i][0] = dp[i-1][0] + 1;
        }

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

        System.out.print(dp[m-1][n-1]);

    }
}

import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
            int n = in.nextInt();
            int m = in.nextInt();
            int min = n<m? n:m;
            int s = 1;
            for(int i=0;i<min;i++){
                s=s*(n+m-i)/(1+i);
            }
            System.out.println(s);
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        //动态规划算法
        int a = in.nextInt();
        int b = in.nextInt();
        int num = jisuan(a,b);
        System.out.print(num);
    }

    public static int jisuan(int a,int b){
           if(a==0 || b ==0){
              return 1;
           }           
            return jisuan(a-1,b)+jisuan(a,b-1);           
    }
}动态规划算法，说到底就是拆解成最小不能再拆的一种场景，这种场景就是a ==0 或者 b==0 ,这种情况就只有一种走法，然后相加即可得到答案

import java.io.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str;
        while((str=br.readLine())!=null){
            String[] strArr=str.split(" ");
            int n = Integer.parseInt(strArr[0]);
            int m = Integer.parseInt(strArr[1]);
            // dp表示第i*j棋盘的走法数
            int[][] dp=new int[m+1][n+1];
            // 初始化第1行的值，不含第0列
            for(int i=1;i<=n;i++) dp[1][i]=i+1;
            // 初始化第1列的值，不含第0行
            for(int i=1;i<=m;i++) dp[i][1]=i+1;
            // i、j行列的值等于i-1、j行列的值+i、j-1行列的值
            for(int i=2;i<=m;i++){
                for(int j=2;j<=n;j++){
                    dp[i][j]=dp[i][j-1]+dp[i-1][j];
                }
            }
            System.out.println(dp[m][n]);
        }
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] dp = new int[n+1][m+1];
        for(int i = 0; i <= n; i++){
            for(int j = 0;j <= m; j++){
                if(i == 0 || j == 0){
                    dp[i][j] = 1;
                }else{
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }   
            }
        }
        System.out.println(dp[n][m]);
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {

    private static int count = 0;
    private static int max_x;
    private static int max_y;

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        
        max_x = in.nextInt();
        max_y = in.nextInt();

        goAhead(0, 0);
        System.out.print(count);
    }

    private static void goAhead(int x, int y) {
        if (x > max_x || y > max_y) {
            return;
        }
        if (x == max_x && y == max_y) {
            count++;
            return;
        }
        goAhead(x+1, y);
        goAhead(x, y+1);
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        while (in.hasNextInt()) {
            int n = in.nextInt();
            int m = in.nextInt();
            int[][] map = new int[n+1][m+1];
            for (int i = 0; i <= n; i++) {
                map[i][0] = 1;
            }
            for (int i = 0; i <= m; i++) {
                map[0][i] = 1;
            }
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= m; j++) {
                    map[i][j] = map[i - 1][j] + map[i][j - 1];
                }
            }
            System.out.println(map[n][m]);
        }
    }
}

import java.util.Scanner;

/**
 * 请计算n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）从棋盘左上角出发沿着边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。
 * 注：沿棋盘格之间的边缘线行走
 *
 * 数据范围： 1 ≤ n,m ≤ 8
 *
 * 输入描述：
 * 输入两个正整数n和m，用空格隔开。(1≤n,m≤8)
 *
 * 在第一步时可以选择向右或者向下，只需要当前的路径选择上加上(n,m−1)和(n−1,m)的矩阵路径选择即可
 */
public class HJ91_dp走方格 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int[][] dp=new int[n+1][m+1];
        for (int i = 0; i <=n ; i++) {
            dp[i][0]=1;
        }
        for (int i = 0; i <=m ; i++) {
            dp[0][i]=1;
        }
        for (int i = 1; i <=n ; i++) {
            for (int j = 1; j <=m ; j++) {
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        System.out.println(dp[n][m]);
    }
}

public class Main {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        /*if(m==1 || n==1){
            System.out.println(1);
        }*/
        int[][] dp = new int[m+1][n+1];
        dp[0][0] = 1;
        
        /*i>0 j>0
        dp[i][j] = dp[i-1][j]+dp[i][j-1];
        //i=0 j>0
        dp[i][j] = 1;
        //i>0 j=0
        dp[i][j] = 1;*/
        for(int i=0;i<m+1;i++){
            for(int j=0;j<n+1;j++){
                if(i==0){
                    dp[i][j] = 1;
                }else if(j==0){
                    dp[i][j] = 1;
                }else{
                    dp[i][j] = dp[i-1][j]+dp[i][j-1];
                }
            }
        }
        System.out.println(dp[m][n]);
    }
}

import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int a = in.nextInt();
            int b = in.nextInt();
            System.out.println(walk(a,b));
        }
    }
    private static int walk(int n, int m) {
        // 定义二位dp数组dp[i,j] = dp[i-1,j]+dp[i,j-1];
        int[][] dp = new int[n + 1][m + 1];
        // base case
        for (int i = 0; i <= n; i++) {
            dp[i][0] = 1;
        }
        for (int j = 0; j <= m; j++) {
            dp[0][j] = 1;
        }
        // 递推
        for (int i = 1;i <= n;i++){
            for(int j = 1;j<= m ;j++){
                dp[i][j] = dp[i][j-1]+dp[i-1][j];
            }
        }
        return dp[n][m];
    }
}

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt(), n = sc.nextInt();
        m++;n++;
        int[][] dp = new int[m+1][n+1];
        
        for(int i=1; i<m+1; i++)
            for(int j=1; j<n+1; j++)
                if(i==1 || j==1) dp[i][j] = 1;
                
        
        for(int i=2; i<m+1; i++){
            for(int j=2; j<n+1; j++){
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        System.out.println(dp[m][n]);
    }
}