Java 求n^k模10^7+的值；7.

给出int n和k。求n^k模10^7+7的值。
我一直试图用不同的方法来解决这个问题，使用模的性质为（a*b）%c=（（a%c）*（b%c））%c。下面是我的代码。另外，我是一个新用户，如果我错过了什么，请让我知道

int res = 1;
int modulo = (int) Math.pow(10,7)+7;
//( a * b) % c = ( ( a % c ) * ( b % c ) ) % c
System.out.println(modulo);
for (int i = 1 ; i <= k; i++){
    res = ((res%modulo)*(n%modulo))%modulo;

}

return res;

int res=1；
整数模=（整数）数学功率（10,7）+7；
//（a*b）%c=（（a%c）*（b%c））%c
系统输出println（模）；
对于（inti=1；i这是最简单的。你可以用它来检查你的其他答案

        System.out.println(fnc(282828,292929));
        System.out.println(yours(282828,292929));


    public static BigInteger fnc(int n, int k) {

        int modulo = (int) Math.pow(10, 7) + 7;
        BigInteger res = BigInteger.valueOf(n).pow(k)
                .mod(BigInteger.valueOf(modulo));
        return res;
    }


这是您的解决方案。您只需要使用
long的

    public static long yours(long n, long k) {
        long res = 1;
        int modulo = (int) Math.pow(10, 7) + 7;
        // ( a * b) % c = ( ( a % c ) * ( b % c ) ) % c

        // pull out n % modulo since n never changes.
        long nmod = n% modulo;
        long res = nmod%modulo;
        for (int i = 1; i < k; i++) {
            res = ((res% modulo)*(nmod))%modulo;
        }
        return res;
    }

轻微的优化


拉出n%模

作为

nmod

。只需计算一次

由于

1%模

是第一次通过

1

，只需将

res

初始化为

nmod%模

。然后只需迭代到

i

次

---

下面的两个解决方案都以O（log k）运行，这与问题中的代码（O（k））和使用

biginger

不同。当

k

为6位时，WJS的代码开始变慢。即使

k

为

Long.MAX\u值，下面的两个解决方案也会立即返回


在这个答案的描述中，
a^b
表示幂运算，而不是按位异或运算

你在正确的道路上使用

(a * b) % c = ((a % c) * (b % c)) % c

你缺少的是

a ^ (b + c) = (a ^ b) * (a ^ c)

递归解
由于目标是计算
（n^k）%（10^7+7）
，因此可以通过递归拆分
k
在O（logk）时间内计算此值

例如，如果
k=15
，则按如下方式拆分

n^15  =  n^8 * n^7
      =  (n^4 * n^4) * (n^4 * n^3)
      =  ...

用模表示

(n^15) % m  =  ((n^8) % m * (n^7) % m) % m
            =  ...

如果您创建了计算
（n^k）%m的方法

int calc(int n, int k, int m)

然后使用
k=15
，
calc（n，15，m）
递归调用
calc（n，8，m）
和
calc（n，7，m）
。使用记忆，结果的时间复杂度为O（logk）

public static int calc(int n, long k) {
    if (n < 0 || k < 0)
        throw new IllegalArgumentException();
    if (n == 0)
        return 0;
    if (k == 0)
        return 1;
    return calc0(n, k, new HashMap<>());
}

private static int calc0(int n, long k, Map<Integer, Integer> cache) {
    Integer cachedValue = cache.get(k);
    if (cachedValue != null)
        return cachedValue;
    int result;
    if (k == 1)
        result = n % MODULO;
    else
        result = (int) ((long) calc0(n, k / 2, cache) * calc0(n, k - k / 2, cache) % MODULO);
    cache.put(k, result);
    return result;
}
private static final int MODULO = 10000007;

输出

6154601
5111924
5910478
问题是什么？如果您对该代码没有问题，但只要求反馈，则该问题与Stackoverflow无关，但欢迎您提出。对不起，我没有包括返回int结果的条件。感谢您抽出时间。您只需将结果转换为
int
。谢谢你的解决方案很好，而且解释得很清楚。
public static int calc(int n, long k) {
    if (n < 0 || k < 0)
        throw new IllegalArgumentException();
    if (n == 0)
        return 0;
    if (k == 0)
        return 1;
    return calc0(n, k, new HashMap<>());
}

private static int calc0(int n, long k, Map<Integer, Integer> cache) {
    Integer cachedValue = cache.get(k);
    if (cachedValue != null)
        return cachedValue;
    int result;
    if (k == 1)
        result = n % MODULO;
    else
        result = (int) ((long) calc0(n, k / 2, cache) * calc0(n, k - k / 2, cache) % MODULO);
    cache.put(k, result);
    return result;
}
private static final int MODULO = 10000007;

public static int calc(int n, long k) {
    if (n < 0 || k < 0)
        throw new IllegalArgumentException();
    int e = n % MODULO;
    int r = ((k & 1) != 0 ? e : 1);
    for (long i = k >>> 1; i != 0; i >>>= 1) {
        e = (int) ((long) e * e % MODULO);
        if ((i & 1) != 0)
            r = (int) ((long) r * e % MODULO);
    }
    return r;
}
private static final int MODULO = 10000007;

System.out.println(calc(282828,292929));
System.out.println(calc(123456789,987654321));
System.out.println(calc(Integer.MAX_VALUE, Long.MAX_VALUE));