替代 long 以避免溢出斐波那契数

Question

Stackoverflow 的新手，所以请指出我可以做些什么来提高我的问题的质量。

所以我的代码所做的（或者更确切地说希望做的）是计算巨大的斐波那契数以一个非常大的 m 为模。为了使算法更高效，我使用了pisano periods。本质上，我计算了 m 的 pisano 周期，然后通过使用以下关系使余数的计算更容易：

第n个斐波那契数的余数（模m）等于第k个斐波那契数的余数（模m) 使得 k = n % p 其中 p 是 pisano 周期m.

为了计算皮萨诺周期，我使用以下属性：

如果当前的Fib % m = 0，并且到目前为止所有Fib的总和 % m = 0，那么当前Fib的索引是pisano周期米。 （注意索引必须大于0）

但是我在这项工作中遇到了一个问题：要计算 pisano 周期，我必须计算连续的斐波那契数。当必须计算的斐波那契数的数量变得非常大（例如 100 000）时，就会出现问题。然后数据类型 long 溢出。

据我所知，任何计算 pisano 周期的努力都需要计算斐波那契，因此唯一的解决方案似乎是将 long 替换为其他东西。如果有人对这个替代品有任何建议，我将不胜感激。

import java.util.*;

public class FibHuge {
    public static void main (String [] args) {
        Scanner in = new Scanner (System.in);
        long num = in.nextLong ();
        long mod = in.nextLong();

        System.out.println ( getMod(num, mod));
    }

    private static int getMod (long num, long mod) {
        Period per = new Period();

        long period = per.getPeriod (mod);
        int newFibNum = (int)(num % period);

        num = (num % mod);

        Integer ia[] = new Integer [per.al.size()];
        ia = per.al.toArray (ia);

        return ia[newFibNum];
    }
}

class Period {

    ArrayList <Long> al;
    long FNum;
    long SNum;

    Period () {
        al = new ArrayList <Long> ();
        FNum = 0;
        SNum = 1;
    }

    private long getFib (long first, long second){
        return first + second;
    }

    long getPeriod (long mod){
        boolean bool = true;
        long fibcount = 0;

        long currentmod = 0;
        long fib = 0;
        long sum = 0;

        while (bool){
            if (fibcount <= 1){
                currentmod = fibcount % mod;

                al.add (currentmod);

                sum += fibcount;
            }

            else {
                fib = getFib (FNum, SNum);
                FNum = SNum;
                SNum = fib;

                currentmod = (fib % mod);
                al.add (currentmod);

                sum += fib;
            }

            if ( (currentmod == 0 & (sum % mod) == 0) & fibcount > 0){
                return fibcount;
            }
            fibcount++;
        }

        return mod; //essentially just to satisfy the return condition
    }
}

Answer 1

使用BigInteger，但请注意它会慢得多，但大小无限。

Answer 2

除非您的模数太大而无法放入 long，否则您不需要使用 BigInteger，在这种情况下，我怀疑您在寻找解决方案时会耗尽内存。

您可以使用此属性在取模后计算第 n 个斐波那契数，而不是计算第 n 个斐波那契数然后再进行取模

(a + b) % n = (a % n + b % n) % n;

换句话说，您只需要在每次迭代中不断添加数字的模数。您可以将所有模数值保存在 Set 中，当您获得重复结果时，您有一个句点。您可以将迭代次数与结果一起存储，并使用它来计算周期。

事实上，模数有点贵，但因为你只会对小于 2 * 模数的数字求和，所以你可以简单地做

long c = a + b; // Fibonacci
if (c >= modulus) c -= modulus; // the only real change you need for modulus.

由于 Java 使用条件移动而不是实际分支，这比使用 % 快​​得多

如果不为您编写代码，我想不出您需要了解的更多细节。