Luogu5285 [十二省联考2019]骗分过样例

Luogu5285 [十二省联考2019]骗分过样例

\(case1,2,3:\)

很明显，求\(19^x\)，直接快速幂。但是\(case3\)数据很大，可以利用\(a^b \mod p= a^{b \mod (p-1)} \mod p\)边读入边取模。

\(case4:\)

没有给模数？拿第一个大数据，暴力枚举模数进行匹配，跑出来模数是\(1145141\)。

\(case5:\)

观察\(ans\)文件，这模数相当大啊！枚举显然废了。利用技巧，我们找到最相邻的\(x,y\)，满足\(x<y,19^x \mod p > 19^y \mod p\)，那么\((19^x \mod p) \times 19^{y-x}-(19^y \mod p)\)应该是\(p\)的倍数，且不会很大。

运行结果：

\[x=264708066\\ y=264708068\\ 19^x \mod p=1996649514996338529\\ 19^y \mod p=1589589654696467295\\ (19^x \mod p) \times 19^{y-x}-(19^y \mod p)=719200885258981741674 \]

这。。。炸\(long \quad long\)了，那么当然是用\(\_\_int128\)喽！

\(p\)应该是它的巨大质因数（一般模数总是质数吧），直接\(Pollard\_Rho\)

运行结果：

\[5211600617818708273 \quad 23 \quad 3 \quad 2 \]

当然就是\(5211600617818708273\)了！

\(case6,7:\)

\(wa\)。。。负数？？？

题目里好像说了自然溢出。

这样快速幂就崩了。

我也不知到它为什么有循环节。

跑一遍，循环节起点为\(55245\)，长度为\(45699\)，解决了。

\(case8:\)

\(p\)嘛，质数！

直接线性筛。

\(case9,10:\)

范围有点大，\(Miller\_Rabin\)！

卡常数，只能牺牲正确性少试验几个质数了。

\(case11:\)

\(u \rightarrow \mu\)。

线性筛！

\(case12,13:\)

这怎么算？

先把\(10^6\)以内的因子筛掉，得到一个\(\mu\)值。

那么剩下的数中，最多有两个质因数（因为必须大于\(10^6\)）。

分三种情况：

\(1.\)留下一个质数，直接\(Miller\_Rabin\)，\(\mu\)符号变向。

\(2.\)留下一个质数的平方，直接\(sqrt\)函数判断即可，\(\mu=0\)。

\(3.\)剩余的情况一定是两个大质数相乘，\(\mu\)不变。

\(case14:\)

\(g\)应该是原根，暴力匹配就好了。

\(case15:\)

\(TLE\)。。。

\(1 \quad 13123110 \quad 13123111\)。

要匹配的数很小啊？所以可以一次性筛完原根，做法同此处。

\(case16:\)

又不给模数。。。

范围\(10^9 \sim 2 \times 10^9\)。

\(dalao:\)显然靠近\(1.5 \times 10^9\)。Why? Why? Why?

为了快速判断，截取答案文件前\(60\)位，从\(1.5 \times 10^9\)向两边寻找质数，只计算\(x^{\frac{n-1}{2}} \mod n\)，若值为\(1\)且被判断成原根，就返回错误。

运行结果：

\[1515343657 \]

直接暴力匹配！

\(Accepted!\)

代码中包含寻找模数等对于数据的测试，因此只有短短\(12.49k\)。

