第十四届蓝桥杯国赛：2023次方的思考（指数塔，数论）

首先我们要知道，正常计算的话，指数优先级最高，因此得先计算指数，比如：
$$2^{3^2}=512$$
欧拉定理的关键在于，它允许我们通过减少计算的指数大小来简化模运算。

1、无脑的想法：

指数模+快速幂（错的）

#include <iostream>
using namespace std;
int main()
{
    int result = 2023;//result 存储 指数
    for(int i = 2022;i >= 2; --i){//遍历底数
        int b = result;
        int a = i;
        int ans = 1;
        while(b){
            if((b & 1) == 1){
                ans = (ans * a) % 2023;
            }
            a = (a * a) % 2023;
            b >>= 1;
        }
        result = ans;
    }
    cout << result;//1259
    return 0;
}

指数并不能直接取模！取模只在四则运算里面好用，在指数里面就不太能直接用了。
$2^{10}mod9=1024mod9=7$；$2^{10}mod9\ne 2mod9=2$
可以证明指数不能随便取模。

普通的取模运算只能运用于加减乘除（四则运算） 下面是这些基本算术操作在模运算下的特性：

1. 加法（Addition）:

   • $(a+b)\mathrm{mod}n=[(a\mathrm{mod}n)+(b\mathrm{mod}n)]\mathrm{mod}n$
   • 加法的模运算遵循分配律。

2. 减法（Subtraction）:

   • $(a-b)\mathrm{mod}n=[(a\mathrm{mod}n)-(b\mathrm{mod}n)+n]\mathrm{mod}n$
   • 减法也遵循类似的规则，但要注意结果保持非负。

3. 乘法（Multiplication）:

   • $(a\times b)\mathrm{mod}n=[(a\mathrm{mod}n)\times (b\mathrm{mod}n)]\mathrm{mod}n$
   • 乘法在模运算中同样遵守分配律。

4. 除法（Division）:

   • 除法在模运算中比较复杂。不能直接应用常规除法运算，需要用到乘法逆元。如果存在，$a$ 在模 $n$ 下的乘法逆元 $a^{-1}$ 满足 $a{a}^{-1}\equiv 1\mathrm{mod}n$。然后，$a/b\mathrm{mod}n$ 可以表示为 $a\times b^{-1}\mathrm{mod}n$。

在处理幂运算（如 $a^b\mathrm{mod}n$）时，不能直接对指数 $b$ 应用普通的模运算，除非考虑到适当的数论属性（如欧拉函数 $\varphi (n)$），这是因为幂运算涉及重复的乘法过程，指数的大小直接影响最终结果。因此，在涉及到幂运算时，需要谨慎处理指数的模运算，通常基于 $\varphi (n)$ 来简化指数大小。

---

2、有脑但不够的想法

费马小定理（错的）

• 费马小定理：
  $$费马小定理：a^{p-1}\equiv 1(modp)p是质数,gcd(a,p)=1$$

$如果2023是质数，则a^{2022}\equiv 1(mod2023)$
$如果2023是质数，则a^{2023}\equiv a(mod2023)$
$由于a=b^{2022}，且b^{2022}\equiv 1(mod2023)$
$则有，a^{2023}\equiv a\equiv 1(mod2023)，其中a=2^{3^{4^{(\cdot \cdot \cdot {)}^{2022}}}}$
$因此得结果为1。$

错误！因为2023压根不是质数。
不过我们需要注意的是，如果是按原题来理解：
而且这样做还存在一个问题，你把a看成一个整体考虑问题了，因为你把底数包裹起来了，然后看最顶层的指数，这就相当于$2^{3^2}$，把$2^3$看成一个整体了，这很显然与指数计算的方式相违背！

#include <iostream>
#include <cmath>
using namespace std;
int main()
{
    int f = sqrt(2023);
    for(int i = 2;i <= f;++i){
        if(2023 % i == 0){
            cout << i << " * " << 2023 / i << " = 2023"<<endl;
        }
    }
    return 0;
}

输出：

7 * 289 = 2023
17 * 119 = 2023

---

3、正解

欧拉定理 : 数论基础

• 欧拉定理：
  $$a^{\varphi (n)}\equiv 1(modn),gcd(a,n)=1$$
  令$b=c\varphi (n)+d，则a^b\equiv a^{c\varphi (n)+d}\equiv a^d(modn)$
  因此$a^b\equiv a^{bmod\varphi (n)}(modn)$。

因此使用欧拉定理可以“模”去一部分指数。

因此由于本题的底数是$2$，$2$的任意次幂都和$2023$互质，所以满足欧拉定理。

• 欧拉函数的计算方式：
  
  其中$p_i$是$n$的所有质因数，计算方式应该是$\varphi (n)=n\times {\prod }_{i=1}^S(\frac{p_i-1}{p_i})$。

根据上述不过我们需要注意的是，如果是按原题来理解：
令计算的指数塔是$2^{a}mod2023$，则结果为$2^{amod\varphi (2023)}mod2023$，也就是$2^{amod1632}mod2023$，那么接下来需要知道$amod1632$的大小，但指数塔$a=3^b$，此时计算的指数塔是$3^{b}mod1632$，接下来$bmod\varphi (1632)$。

好好好，这样不一定互质了，所以问题太大了。

正确的解法：

#include<bits/stdc++.h>
using namespace std;
#define int long long

//欧拉函数 
int get_eular(int n){
    int phi=n;
    for(int i=2;i<=n/i;i++){
        if(n%i)    continue;
        while(n%i==0)    n/=i;
        phi=phi/i*(i-1);
    }
    if(n>1)    phi=phi/n*(n-1);
    return phi;
} 

//快速幂
int quick(int base, int x, int mod){
    int res=1;
    while(x){
        if(x&1)    res=res*base%mod;
        base=base*base%mod;
        x>>=1;
    }
    return res;
} 

signed main(){
    int a=get_eular(2023); 
    int t=2023; 
    for(int i=2022;i>=3;i--){
        t=quick(i,t,a);
    };
    t=quick(2,t,2023);
    cout<<t<<endl;    
    return 0;
}

究其原因，我是真没想清楚。