题目描述：
给定一个正整数 n ，请找出跳格子的方式数，跳格子的规则是每次只能跳至正向的下一个格子，或是跳至负向的下一个格子。
输入描述：
输入一个正整数 n
输出描述：
输出跳格子的方式数
解决方案：
这是一个典型的动态规划问题。我们可以定义一个数组 dp ，其中 dp[i] 表示到达格子 i 的方式数。初始时，dp 数组中的所有元素都初始化为0。
动态规划的状态转移方程为：
- 如果 i 是偶数，那么 dp[i] = dp[i - 1] + dp[i / 2]，表示可以从 i - 1 直接跳到 i，或者从 i / 2 经过一次跳跃后到达 i。
- 如果 i 是奇数，那么 dp[i] = dp[i - 1]，表示因为只能跳至正向的下一个格子或负向的下一个格子，所以无论如何我们都不能到达奇数位置的格子。
以下是各种语言的实现：
Java 实现：
public class Main {
public static void main(String[] args) {
int n = 5; // 示例输入
System.out.println(jumpFloor(n));
}
public static int jumpFloor(int target) {
if (target <= 0) {
return 0;
}
int[] dp = new int[target + 1];
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= target; i++) {
if (i % 2 == 0) {
dp[i] = dp[i - 1] + dp[i / 2];
} else {
dp[i] = dp[i - 1];
}
}
return dp[target];
}
}Python 实现：
def jumpFloor(target):
dp = [0] * (target + 1)
dp[0], dp[1] = 0, 1
for i in range(2, target + 1):
if i % 2 == 0:
dp[i] = dp[i - 1] + dp[i // 2]
else:
dp[i] = dp[i - 1]
return dp[target]
print(jumpFloor(5)) # 示例输出C++ 实现：
#include <iostream>
#include <vector>
using namespace std;
int jumpFloor(int target) {
vector<int> dp(target + 1, 0);
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= target; i++) {
if (i % 2 == 0) {
dp[i] = dp[i - 1] + dp[i / 2];
} else {
dp[i] = dp[i - 1];
}
}
return dp[target];
}
int main() {
int n;
cin >> n;
cout << jumpFloor(n) << endl;
return 0;
}JavaScript 实现：
function jumpFloor(target) {
let dp = new Array(target + 1).fill(0);
dp[0] = 0;
dp[1] = 1;
for (let i = 2; i <= target; i++) {
if (i % 2 === 0) {