sfs和dp例子

package com.od;

import java.util.Scanner;

/**
 * 一天一只顽猴想要从山脚爬到山顶
 * 途中经过一个有n个台阶的阶梯，但是这个猴子有个习惯，每一次只跳1步或3步
 * 试问？猴子通过这个阶梯有多少种不同的跳跃方式
 * <p>
 * 输入描述
 * 输入只有一个这个数n 0 < n < 50
 * 此阶梯有多个台阶
 * <p>
 * 输出描述
 * 有多少种跳跃方式
 * <p>
 * 示例一
 * 输入
 * <p>
 * 50
 * 输出
 * <p>
 * 122106097
 */
public class Main0004 {
    public static int cnt = 0;

    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            int n = scanner.nextInt();
            dfs(0, n);
            System.out.println(cnt);
        }
    }

    /**
     * 深度优先
     * @param cur
     * @param n
     */
    private static void dfs(int cur, int n) {
        if (cur == n) {
            cnt++;
        }
        if (cur > n) {
            return;
        }
        dfs(cur + 1, n);
        dfs(cur + 3, n);
    }

    private static void solution(int n) {
        int step1 = 1, step2 = 1, step3 = 2;
        int step4 = n == 1 || n == 2 ? 1 : 2;
        for (int i = 4; i <= n; i++) {
            step4 = step3 + step1;
            step1 = step2;
            step2 = step3;
            step3 = step4;
        }
        System.out.println(step4);
    }
}

package org.example;

import java.util.Scanner;

/**
 * 描述
 * 请计算n*m的棋盘格子（n为横向的格子数，m为竖向的格子数）
 * 从棋盘左上角出发沿着边缘线从左上角走到右下角，
 * 总共有多少种走法，要求不能走回头路，
 * 即：只能往右和往下走，不能往左和往上走。
 * <p>
 * 注：沿棋盘格之间的边缘线行走
 * 数据范围： 1 \le n,m \le 8 \1≤n,m≤8
 * <p>
 * 输入描述：
 * 输入两个正整数n和m，用空格隔开。(1≤n,m≤8)
 * <p>
 * 输出描述：
 * 输出一行结果
 */
public class Test33 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            int m = in.nextInt();
            System.out.println(walk(n, m));
        }
    }

    public static int walk(int n, int m) {
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 0; i < dp[0].length; i++) {
            // 列长度
            dp[0][i] = 1;
        }

        for (int i = 0; i < dp.length; i++) {
            // 行长度
            dp[i][0] = 1;
        }

        for (int i = 1; i < dp.length; i++) {
            for (int j = 1; j < dp[0].length; j++) {
                dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
            }
        }
        return dp[n][m];
    }
}

package org.example;

import java.util.Scanner;

/**
 * 把m个同样的苹果放在n个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？
 * 注意：如果有7个苹果和3个盘子，（5，1，1）和（1，5，1）被视为是同一种分法。
 * <p>
 * 数据范围：0 \le m \le 10 \0≤m≤10 ，1 \le n \le 10 \1≤n≤10 。
 * <p>
 * 输入描述：
 * 输入两个int整数
 * <p>
 * 输出描述：
 * 输出结果，int型
 */
public class Test34 {

    /**
     * 解析：
     * 放苹果情况：（1）有空盘，（2）无空盘
     * 有空盘理解为：f(m, n) = f(m, n-1)，在n-1个盘上放苹果，
     * 一次类推直到n==1，只有1种放法
     * 无空盘理解为：f(m, n) = f(m-n, n)，
     * 在n个盘上放1个苹果，剩下的m-n苹果随意放，
     * 直到m<n时，返回0，当m=n，即m-n=0时，返回1
     * 所以f(m, n) = f(m, n-1) + f(m-n, n);
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int m = in.nextInt(); // 苹果个数
        int n = in.nextInt(); // 盘子个数
        System.out.println(countWays(m, n));

        ///System.out.println(count(m, n));
    }

    // 动态规划
    public static int countWays(int m, int n) {
        // 额外创建一行作为辅助行
        int[][] dp = new int[m + 1][n + 1];
        // 初始化（m-n=0时，1种摆法）(n=1, 1种摆法【可省略】)
        for (int j = 0; j < dp[0].length; j++) {
            dp[0][j] = 1;
        }
        // 遍历计算f(m, n) = f(m, n-1) + f(m-n, n)
        for (int i = 1; i < dp.length; i++) {
            for (int j = 1; j < dp[0].length; j++) {
                dp[i][j] = dp[i][j - 1] + (i < j ? 0 : dp[i - j][j]);
            }
        }
//          1.假设有一个盘子为空，则(m,n)问题转化为将m个苹果放在n-1个盘子上，即求得(m,n-1)即可
//          2.假设所有盘子都装有苹果，则每个盘子上至少有一个苹果，
//          即最多剩下m-n个苹果，问题转化为将m-n个苹果放到n个盘子上
//          即求(m-n，n)
//          就转换为了以上两种情况
        return dp[m][n];
    }

    public static int count(int m, int n) {
        //不可能是负数
        if (m < 0 || n <= 0) {
            return 0;
        }
        // 细分为苹果数为1或盘子数为一的情况返回1
        //一个苹果、一个盘子、没有苹果，就都只有一种情况
        //给出了下限，1种1种的向上累计
        if (m == 1 || n == 1 || m == 0) {
            return 1;
        }
        // 将事件无线细分
        return count(m, n - 1) + count(m - n, n);
//          1.假设有一个盘子为空，则(m,n)问题转化为将m个苹果放在n-1个盘子上，即求得(m,n-1)即可
//          2.假设所有盘子都装有苹果，则每个盘子上至少有一个苹果，即最多剩下m-n个苹果，问题转化为将m-n个苹果放到n个盘子上
//          即求(m-n，n)
//          就转换为了以上两种情况
    }
}