对于玩具程序,我需要一种有效的计算方式
(2**64 * x) % m
其中 x
和 m
是 java long
,**
表示求幂。这可以计算为
BigInteger.valueOf(x).shiftLeft(64).mod(BigInteger.valueOf(m)).longValue()
或者反复将 x
向左移动并减少,但两者都非常慢。这不是过早的优化。
说明
‣ 任何使用 BigInteger
的算法都可能比上面的表达式慢。
‣ 你可以假设 m
对于 int
来说太大了,否则
long n = (1L<<32) % m;
return ((n*n) % m) * (x % m)) % m
会做。
‣ 慢移和归约算法是这样的
// assuming x >= 0
long shift32Left(long x, long m) {
long result = x % m;
for (int i=0; i<64; ++i) {
x <<= 1;
// here, `x<0` handles overflow
if (x<0 || x>=m) {
x -= m;
}
}
}
最佳答案
一般形式:
(a1 * a2 * a3 ... * an) % m = [(a1 % m) * (a2 % m) * ... * (a3 % m) ] % m
应用上面的公式,我们有:
(2^64 * x) % m = (((2^64) % m) * (x % m)) % m
对于第一部分:2^64 mod m
。我可以做更一般的情况:2^t mod m
。我有这个伪代码。 In 将运行 N(log t)
次。这个伪代码只是为了 t 和 m 是正常的整数。根据 t 和 m 的范围,您可以固定内部函数计算以在合适的点使用 BigInteger。
long solve(long t, long m) {
if (t == 0) return 1 % m;
if (t == 1) return t % m;
long res = solve(t/2, m);
res = (res * res) % m;
if (t % 2 == 1) res = (res * 2) % m;
return res;
}
感谢 OldCurmudgeon。上面的代码可以是一行简单的代码:
BigInteger res = (new BigInteger("2")).
modPow(new BigInteger("64"), new BigInteger("" + m));
这里是 modPow
的实现。此实现使用不同的方法。算法从 m 开始:将 m 分解为 m = 2^k*q
。然后求2^k和q的模然后用Chinese Reminder theorem
合并结果。
public BigInteger modPow(BigInteger exponent, BigInteger m) {
if (m.signum <= 0)
throw new ArithmeticException("BigInteger: modulus not positive");
// Trivial cases
if (exponent.signum == 0)
return (m.equals(ONE) ? ZERO : ONE);
if (this.equals(ONE))
return (m.equals(ONE) ? ZERO : ONE);
if (this.equals(ZERO) && exponent.signum >= 0)
return ZERO;
if (this.equals(negConst[1]) && (!exponent.testBit(0)))
return (m.equals(ONE) ? ZERO : ONE);
boolean invertResult;
if ((invertResult = (exponent.signum < 0)))
exponent = exponent.negate();
BigInteger base = (this.signum < 0 || this.compareTo(m) >= 0
? this.mod(m) : this);
BigInteger result;
if (m.testBit(0)) { // odd modulus
result = base.oddModPow(exponent, m);
} else {
/*
* Even modulus. Tear it into an "odd part" (m1) and power of two
* (m2), exponentiate mod m1, manually exponentiate mod m2, and
* use Chinese Remainder Theorem to combine results.
*/
// Tear m apart into odd part (m1) and power of 2 (m2)
int p = m.getLowestSetBit(); // Max pow of 2 that divides m
BigInteger m1 = m.shiftRight(p); // m/2**p
BigInteger m2 = ONE.shiftLeft(p); // 2**p
// Calculate new base from m1
BigInteger base2 = (this.signum < 0 || this.compareTo(m1) >= 0
? this.mod(m1) : this);
// Caculate (base ** exponent) mod m1.
BigInteger a1 = (m1.equals(ONE) ? ZERO :
base2.oddModPow(exponent, m1));
// Calculate (this ** exponent) mod m2
BigInteger a2 = base.modPow2(exponent, p);
// Combine results using Chinese Remainder Theorem
BigInteger y1 = m2.modInverse(m1);
BigInteger y2 = m1.modInverse(m2);
if (m.mag.length < MAX_MAG_LENGTH / 2) {
result = a1.multiply(m2).multiply(y1).add(a2.multiply(m1).multiply(y2)).mod(m);
} else {
MutableBigInteger t1 = new MutableBigInteger();
new MutableBigInteger(a1.multiply(m2)).multiply(new MutableBigInteger(y1), t1);
MutableBigInteger t2 = new MutableBigInteger();
new MutableBigInteger(a2.multiply(m1)).multiply(new MutableBigInteger(y2), t2);
t1.add(t2);
MutableBigInteger q = new MutableBigInteger();
result = t1.divide(new MutableBigInteger(m), q).toBigInteger();
}
}
return (invertResult ? result.modInverse(m) : result);
}
对于第二部分:您可以轻松地使用 BigInteger
或简单地进行普通计算,具体取决于 x 和 m 的范围。
关于java - 大数的模块化归约,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/31158366/