Java逆模2**64

给定一个奇数的

长x

，我要寻找

长y

，这样它们的乘积模

2**64

（即使用正常溢出算法）等于1。为了明确我的意思：这可以用几千年的时间来计算：

for (long y=1; ; y+=2) {
    if (x*y == 1) return y;
}

---

我知道使用扩展的欧几里德算法可以很快解决这个问题，但它需要能够表示所有涉及的数字（范围可达

2**64

，因此即使是无符号算术也无济于事）。使用BigInteger肯定会有帮助，但我想知道是否有更简单的方法，可能是使用扩展的欧几里德算法实现正长。

这里有一种方法。这使用扩展的欧几里德算法来查找模262的倒数

abs（x）

public static long longInverse(long x) {

    if (x % 2 == 0) { throw new RuntimeException("must be odd"); }

    long power = 1L << 62;

    long a = Math.abs(x);
    long b = power;
    long sign = (x < 0) ? -1 : 1;

    long c1 = 1;
    long d1 = 0;
    long c2 = 0;
    long d2 = 1;

    // Loop invariants:
    // c1 * abs(x) + d1 * 2^62 = a
    // c2 * abs(x) + d2 * 2^62 = b 

    while (b > 0) {
        long q = a / b;
        long r = a % b;
        // r = a - qb.

        long c3 = c1 - q*c2;
        long d3 = d1 - q*d2;

        // Now c3 * abs(x) + d3 * 2^62 = r, with 0 <= r < b.

        c1 = c2;
        d1 = d2;
        c2 = c3;
        d2 = d3;
        a = b;
        b = r;
    }

    if (a != 1) { throw new RuntimeException("gcd not 1 !"); }

    // Extend from modulo 2^62 to modulo 2^64, and incorporate sign change
    // if necessary.
    for (int i = 0; i < 4; ++i) {
        long possinv = sign * (c1 + (i * power));
        if (possinv * x == 1L) { return possinv; }
    }

    throw new RuntimeException("failed");
}

公共静态长纵向反转（长x）{
如果（x%2==0）{抛出新的RuntimeException（“必须是奇数”）；}
长功率=1L（0）{
长q=a/b；
长r=a%b；
//r=a-qb。
长c3=c1-q*c2；
长d3=d1-q*d2；
//现在c3*abs（x）+d3*2^62=r，0同时，我回顾/重新发明了一个非常简单的解决方案：

public static int inverseOf(int x) {
    Preconditions.checkArgument((x&1)!=0, "Only odd numbers have an inverse, got " + x);
    int y = 1;
    for (int mask=2; mask!=0; mask<<=1) {
        final int product = x * y;
        final int delta = product & mask;
        y |= delta;
    }
    return y;
}

publicstaticintinverseof（intx）{
先决条件。checkArgument（（x&1）！=0，“只有奇数才有倒数，得到”+x）；
int y=1；
对于（int mask=2；mask！=0；maskHacker's delivery）mod 2^32的算法。当然，我会尝试它的一些变体，尽管我会进行大量测试。（也许这值得包含在番石榴中…@Louis Wasserman:很好的链接…同时，我想我得到了快3倍的东西——我稍后会发布我的结果。顺便说一句，我需要
pow（long，long）
（从
LongMath
中缺失）作为一种方法。
pow（long，long）
是故意缺失的，因为将任何不适合
int
的东西带到电源中，基本上保证会溢出（尽管我想这就是你的情况。）是的。对于像
checkedPow
或
saturatedPow
这样的事情，我同意长指数没有意义，因为
pow
我没有。我发表了6种不同的解决方案。关于番石榴，我建议包括链接数学64中的内容。我们最终的规则是，我们假设您不想故意这么做造成溢出。
pow
和
checkedPow
之间的区别不是它是否会溢出，而是你是否愿意支付检查的开销。+1有趣的答案。我认为你提到的
n
的值是
2**62
@Luke Woodward：使用我得到的
2**63
，但它看起来很有趣s也可以使用
2**62
。这似乎是最快的方法。我已经接受了你的解决方案，因为你对我的评论导致了最快的解决方案，请参阅。