Java 动态规划斐波那契序列

我正在学习动态规划在斐波那契序列中的应用，我有一个问题。以下是代码供参考：

import java.math.BigInteger;
import java.util.Arrays;

public class FibonacciNumbersB {

    static BigInteger[] dp = new BigInteger[10000];

    public static void main(String[] args) {
        Arrays.fill(dp, BigInteger.ZERO);
        dp[0] = BigInteger.ONE;
        dp[1] = BigInteger.ONE;

        for(int i = 4; i < 9999; i++)
            System.out.println(fibRecurse(i).toString());
    }

    public static BigInteger fibRecurse(int N) {
        for(int i = 2; i < N; i++) {
            // For numerous calls to this function, this will save as it goes
            if(dp[i].equals(BigInteger.ZERO))
                dp[i] = dp[i - 1].add(dp[i - 2]);
        }

        return dp[N - 1];
    }
}

import java.math.biginger；
导入java.util.array；
公共类FibonacciNumbersB{
静态BigInteger[]dp=新的BigInteger[10000]；
公共静态void main（字符串[]args）{
fill（dp，biginger.ZERO）；
dp[0]=BigInteger.1；
dp[1]=BigInteger.1；
对于（int i=4；i<9999；i++）
System.out.println（fibRecurse（i.toString（））；
}
公共静态BigInteger光纤通道（int N）{
for（int i=2；i

在

fibRecurse

方法中，我有一个语句检查

dp[I]

是否等于

0

（尽管

fibRecurse

不是递归的）

检查是否已经计算了

dp[i]

，还是让

dp[i]

等于前两个元素的总和更有效？

import java.math.biginger；
import java.math.BigInteger;
import java.util.Arrays;

public class FibonacciNumbersB {

    static BigInteger[] dp = new BigInteger[10000];

    public static void main(String[] args) {
        dp[0] = BigInteger.ONE;
        dp[1] = BigInteger.ONE;
        int N = 9999;
         fibRecurse(N);
        for(int i = 0; i < N; i++)
            System.out.println(dp[i].toString()) ;
    }

    public static void fibRecurse(int N) {
        for(int i = 2; i < N; i++) {

                dp[i] = dp[i - 1].add(dp[i - 2]);
        }
    }
}

导入java.util.array；
公共类FibonacciNumbersB{
静态BigInteger[]dp=新的BigInteger[10000]；
公共静态void main（字符串[]args）{
dp[0]=BigInteger.1；
dp[1]=BigInteger.1；
int N=9999；
纤维状（N）；
对于（int i=0；i

在执行此备忘录时，我更喜欢

映射，而不是使用固定的
biginger[]
。请注意，您当前的方法不是递归的。
Map
可以像这样声明和初始化

static Map<Integer, BigInteger> memo = new HashMap<>();
static {
    memo.put(0, BigInteger.ONE);
    memo.put(1, BigInteger.ONE);
}

没有备忘录的版本会简单地省略
memo
like

public static BigInteger fibRecurseSlow(int n) {
    if (n == 0 || n == 1) return BigInteger.ONE;
    BigInteger v = fibRecurse(n - 1).add(fibRecurse(n - 2));
    return v;
}

我想你可以从我选择的方法名称中推断出较慢。
 < P>查找Fibonacci序列的代码可以很容易地编写。让我们考虑递归代码来找到斐波那契数集。

import java.util.Scanner;

class fac{
  public static void main(String a[]){

    Scanner sc=new Scanner(System.in);
    System.out.print("Enter Your number :");
    int n=sc.nextInt();

    System.out.print(fibonacci(n));
}   

public static int fibonacci(int x){
    if(x<2){
        return 1;
    }
    else{
        return (fibonacci(x-1)+fibonacci(x-2));
    }
}

import java.util.Scanner；
类fac{
公共静态void main（字符串a[]{
扫描仪sc=新的扫描仪（System.in）；
System.out.print（“输入您的号码：”）；
int n=sc.nextInt（）；
系统输出打印（斐波那契（n））；
}   
公共静态整数fibonacci（整数x）{
如果（xIs）检查null或重新计算dp[i]是否更有效？@ElliottFrischBenchmark你的代码。但这不是递归算法，你的记忆也不会有帮助。也许我不理解你的问题，但首先检查值会比总是重新计算更有效——至少对于大的输入。这不是动态编程的全部意义吗？@Chris Oh我明白了。谢谢你的帮助你的回答-这就是我想要的。没问题。动态规划与其他一些“算法类型”非常相似。我认为它有点像分而治之，但你保存了“子问题”希望这有助于比特完美，这是有意义的。我一直认为使用映射不会是O（1）查找。这不比上面的方法慢吗？时间复杂度与@Elliott Frisch答案相同，即O（n）但是对于大量调用，您必须重复计算，而@Elliot Frisch则不必重复计算。在函数fibRecurse（N）之后，我已经计算了从1到N的所有值，并将它们保存到数组中。您是否仍要反复计算总和？
import java.util.Scanner;

class fac{
  public static void main(String a[]){

    Scanner sc=new Scanner(System.in);
    System.out.print("Enter Your number :");
    int n=sc.nextInt();

    System.out.print(fibonacci(n));
}   

public static int fibonacci(int x){
    if(x<2){
        return 1;
    }
    else{
        return (fibonacci(x-1)+fibonacci(x-2));
    }
}

 import java.util.Scanner;

 class fab{
   public static void main(String a[]){

    Scanner sc=new Scanner(System.in);
    System.out.print("Enter Your number :");
    int n=sc.nextInt();

    int[] lookUp=new int[n];        
    int i;

    for(i=0;i<n;i++){
        lookUp[i]=-1;
    }
    fibonachi(n);   
}
public static void fibonachi(int x){
    if(lookUp[x]==-1){
        if(x<=1){
            lookUp[x]=x;
        }
        else{
            lookUp[x]=fibonachi(x-1)+fibonachi(x-2);
        }
    }
    System.out.print(lookUp[x]);
}   

import java.util.Scanner;

class fac{
  public static void main(String a[]){

    Scanner sc=new Scanner(System.in);
    System.out.print("Enter Your number :");
    int n=sc.nextInt();

    int[] lookUp=new int[n];        
    int i;

    lookUp[0]=1; // store base case values in the 'lookUp' table
    lookUp[1]=1;

    for(i=2;i<n;i++){
        lookUp[i]=lookUp[i-1]+lookUp[i-2];
    }
    System.out.print(lookUp[n-1]);
  }