\(Code:\)

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<map>
#define ll long long
#define ull unsigned long long
#define ui unsigned int
#define int128 __int128
using namespace std;
const int INF=1000000007;
char opt[15];
template<typename T>
void Add(T &x,T y,T p)
{
    x=(x+y)%p;
}
template<typename T>
void Mul(T &x,T y,T p)
{
    x=(int128)x*y%p;
}
template<typename T>
T add(T x,T y,T p)
{
    return (x+y)%p;
}
template<typename T>
T mul(T x,T y,T p)
{
    return (int128)x*y%p;
}
template<typename T>
T low_mul(T x,T y,T p)
{
    T ans=0;
    x%=p;
    while (y)
    {
        if (y & 1)
            ans=ans+x;
        x <<=1;
        y >>=1;
        if (ans>=p)
            ans-=p;
        if (x>=p)
            x-=p;
    }
    return ans;
}
template<typename T>
T fast_mul(T x,T y,T p)
{
    return (int128)x*y%p;
}
template<typename T>
T ksm(T x,T y,T p)
{
    T ans=1;
    while (y)
    {
        if (y & 1)
            ans=fast_mul(ans,x,p);
        x=fast_mul(x,x,p);
        y >>=1;
    }
    return ans;
}
template<typename T>
T gcd(T x,T y)
{
    if (!y)
        return x;
    return gcd(y,x%y);
}
template<typename T>
T My_abs(T x,T y)
{
    return (x>y)?x-y:y-x;
}
template<typename T>
void write(T x)
{
    if (x>9)
        write(x/10);
    putchar(x%10+'0');
}
template<typename T>
void writeln(T x)
{
    write(x),putchar('\n');
}
namespace ModRead
{
    template<typename T>
    T solve1(T p)
    {
        char c=getchar();
        T x=0;
        while (c<'0' || c>'9')
            c=getchar();
        while ('0'<=c && c<='9')
            x=(fast_mul(x,(T)10,p-1)+(c^48))%(p-1),c=getchar();
        return x;
    }
    template<typename T>
    T solve2(char *s,T p)
    {
        T x=0;
        int n=strlen(s);
        for (int i=0;i<n;++i)
            x=(fast_mul(x,(T)10,p-1)+(s[i]^48))%(p-1);
        return x;
    }
};
namespace Prime
{
    bool pri[1000005];
    int cnt=0,prime[1000005],mu[1000005],phi[1000005];
    void solve()
    {
        pri[0]=pri[1]=true,mu[1]=1,phi[1]=1;
        for (int i=2;i<=1000000;++i)
        {
            if (!pri[i])
                prime[++cnt]=i,mu[i]=-1,phi[i]=i-1;
            for (int j=1;j<=cnt;++j)
            {
                if ((ll)i*prime[j]>1000000)
                    break;
                int g=i*prime[j];
                pri[g]=true;
                if (i % prime[j] == 0)
                {
                    mu[g]=0;
                    phi[g]=phi[i]*prime[j];
                    break;
                }
                mu[g]=-mu[i];
                phi[g]=phi[i]*phi[prime[j]];
            }
        }
    }
};
namespace Miller_Rabin
{
    int pri[15]={2,3,5,7,11,13,17,19,23,29,31,37};
    template<typename T>
    T ksm(T x,T y,T p)
    {
        T ans=1;
        while (y)
        {
            if (y & 1)
                ans=fast_mul(ans,x,p);
            x=fast_mul(x,x,p);
            y >>=1;
        }
        return ans;
    }
    template<typename T>
    bool check(T n)
    {
        if (n==2)
            return true;
        if (n<2 || !(n & 1))
            return false;
        int cnt=0;
        T t=n-1;
        while (!(t & 1))
            ++cnt,t >>=1;
        for (int i=0;i<12;++i)
        {
            if (n<=pri[i])
                return n==pri[i];
            T u=ksm((T)pri[i],t,n),v;
            for (int j=0;j<cnt;++j)
            {
                v=fast_mul(u,u,n);
                if (v==1 && u!=1 && u!=n-1)
                    return false;
                u=v;
            }
            if (u!=1)
                return false;
        }
        return true;
    }
    template<typename T>
    bool fast_check(T n)
    {
        if (n==2)
            return true;
        if (n<2 || !(n & 1))
            return false;
        int cnt=0;
        T t=n-1;
        while (!(t & 1))
            ++cnt,t >>=1;
        for (int i=0;i<2;++i)
        {
            if (n<=pri[i])
                return n==pri[i];
            T u=ksm((T)pri[i],t,n),v;
            for (int j=0;j<cnt;++j)
            {
                v=fast_mul(u,u,n);
                if (v==1 && u!=1 && u!=n-1)
                    return false;
                u=v;
            }
            if (u!=1)
                return false;
        }
        return true;
    }
};
namespace Pollard_Rho
{
    int128 c;
    template<typename T>
    T f(T x,T p)
    {
        return (fast_mul(x,x,p)+c)%p;
    }
    template<typename T>
    T SearchFac(T n)
    {
        c=(int128)rand()*rand()*rand()%(n-1)+1;
        T s=0,t=0,u=1;
        for (int lim=1;;lim <<=1,s=t)
        {
            for (int i=1;i<=lim;++i)
            {
                t=f(t,n);
                u=fast_mul(u,My_abs(s,t),n);
                if (i % 127 == 0)
                {
                    T d=gcd(u,n);
                    if (d>1)
                        return d;
                }
            }
            T d=gcd(u,n);
            if (d>1)
                return d;
        }
    }
    template<typename T>
    void solve(T n,T *a)
    {
        if (n<2)
            return;
        if (Miller_Rabin::check(n))
        {
            a[++a[0]]=n;
            return;
        }
        T p=n;
        while (p==n)
            p=SearchFac(n);
        while (n % p == 0)
            n/=p;
        solve(n,a),solve(p,a);
    }
};
namespace Easy_Prime_Resolve
{
    void solve(int n,int *a)
    {
        a[0]=0;
        for (int i=2;(ll)i*i<=n;++i)
            if (n % i == 0)
            {
                a[++a[0]]=i;
                while (n % i == 0)
                    n/=i;
            }
        if (n!=1)
            a[++a[0]]=n;
    }
};
namespace Task1
{
    template<typename T>
    void solve(T rp)
    {
        T p=rp;
        int _;
        scanf("%d",&_);
        while (_--)
            printf("%lld\n",(ll)ksm((T)19,ModRead::solve1(p),p));
    }
};
namespace Test4
{
    int solve()
    {
        for (int i=2;;++i)
            if (ksm(19,ModRead::solve2("627811703016764290815178977207148434322",i),i)==642666)
                return i;
    }
};
namespace Test5
{
    char s[25];
    int n;
    pair<int,ll>a[10005];
    int128 fac[65];
    void solve()
    {
        freopen("software5.in","r",stdin);
        scanf("%s",s);
        scanf("%d",&n);
        for (int i=1;i<=n;++i)
            scanf("%d",&a[i].first);
        freopen("software5.ans","r",stdin);
        for (int i=1;i<=n;++i)
            scanf("%lld",&a[i].second);
        sort(a+1,a+n+1);
        int mn=INF,id=1;
        for (int i=2;i<=n;++i)
            if (a[i-1].second>a[i].second && a[i].first-a[i-1].first<mn)
                mn=a[i].first-a[i-1].first,id=i-1;
        printf("%d %lld %d %lld\n",a[id].first,a[id].second,a[id+1].first,a[id+1].second);
        int128 del=a[id].second;
        del*=361;
        del-=a[id+1].second;
        writeln(del);
        fac[0]=0;
        Pollard_Rho::solve(del,fac);
        for (int i=1;i<=fac[0];++i)
            writeln(fac[i]);
    }
};
namespace Test6
{
    const int p=998244353;
    map<int,int>xh;
    void solve()
    {
        int x=1;
        for (int i=1;;++i)
        {
            x=(int)((ui)19*(ui)x)%p;
            if (xh[x])
            {
                printf("%d %d\n",xh[x],i-xh[x]);
                return;
            }
            xh[x]=i;
        }
    }
};
namespace Task2
{
    const int p=998244353;
    const int st=55245;
    const int len=45699;
    int ans[120005];
    void solve()
    {
        ans[0]=1;
        for (int i=1;i<=st+len;++i)
            ans[i]=(int)((ui)19*(ui)ans[i-1])%p;
        int T;
        ll x;
        scanf("%d",&T);
        while (T--)
        {
            scanf("%lld",&x);
            printf("%d\n",(x<=st+len)?ans[x]:ans[(x-st)%len+st]);
        }
    }
};
namespace Task3
{
    void solve()
    {
        Prime::solve();
        int T;
        ll l,r;
        scanf("%d",&T);
        while (T--)
        {
            scanf("%lld%lld",&l,&r);
            if (r<=1000000)
            {
                for (ll i=l;i<=r;++i)
                    putchar(Prime::pri[i]?'.':'p');
                putchar('\n');
            } else
            {
                for (ll i=l;i<=r;++i)
                    putchar(Miller_Rabin::fast_check(i)?'p':'.');
                putchar('\n');
            }
        }
    }
};
namespace Task4
{
    int mu[1000005];
    ll fr[1000005];
    ll nxt(ll x,ll p)
    {
        if (x % p == 0)
            return x;
        return (x/p+1)*p;
    }
    void solve()
    {
        Prime::solve();
        int T;
        ll l,r;
        scanf("%d",&T);
        while (T--)
        {
            scanf("%lld%lld",&l,&r);
            if (r<=1000000)
            {
                for (ll i=l;i<=r;++i)
                    putchar((!Prime::mu[i])?'0':((Prime::mu[i]==1)?'+':'-'));
                putchar('\n');
            } else
            {
                for (int i=1;i<=r-l+1;++i)
                    mu[i]=1,fr[i]=l+i-1;
                for (int i=1;i<=Prime::cnt;++i)
                {
                    int s=Prime::prime[i];
                    ll t=(ll)s*s;
                    for (ll j=nxt(l,s);j<=r;j+=s)
                    {
                        mu[j-l+1]=-mu[j-l+1];
                        while (fr[j-l+1] % s == 0)
                            fr[j-l+1]/=s;
                    }
                    for (ll j=nxt(l,t);j<=r;j+=t)
                        mu[j-l+1]=0;
                }
                for (ll i=l;i<=r;++i)
                {
                    if (!mu[i-l+1] || (ll)(sqrt(i))*(ll)(sqrt(i))==i)
                    {
                        putchar('0');
                        continue;
                    }
                    if (Miller_Rabin::fast_check(fr[i-l+1]))
                        mu[i-l+1]=-mu[i-l+1];
                    putchar((mu[i-l+1]==1)?'+':'-');
                }
                putchar('\n');
            }
        }
    }
};
namespace Test16
{
    const int L=1000000000,R=2000000000,mid=1500000000;
    const int st=233333333;
    string s="...ggg..gg.g...g..gg..g.gg......gg..g......gg..gg...g...g..g";
    bool Rcheck(int i)
    {
        if (!Miller_Rabin::fast_check(i))
            return false;
        for (int j=0;j<60;++j)
            if (ksm(j+st,(i-1) >> 1,i)==1 && s[j]=='g')
                return false;
        return true;
    }
    void solve()
    {
        for (int i=1;;++i)
        {
            if (Rcheck(mid-i))
            {
                printf("%d\n",mid-i);
                return;
            }
            if (Rcheck(mid+i))
            {
                printf("%d\n",mid+i);
                return;
            }
        }
    }
};
namespace Task5
{
    const int p1=998244353,p2=13123111,p3=1515343657;
    int a[25],b[25],c[25];
    bool nt[p2+5],isg[p2+5];
    bool check(int x,int *a,int p)
    {
        if (x % p == 0)
            return false;
        for (int i=1;i<=a[0];++i)
            if (ksm(x,(p-1)/a[i],p)==1)
                return false;
        return true;
    }
    void g_All()
    {
        int g;
        for (g=1;!check(g,b,p2);++g);
        for (int i=1;i<=b[0];++i)
            for (int j=b[i];j<=p2-1;j+=b[i])
                nt[j]=true;
        for (int i=1;i<=p2-1;++i)
            if (!nt[i])
                isg[ksm(g,i,p2)]=true;
    }
    void solve()
    {
        Prime::solve();
        Easy_Prime_Resolve::solve(p1-1,a);
        Easy_Prime_Resolve::solve(p2-1,b);
        Easy_Prime_Resolve::solve(p3-1,c);
        g_All();
        int T,l,r,p;
        scanf("%d",&T);
        while (T--)
        {
            scanf("%d%d",&l,&r);
            if (l==Test16::st)
            {
                for (int i=l;i<=r;++i)
                    putchar(check(i,c,p3)?'g':'.');
                putchar('\n');
                return;
            }
            scanf("%d",&p);
            if (p==p1)
            {
                for (int i=l;i<=r;++i)
                    putchar(check(i,a,p)?'g':'.');
                putchar('\n');
            } else
            if (p==p2)
            {
                for (int i=l;i<=r;++i)
                    putchar(isg[i]?'g':'.');
                putchar('\n');
            }
        }
    }
};
int main()
{
    srand(time(NULL));
    scanf("%s",opt);
    if (opt[0]=='1' && opt[1]=='_')
        Task1::solve(998244353); else
    if (opt[0]=='1' && opt[1]=='?' && opt[2]!='+')
        Task1::solve(1145141); else
    if (opt[0]=='1' && opt[1]=='?' && opt[2]=='+')
        Task1::solve(5211600617818708273); else
    if (opt[0]=='1' && opt[1]=='w')
        Task2::solve(); else
    if (opt[0]=='2' && opt[1]=='p')
        Task3::solve(); else
    if (opt[0]=='2' && opt[1]=='u')
        Task4::solve(); else
    if (opt[0]=='2' && opt[1]=='g')
        Task5::solve();
    return 0;
}