bzoj 3283: 运算器 扩展Baby Step Giant Step && 快速阶乘

3283: 运算器

Time Limit: 20 Sec  Memory Limit: 256 MB
Submit: 184  Solved: 59
[Submit][Status][Discuss]

Description

操作有3种：

 

Input

第一行一个正整数N，描述数据组数。

接下来的N行，每行4个正整数Sum，y，z，p。

Sum表述询问类型，如上题所述。对于第2种要求，若X不存在，则输出“Math Error”

 

Output

 

要求有N行输出，每行一个整数，为询问的答案。

 

Sample Input

4
1 2 10 1000
2 3 1 1000
2 2 3 4
3 2 7 9

Sample Output

24
0
Math Error
3

HINT

 

操作1个数小于501。保证Y,Z,P小于10^9

操作2个数小于51 保证Y,Z,P小于10^9 P不一定为质数

操作3个数小于51 保证Y，Z小于10^9，P小于10^9

P不一定为质数

P<=10^9

假设分解质因数后,P=p1^s1*p2^s2*……保证pi^ki<=10^5

 

　　VFK上课时提到了这题，然后就试着做了一下。

　　本来还以为是水题，结果两个晚上就砸这道题上了，第一问不说了，为啥这类题第一问都是快速幂?第二问本以为可以用经典大步小步做，但是发现由于ax=b(mod c)当解得个数是gcd(a,c)，所以gcd(a,c)不等于1是复杂度可以卡到O(c)，于是我们可以考虑使gcd(a,c)==1，并且尽量不改变a^x=b (mod c)的解，我们想到了将gcd(a,c)中的因数消去，具体是不断找gcd(a,c)，然后借助 a=b (mod c) -> ak=bk (mod ck)的性质，设g=gcd(a,c),将原式变成a*a^(x-1)=b (mod c)，发现有解仅当g|a&&g|b&&g|c，同时消去因子，直到互质，这里要特殊处理x较小的解。

　　第三问方法是由p是质数的快速阶乘修改而来，这类题通常将p写成PI(pi^ki)的形式，分别计算，在套用中国剩余定理。计算ans=n! mod p [p=pp^pk]，将ans表示为k*pp^b的形式。考虑将n!中的数分为与p互质的数，与p不互质的数，对于第一类，由于[1,n),[n+1,2*n)结果相同，可用快速幂优化，对于第二类，同时除以pp可转化为规模n/pp的子问题。

　　这道题告诉我以后数论题千万不要用pair存值，稍有修改，一定免不了使用pair<pair<int,int> ,int>这类奇葩类型。

 

　　

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<set>
#include<cmath>
#include<vector>
using namespace std;
#define MAXN 1001000
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3fLL
typedef long long qword;
bool pflag[MAXN];
int prime[MAXN],topp=-1;
void init()
{
        for (int i=2;i<MAXN;i++)
        {
                if (!pflag[i])
                        prime[++topp]=i;
                for (int j=0;j<=topp && i*prime[j]<MAXN;j++)
                {
                        pflag[i*prime[j]]=true;
                        if (i%prime[j]==0)break;
                }
        }
}
qword fact[MAXN];
qword pow_mod(qword x,qword y,qword mod)
{
        qword ret=1;
        while (y)
        {
                if (y&1)
                        ret=ret*x%mod;
                x=x*x%mod;
                y>>=1;
        }
        return ret;
}
qword gcd(qword x,qword y)
{
        return x%y==0?y:gcd(y,x%y);
}
qword extgcd(qword p,qword q,qword &x,qword &y)
{
        if (!q)
        {
                x=1;y=0;
                return p;
        }
        qword xx,yy;
        qword ret=extgcd(q,p%q,xx,yy);
        x=yy;
        y=xx-p/q*yy;
        return ret;
}    

pair<int,int> lst[MAXN];
int topl=-1;
qword BabyStepGiantStep_Naive(qword k,qword a,qword b,int p)//k*a^x==b (mod p) (gcd(a,p)==1)
{
        qword res=INFL;
        int sb=(int)ceil(sqrt(p));
        qword x=k;
        topl=-1;
        for (int i=0;i<sb;i++)
        {
                lst[++topl].first=(int)x;
                lst[topl].second=i;
                x=x*a%p;
        }
        sort(lst,lst+topl+1);
        qword y=pow_mod(a,sb,p);
        x=1;
        qword xx,yy;
        qword r;
        for (int i=0;i<sb;i++)
        {
                r=extgcd(x,p,xx,yy);
                if (b%r==0)
                {
                        xx*=b/r;
                        xx=(xx%(p/r)+p/r)%(p/r);
                        if (lower_bound(lst,lst+topl+1,make_pair((int)xx,-INF))->first==xx)
                        {
                                res=i*sb+lower_bound(lst,lst+topl+1,make_pair((int)xx,-INF))->second;
                                break;
                        }
                }
                x=x*y%p;
        }
        if (res==INFL)
                return -1;
        else
                return res;
}
void BabyStepGiantStep(qword a,qword b,int p)//a^x==b (mod P)
{
        qword x=1%p;
        for (int i=0;i<70;i++)
        {
                if (x==b)
                {
                        printf("%d\n",i);
                        return ;
                }
                x=x*a%p;
        }
        int delta=0;
        int g;
        qword kk=1;
        while ((g=(int)gcd(a,p))!=1)
        {
                if (b%g)
                {
                        printf("Math Error\n");
                        return ;
                }
                kk*=a/g;
                delta++;
                b/=g;
                p/=g;
                kk%=p;
        }
        qword res=BabyStepGiantStep_Naive(kk,a,b,p);
        if (res==-1)
                printf("Math Error\n");
        else
                printf("%d\n",(int)(res+delta));
}
void init_fact(int p,int pp)
{
        fact[0]=1;
        for (int i=1;i<=p;i++)
        {
                if (i%pp)
                {
                        fact[i]=fact[i-1]*i%p;
                }
                else
                {
                        fact[i]=fact[i-1];
                        int x=i;
                        while (x%pp==0)
                        {
                                x/=pp;
                        }
                }
        }
}
pair<qword,int> solve2(int n,int p,int pp,int pk)//n! mod p (p=pp^k)
{
        pair<qword,int> res;
        if (!n)return make_pair(1,0);
        pair<qword,int> pr=solve2(n/pp,p,pp,pk);
        res.first=pow_mod(fact[p-1],n/p,p) * fact[n%p]%p * pr.first%p;
        res.second=n/pp + pr.second;
        return res;
}
qword solve4(vector<pair<pair<int,int>,int> > &lst)
{
        qword mm=1;
        for (int i=0;i<lst.size();i++)
                mm=mm*lst[i].first.first;
        qword ans=0;
        for (int i=0;i<lst.size();i++)
        {
                ans+=mm/lst[i].first.first*pow_mod(mm/lst[i].first.first%lst[i].first.first,lst[i].first.second-1,lst[i].first.first)%mm*lst[i].second%mm;
                ans%=mm;
        }
        return ans;
}
int factor[MAXN][4];
int totf=0;
void solve3(int n,int m,int p)//n!/(m!(n-m)!) mod p
{
        if (n<m)
        {
                printf("0\n");
                return ;
        }
        qword x=p;
        totf=0;
        for (int i=0;i<=topp;i++)
        {
                if (x%prime[i]==0)
                {
                        x/=prime[i];
                        factor[totf][0]=prime[i];
                        factor[totf][1]=prime[i];
                        factor[totf][2]=prime[i]-1;
                        factor[totf][3]=1;
                        while (x%prime[i]==0)
                        {
                                factor[totf][0]*=prime[i];
                                factor[totf][2]*=prime[i];
                                factor[totf][3]++;
                                x/=prime[i];
                        }
                        totf++;
                }
        }
        if (x!=1)
                throw 1;
        vector<pair<pair<int,int>,int> > lst;
        pair<qword,qword> pr,res;
        for (int i=0;i<totf;i++)
        {
                init_fact(factor[i][0],factor[i][1]);
                res=solve2(n,factor[i][0],factor[i][1],factor[i][3]);
                pr=solve2(m,factor[i][0],factor[i][1],factor[i][3]);
                pr.first=pow_mod(pr.first,factor[i][2]-1,factor[i][0]);pr.second=-pr.second;
                res.first=res.first*pr.first%factor[i][0];
                res.second=res.second+pr.second;
                pr=solve2(n-m,factor[i][0],factor[i][1],factor[i][3]);
                pr.first=pow_mod(pr.first,factor[i][2]-1,factor[i][0]);pr.second=-pr.second;
                res.first=res.first*pr.first%factor[i][0];
                res.second=res.second+pr.second;
                res.first=res.first*pow_mod(factor[i][1],res.second,factor[i][0])%factor[i][0];
                lst.push_back(make_pair(make_pair(factor[i][0],factor[i][2]),res.first));
        }
        qword ans;
        ans=solve4(lst);
        printf("%d\n",(int)ans);
}

int main()
{
        freopen("input.txt","r",stdin);
        int n,m,x,y,z;
        scanf("%d",&n);
        int opt;
        init();
        for (int i=1;i<=n;i++)
        {
                scanf("%d%d%d%d",&opt,&x,&y,&z);
                if (opt==1)
                {
                        printf("%d\n",(int)pow_mod(x,y,z));
                }else if (opt==2)
                {
                        BabyStepGiantStep(x,y,z);
                }else if (opt==3)
                {
                        solve3(y,x,z);
                }
        }
}