Algorithm o（logn）解决方案的方法和代码

f（N）=0^0+1^1+2^2+3^3+4^4+…+N^N

我想计算（f（N）mod M）

这些是制约因素

• 一,≤ N≤ 10^9
• 一,≤ M≤ 10^3

这是我的密码

test=int(input())
ans = 0

for cases in range(test):
    arr=[int(x) for x in input().split()]
    N=arr[0]
    mod=arr[1]

    #ret=sum([int(y**y) for y in range(N+1)])
    #ans=ret

    for i in range(1,N+1):
        ans = (ans + pow(i,i,mod))%mod
    print (ans)

我尝试了另一种方法，但没有成功。 下面是代码

from functools import reduce
test=int(input())
answer=0
for cases in range(test):
    arr=[int(x) for x in input().split()]
    N=arr[0]
    mod=arr[1]

    answer = reduce(lambda K,N: x+pow(N,N), range(1,N+1)) % M

    print(answer)

---

为什么不使用简单的递归来求幂的递归和呢

def find_powersum(s):
    if s == 1 or s== 0:
        return 1
    else:
       return s*s + find_powersum(s-1)  

def find_mod (s, m):   
   print(find_powersum(s) % m)

find_mod(4, 4)
2

两项建议：

让

0^0=1

成为您所使用的。这似乎是我对如何处理这个问题的最佳指导

计算

k^k

，方法是在计算过程中乘以并取模

在进行任何其他操作之前，先进行一次初始传递，将所有

k

（非指数）更改为

k mod M

在计算

（k mod M）^k

时，如果中间结果是您已经访问过的结果，则您可以减少迭代次数，以继续进行所有迭代，但最多可以再进行一个循环

示例：设N=5，M=3。我们要计算0^0+1^1+2^2+3^3+4^4+5^5（mod 3）

首先，我们采用建议3。现在我们要计算0^0+1^1+2^2+0^3+1^4+2^5（mod 3）

接下来，我们开始评估并立即使用建议1，以获得1+1+2^2+0^3+1^4+2^5（mod 3）。2^2是4=1（mod 3），我们需要注意（2^2=1（mod 3））。接下来，我们发现0^1=0，0^2=0，所以我们有一个大小为1的循环，这意味着不需要进一步的乘法来告诉0^3=0（mod 3）。注意。1^4的类似过程（我们在第二次迭代中告诉我们有一个大小为1的循环，所以1^4是1，我们注意到了）。最后，我们得到了2^1=2（mod 3），2^2=1（mod 3），2^3=2（mod 3），一个长度为2的循环，因此我们可以跳过一个偶数，这个偶数会排出2^5，不需要再次检查，我们就知道2^5=2（mod 3）

我们的总和现在是1+1+1+0+1+2（模3）=2+1+0+1+2（模3）=0+0+1+2（模3）=0+1+2（模3）=1+2（模3）=0（模3）

这些规则将对您有所帮助，因为您的案例中N比M大得多。如果相反，如果N比M小得多，您将无法从我的方法中获益（取模数w.r.t.M对结果的影响较小）

伪代码：

Compute(N, M)
1. sum = 0
2. for i = 0 to N do
3.    term = SelfPower(i, M)
4.    sum = (sum + term) % M
5. return sum

SelfPower(k, M)
1. selfPower = 1
2. iterations = new HashTable
3. for i = 1 to k do
4.    selfPower = (selfPower * (k % M)) % M
5.    if iterations[selfPower] is defined
6.        i = k - (k - i) % (i - iterations[selfPower])
7.        clear out iterations
8.    else iterations[selfPower] = i
9. return selfPower

执行示例：

resul = Compute(5, 3)
    sum = 0
    i = 0
        term = SelfPower(0, 3)
            selfPower = 1
            iterations = []
            // does not enter loop
            return 1
        sum = (0 + 1) % 3 = 1
    i = 1
        term = SelfPower(1, 3)
            selfPower = 1
            iterations = []
            i = 1
                selfPower = (1 * 1 % 3) % 3 = 1
                iterations[1] is not defined
                    iterations[1] = 1
            return 1
        sum = (1 + 1) % 3 = 2
    i = 2
        term = SelfPower(2, 3)
            selfPower = 1
            iterations = []
            i = 1
                selfPower = (1 * 2 % 3) % 3 = 2
                iterations[2] is not defined
                    iterations[2] = 1
            i = 2
                selfPower = (2 * 2 % 3) % 3 = 1
                iterations[1] is not defined
                    iterations[1] = 2
            return 1
        sum = (2 + 1) % 3 = 0
    i = 3
        term = SelfPower(3, 3)
            selfPower = 1
            iterations = []
            i = 1
                selfPower = (1 * 3 % 0) % 3 = 0
                iterations[0] is not defined
                    iterations[0] = 1
            i = 2
                selfPower = (0 * 3 % 0) % 3 = 0
                iterations[0] is defined as 1
                    i = 3 - (3 - 2) % (2 - 1) = 3
                    iterations is blank
            return 0
        sum = (0 + 0) % 3 = 0
    i = 4
        term = SelfPower(4, 3)
            selfPower = 1
            iterations = []
            i = 1
                selfPower = (1 * 4 % 3) % 3 = 1
                iterations[1] is not defined
                    iterations[1] = 1
            i = 2
                selfPower = (1 * 4 % 3) % 3 = 1
                iterations[1] is defined as 1
                    i = 4 - (4 - 2) % (2 - 1) = 4
                    iterations is blank
            return 1
        sum = (0 + 1) % 3 = 1
    i = 5
        term = SelfPower(5, 3)
            selfPower = 1
            iterations = []
            i = 1
                selfPower = (1 * 5 % 3) % 3 = 2
                iterations[2] is not defined
                    iterations[2] = 1
            i = 2
                selfPower = (2 * 5 % 3) % 3 = 1
                iterations[1] is not defined
                    iterations[1] = 2
            i = 3
                selfPower = (1 * 5 % 3) % 3 = 2
                iterations[2] is defined as 1
                    i = 5 - (5 - 3) % (3 - 1) = 5
                    iterations is blank
            return 2
        sum = (1 + 2) % 3 = 0
    return 0

---

pow（i，i，mod）

做什么？你想计算

0^0+1^1+…+N^N

模

M

？@alfasin pow（x，y[，z]）将x返回到y的幂；如果存在z，则将x返回到幂y，模z（计算效率高于pow（x，y）%z）。双参数形式pow（x，y）相当于使用幂运算符：x**y.Yes，@Patrick87。但这不是您描述的您想要做的。。。在你写的问题中，你想对所有

0^0+1^1+2^2+3^3+4^4+…+求和N^N

然后才计算模（一次）。通过执行

（ans+pow（i，i，mod））%mod

可以取模两次（这不重要，但仍然是多余的），这意味着您可以为函数Simple recursion中的每一项计算模。1@Akashdeep Jassal您正在使用的IDE或编译器

m

不一定等于

n

在最坏的情况下，

m

是素数，在计算

m

项之前，您不会遇到“循环”（然后根据鸽子洞原理，您一定会遇到一个）。不过，如果

N>>M

，这还是一个合理的成本节约。另一个节省是在

N>>M

的情况下智能地计算出类似的碱基，并与类似的碱基共享中间结果。同样，如果

M>>N

，则不可能有任何重要的技巧，因为这与模数无关。谢谢。我将实施你的方法。