Question

我正在学习动态编程和Fibonacci序列的应用，并有一个问题。以下是供参考的代码：

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

我会在dp[i]方法中检查0是否等于fibRecurse（尽管fibRecurse不是递归的）。

检查是否已经计算dp[i]或仅让dp[i]等于前两个元素的总和是否更有效？

Answer 1

执行此 memoization 时，我希望Map<Integer, BigInteger>使用固定的BigInteger[]。请注意，您当前的方法是递归。 Map可能会被声明并初始化为

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

然后检查n中是否存在当前memo（如果是，请将其返回） - 否则，请计算并存储它。像，

public static BigInteger fibRecurse(int n) {
    if (memo.containsKey(n)) {
        return memo.get(n);
    }
    BigInteger v = fibRecurse(n - 1).add(fibRecurse(n - 2));
    memo.put(n, v);
    return v;
}

没有 memoization 的版本只会忽略memo

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

我认为你可以从我选择的方法名称推断这个名称更慢。

Answer 2

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

Answer 3

查找斐波那契数列的代码很容易编写，让我们考虑一下查找斐波那契数集的递归代码。

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

}

在此阶段，有许多相同的子问题一次又一次地计算出来，因此在这种情况下，大输入量的时间复杂度达到了极限。因此，出现了动态编程技术。在动态编程中，维护了一个额外的表（“ lookUp”表）以存储先前计算的子问题的值。在计算下一个子问题的值之前，请检查创建的表（“ lookUp”表）中特定子问题的答案是否可用。如果在“ lookUp表”中，请获取特定子问题的答案。如果它不在“ lookUp”表中，则计算特定问题的值并存储“ lookUp”表。这就是动态编程技术的含义。执行此技术有两种方法。

1。记忆- 记忆是一种从上到下的方式计算子问题的值的技术。让我们考虑斐波那契数列的代码。

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

}

2。制表法-此计算从下到上进行。首先考虑基本情况并执行。然后使用先前的情况执行下一步。Les考虑采用制表技术的斐波那契数列代码。

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

}

在这种情况下，首先存储基本情况值，然后使用先前的值计算下一个值。在制表中，必须计算所有值，因为使用先前的vlues计算的新值。所以记忆比制表要好。。希望您能有所想法。谢谢！

动态规划Fibonacci序列

3 个答案: