Groundhog Chasing Death 2020牛客多校第九场（质因子分解+欧拉降幂）

原题题面

As we all know,“Groundhog chasing death” means “GCD”,while “GCD” stands for “greatest common divisor”.
So you need to calculate ${\prod }_{i=a}^b{\prod }_{j=c}^d\gcd (x^i,y^j)$ modulo $998244353$

输入格式

One line which contains six intergers $a,b,c,d,x,y$.
$0\le a,b,c,d\le 3e6,a\le b,c\le d,0\le x,y\le 1e9$

输出格式

One line which contains ${\prod }_{i=a}^b{\prod }_{j=c}^d\gcd (x^i,y^j)$ modulo $998244353$

输入样例1

1 2 1 2 8 4

输出样例1

2048

输入样例2

1 2 3 4 120 180

输出样例2

235140177

题面分析

第一眼以为是莫反就屁颠屁颠地化式子去了，果然画不出来
首先我们给出gcd的另一种定义，
对于$a={\prod }_{i=1}^m{p}_i^{x_i},b={\prod }_{i=1}^n{p}_i^{y_i}$
$gcd(a,b)={\prod }_{i=1}^{min(m,n)}{p}_i^{min(x_i,y_i)}$
证明略，稍加理解即可。
那我们可以考虑去计算每个质因子$p_i$对答案的贡献。
把原式的$x,y$质因子分解后，对于某一个质因子$p$，设$x$对应的次数为$k_1$,$y$对应的次数为$k_2$
那么$p_i$的贡献就是$p_i^{{\sum }_{i=1}^b{\sum }_{j=c}^{d}min(k_{1}i,k_{2}j)}$
对于${\sum }_{i=1}^b{\sum }_{j=c}^{d}min(k_{1}i,k_{2}j)$
根据$min$的取值不同，我们分成两种情况。
①$k_{1}i\le k_{2}j$
此时可以得到$j\ge \frac{k_1}{k_2}i$，所以这部分求和的结果是${\sum }_{i=a}^b{\sum }_{j=max(c,\lceil \frac{k_1}{k2}i\rceil )}^d{k}_{1}i$
化简得$k_1{\sum }_{i=a}^{b}i\ast [d-max(c,\lceil \frac{k_1}{k_2}i\rceil )+1]$
②$k_{1}i>k_{2}j$
此时可以得到$i>\frac{k_2}{k_1}j$，所以这部分求和的结果是${\sum }_{j=c}^d{\sum }_{i=max(a,\lceil \frac{k_1}{k2}j\rceil )}^b{k}_{2}j$
同理得到$k_2{\sum }_{j=c}^{d}j\ast [b-max(a,\lfloor \frac{k_2}{k_1}j\rfloor +1)+1]$
所以${\sum }_{i=1}^b{\sum }_{j=c}^{d}min(k_{1}i,k_{2}j)$
$=k_1{\sum }_{i=a}^{b}i\ast [d-max(c,\lceil \frac{k_1}{k_2}i\rceil )+1]+k_2{\sum }_{j=c}^{d}j\ast [b-max(a,\lfloor \frac{k_2}{k_1}j\rfloor +1)+1]$
因为质因子的个数很小，前9个质数相乘就已经超出$1e9$了，故枚举质因子复杂度为$O(9)$
暴力计算贡献的复杂度是$O(3e6)$
质因子分解的复杂度最大是$O(32)$(即$x=2^{32}$的时候)
因此总复杂度为$O(9\times 3e6\times 32)$（实际复杂度远比这小）

AC代码(1175ms)

值得注意的地方有两个：
1.要使用欧拉降幂加速
2.使用欧拉降幂时注意模数是$p-1$不是$p$（具体的请看代码）

