[Codeforces]906D Power Tower

　　虽说是一道裸题，但还是让小C学到了一点姿势的。

Description

　　给定一个长度为n的数组w，模数m和询问次数q，每次询问给定l,r，求：

　　对m取模的值。

Input

　　第一行两个整数n,m，表示数组长度和模数。
　　接下来一行n个数，表示w数组。
　　接下来一行一个整数q，表示询问次数。
　　接下来q行，每行两个整数l,r，表示一次询问。

Output

　　对于每次询问，输出一行一个整数表示答案。

Sample Input

　　6 1000000000
　　1 2 2 3 3 3
　　8
　　1 1
　　1 6
　　2 2
　　2 3
　　2 4
　　4 4
　　4 5
　　4 6

Sample Output

　　1
　　1
　　2
　　4
　　256
　　3
　　27
　　597484987

HINT

　　1 ≤ n ≤ 10⁵，1 ≤ m ≤ 10⁹，1 ≤ w_i ≤ 10⁹，1 ≤ q ≤ 10⁵，1 ≤ l ≤ r ≤ n。

Solution

　　看到这么清奇的式子，你大概会第一时间想到降幂大法吧？

　　先说说扩展欧拉定理，对于任意正整数a,b,p：

　　所以假设堆叠的幂次足够大，那么式子就可以转化为：

　　已知p经过至多2log次phi就会变成1。

　　所以递归求解，至多走到2log层模数就会变成1，所以返回0就行。

　　所以这道题就非常显然了，首先预处理出m的所有phi，对于每个询问，从l开始直接递归暴力，直到模数为1时返回。

　　还有一个问题，在求a^b%p的时候，怎么比较b和phi(p)的大小呢？

　　一种思路就是暴力计算a的后log项的值，注意还要特判1的情况，但这样写起来确实麻烦。

　　当然，有一种非常精妙的取模写法：

int modulo(ll x,int mod) {return x<mod?x:x%mod+mod;}

　　这是在做什么呢？这就是在比较b和phi(p)的大小，如果b<phi(p)，返回b；否则返回b%phi(p)+phi(p)。

　　然后原式就变成了这样：

　　这样做看上去漏洞百出，可能的情况是，原本我们要计算，其中大等于。

　　然而我们计算，将取模后，却发现小于了。

　　是否有这种可能呢？

　　其实就相当于判断是否有可能成立，我们可以发现，当a>2时式子是不可能成立的。

　　所以我们来看一看是否有可能成立。

　　有可能。

　　当且仅当p=6时，不等式成立。

　　然而6有什么特殊的性质呢？

　　我们发现phi(x)=6只有三个解：x=7，x=9或x=18。

　　所以接下来我们只要证明和即和在对x取模的意义下相等即可。（其中phi(x)=6）

　　若a为x的倍数，显然它们对x取模都等于0，对于答案无影响。

　　当x=7时，，所以；

　　当x=9时，若，则影响同上；

　　　　　　若，一定有，所以一定有，

　　　　　　　　　　　　　所以一定有，对于答案是没有影响的；

　　当x=18时，若或，则影响同上；

　　　　　　　我们有一个显然的结论：同余方程的解为

　　　　　　　若，则，则，则

　　　　　　　若，则且，则，则

　　所以综上，我们就证明了该算法的正确性。

　　时间复杂度。

#include <cstdio>

#include <cstring>

#include <algorithm>

#define ll long long

#define MN 100005

using namespace std;

int a[MN],mod[MN];

int n,p;

bool fg;

inline int read()

{

    int n=,f=; char c=getchar();

    while (c<'' || c>'') {if(c=='-')f=-; c=getchar();}

    while (c>='' && c<='') {n=n*+c-''; c=getchar();}

    return n*f;

}

inline int pro(ll x,int md) {return x<md?x:x%md+md;}

inline int mi(int x,int y,int md)

{

    register int z=;

    for (;y;x=pro(1LL*x*x,md),y>>=)

        if (y&) z=pro(1LL*z*x,md);

    return z;

}

int dfs(int x,int y,int lim)

{

    if (x==lim) return a[x]>=mod[y]?a[x]%mod[y]+mod[y]:a[x];

    if (mod[y]==) return ;

    return mi(a[x],dfs(x+,y+,lim),mod[y]);

}

int main()

{

    register int i,j,x,y;

    n=read(); mod[]=read();

    for (i=;mod[i]>;++i)

    {

        mod[i+]=x=mod[i];

        for (j=;j*j<=x;++j)

        {

            for (fg=;x%j==;x/=j,fg=true);

            if (fg) mod[i+]=1LL*mod[i+]*(j-)/j;

        }

        if (x>) mod[i+]=1LL*mod[i+]*(x-)/x;

    }

    for (i=;i<=n;++i) a[i]=read();

    for (p=read();p;--p)

    {

        x=read(); y=read();

        printf("%d\n",dfs(x,,y)%mod[]);

    }

}

Last Word

　　打Codeforces的时候正纳闷这种情况该怎么处理，却发现大佬们清一色都是这么写的。

　　小C觉得自己的证明蠢得不行啊……

　　如果读者有更直观的证明该算法的正确性的方法请务必告诉小C。