0004-猴子爬山

题目描述

一天一只顽猴想要从山脚爬到山顶，
途中经过一个有n个台阶的阶梯，
但是这个猴子有个习惯，每一次只跳1步或3步
试问？猴子通过这个阶梯有多少种不同的跳跃方式

输入描述

输入只有一个数n， 0 < n < 50
代表此阶梯有多个台阶

输出描述

有多少种跳跃方式

示例一

输入

50

输出

122106097

示例二

输入

3

输出

2

参考解题 Java-1

import java.util.Scanner;

public class Main0004 {
  public static void main(String[] args) {
    try (Scanner scanner = new Scanner(System.in)) {
      int n = scanner.nextInt();
      solution(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);
  }
}

参考解题 Java-2

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        long[] dp = new long[n + 1];// 创建一个长度为n+1的数组来保存跳跃方式数，初始值都为0
        dp[0] = 0;// 初始位置，只有0种方式
        dp[1] = 1;// 第一步跳1步，只有一种方式
        dp[2] = 1; // 第一步跳2步，只有一种方式
        dp[3] = 2; // 第一步走3步，第一步跳3步，只有两种方式
        // 计算每个位置的跳跃方式数
        for (int i = 4; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 3];
        }
        System.out.println(dp[n]);
    }
} 

参考解题java-3

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入阶梯数：");
        int num = scanner.nextInt();
        System.out.println(showF(num));
    }

    /**
     * 递归算法f(n) = f(n-1) + f(n-3);
     * f(1) =1;f(2) =1;f(3) = 2
     */
    public static long showF(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }
        if (n == 3) {
            return 2;
        }
        return showF(n - 1) + showF(n - 3);
    }

}

参考解题 Python

n = int(input())

steps = [1, 1, 2]
res = 1 if n == 1 or n == 2 else 2
for i in range(4, n + 1):
    res = steps[2] + steps[0]
    steps = steps[1:] + [res]
print(res)

参考解题 C

#include <stdio.h>

int jumpWaysCount(int n) {
    if (n == 1) {
        return 1;
    }
    if (n == 2) {
        return 1;
    }
    if (n == 3) {
        return 2;
    }
    int dp[n + 1];  // 创建动态规划数组，用于存储跳跃方式数量
    dp[1] = 1;  // 初始化状态：1个台阶只有1种跳跃方式
    dp[2] = 1;  // 初始化状态：2个台阶只有1种跳跃方式
    dp[3] = 2;  // 初始化状态：3个台阶有2种跳跃方式
    for (int i = 4; i <= n; i++) {  // 从4个台阶开始计算跳跃方式数量
        dp[i] = dp[i - 1] + dp[i - 3];  // 使用状态转移方程计算跳跃方式数量
    }
    return dp[n];  // 返回通过n个台阶的不同跳跃方式数量
}

int main() {
    int n;
    printf("Enter the number of steps: ");
    scanf("%d", &n);  // 输入台阶数
    int ways = jumpWaysCount(n);  // 调用函数计算跳跃方式数量
    printf("Number of jump ways: %d\n", ways);  // 输出跳跃方式数量
    return 0;
}

参考解题C++

#include <iostream>
#include <vector>
using namespace std;

int countJumpWays(int n) {
    if (n == 0 || n == 1) {
        return 1;
    } else if (n == 2) {
        return 1;
    }

    // 创建一个长度为n+1的向量来保存跳跃方式数，初始值都为0
    vector<int> jumpWays(n + 1, 0);

    // 初始化前几个位置的跳跃方式数
    jumpWays[0] = 1;  // 初始位置，只有一种方式
    jumpWays[1] = 1;  // 第一步跳1步，只有一种方式
    jumpWays[2] = 1;  // 第一步跳2步，只有一种方式

    // 计算每个位置的跳跃方式数
    for (int i = 3; i <= n; i++) {
        jumpWays[i] = jumpWays[i - 1] + jumpWays[i - 3];
    }

    return jumpWays[n];
}

int main() {
    // 读取输入的阶梯台阶数
    int n;
    cin >> n;

    // 调用函数计算跳跃方式数
    int result = countJumpWays(n);

    // 输出结果
    cout << result << endl;

    return 0;
}

参考解题JS

function countJumpWays(n) {
    if (n === 0 || n === 1) {
      return 1;
    } else if (n === 2) {
      return 1;
    }
  
    // 创建一个长度为n+1的数组来保存跳跃方式数，初始值都为0
    const jumpWays = new Array(n + 1).fill(0);
  
    // 初始化前几个位置的跳跃方式数
    jumpWays[0] = 1; // 初始位置，只有一种方式
    jumpWays[1] = 1; // 第一步跳1步，只有一种方式
    jumpWays[2] = 1; // 第一步跳2步，只有一种方式
  
    // 计算每个位置的跳跃方式数
    for (let i = 3; i <= n; i++) {
      jumpWays[i] = jumpWays[i - 1] + jumpWays[i - 3];
    }
    return jumpWays[n];
  }
  // 读取输入的阶梯台阶数
  const readline = require('readline');
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });
  
  rl.question('请输入阶梯台阶数：', (n) => {
    // 调用函数计算跳跃方式数
    const result = countJumpWays(parseInt(n));
    // 输出结果
    console.log(result);
    rl.close();
  });