#include
using namespace std;
const long long MAXN=2e5;
const long long mod=998244353;
int prime[MAXN];//素数数组
bool is_prime[MAXN+10];//is_pri[i]表示i是素数
int factorX[MAXN+10];
int sumX=0;
int sumY=0;
int factorY[MAXN+10];
long long a, b, c, d, x, y;
int sumPrime;
//返回n以内素数的个数
inline long long quick_pow(long long a, long long b)//快速幂
{
    long long ans=1, base=a;
    while(b!=0)
    {
        if (b&1)
            ans=(long long) ans*base%mod;
        base=(long long) base*base%mod;
        b>>=1;
    }
    return ans;
}
int sieve(int n)
{
    int p=0;//素数个数计数器
    for(int i=0; i<=n; i++)
        is_prime[i]=true;
    is_prime[0]=is_prime[1]=false;//首先标记0和1不是素数
    is_prime[2]=true;//标记2是素数
    for(int i=2; i<=sqrt(n); i++)
    {
        if (is_prime[i]) //如果i是素数
        {
            for(int j=i*i; j<=n; j+=i)//所有i的倍数都不是素数
                is_prime[j]=false;
        }
    }
    for(int i=1; i<=n; i++)
        if (is_prime[i])
            prime[++p]=i;
    return p;
}
void init()//质因子分解
{
    for(int i=1; i<=sumPrime && x!=1; i++)
    {
        if (x%prime[i]==0)
        {
            sumX=i;
            while(x!=1 && x%prime[i]==0)
            {
                x/=prime[i];
                factorX[i]++;
            }
        }
    }
    if (x!=1)
    {
        sumPrime++;
        prime[sumPrime]=x;
        factorX[sumPrime]++;
    }
    for(int i=1; i<=sumPrime && y!=1; i++)
    {
        if (y%prime[i]==0)
        {
            sumY=i;
            while(y!=1 && y%prime[i]==0)
            {
                y/=prime[i];
                factorY[i]++;
            }
        }
    }
    if (y!=1)
    {
        sumPrime++;
        prime[sumPrime]=y;
        factorY[sumPrime]++;
    }
}
void solve()
{
    sumPrime=sieve((int) 2e5);
    scanf("%lld%lld%lld%lld%lld%lld", &a, &b, &c, &d, &x, &y);
    init();
    long long ans=1;
    for(int z=1; z<=min(sumX, sumY); z++)
    {
        if (factorX[z] && factorY[z])
        {
            long long powP1=0, powP2=0;
            for(long long i=a; i<=b; i++)
            {
                long long j;
                if(factorX[z]*i%factorY[z]==0)
                {
                    j=(long long)max(factorX[z]*i/factorY[z],c);
                }
                else
                {
                    j=(long long)max(factorX[z]*i/factorY[z]+1,c);
                }
                if (j<=d && j>=0)
                    powP1=(powP1+(long long) i*((d-j+1+(mod-1))%(mod-1))%(mod-1))%(mod-1);
            }
            powP1=(long long) powP1*factorX[z]%(mod-1);
            for(long long i=c; i<=d; i++)
            {
                long long j;
                j=(long long) max(factorY[z]*i/factorX[z]+1, a);
                if (j<=b && j>=0)
                    powP2=(powP2+(long long) i*((b-j+1+(mod-1))%(mod-1))%(mod-1))%(mod-1);
            }
            powP2=(long long) powP2*factorY[z]%(mod-1);
            ans=(long long) (ans*quick_pow(prime[z], (powP1+powP2)%(mod-1)))%mod;
        }
    }
    printf("%lld\n", ans);
}
int main()
{
//    ios_base::sync_with_stdio(false);
//    cin.tie(0);
//    cout.tie(0);
#ifdef ACM_LOCAL
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    long long test_index_for_debug=1;
    char acm_local_for_debug;
    while(cin>>acm_local_for_debug)
    {
        cin.putback(acm_local_for_debug);
        if (test_index_for_debug>100)
        {
            throw runtime_error("Check the stdin!!!");
        }
        auto start_clock_for_debug=clock();
        solve();
        auto end_clock_for_debug=clock();
        cout<<"\nTest "<<test_index_for_debug<<" successful"<<endl;
        cerr<<"Test "<<test_index_for_debug++<<" Run Time: "
            <<double(end_clock_for_debug-start_clock_for_debug)/CLOCKS_PER_SEC<<"s"<<endl;
        cout<<"--------------------------------------------------"<<endl;
    }
#else
    solve();
#endif
    return 0;
}

后记

赛中傻逼了，欧拉降幂模数一直错，白白WA了3发…
DrGilbert 2020.8.9