Hash Function

最新推荐文章于 2021-12-26 23:40:05 发布
最新推荐文章于 2021-12-26 23:40:05 发布
阅读量162 收藏 1
点赞数
分类专栏： # FFT/NTT/FMT/FWT 数论 文章标签： FFT 数论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35975367/article/details/118969273
版权

Hash Function

文章目录

题意：

给定n个互不相同的数，找一个最小的模域，使得它们在这个模域下互不相同。n<=5e5

题解：

考虑两个数a和b，a与b模m余数相同，当且仅当|a-b|能被m整除。
这样问题就转化成找到一个最下的m，使得m不是任意一个|ai-aj|约数(不会被m整除)
n<=5e5,所以直接暴力n2肯定不行
这时就要用到FFT/NTT加速
算N个数两两之差当然用FFT，利用多项式相乘即指数相加来做，(加减用指数，相乘用系数)
刚接触FFT的同学可能不明白，减法怎么用？FFT的模板不是乘法吗？
我们这样想：FFT可以快速求两个多项式的乘积，并求出每个指数所对应的系数，两个数相乘，指数相加，也就是如果我有一个多项式的指数为x，y（对应的系数都为1），另一个多项式的指数为z，w（对应的系数都为1），相乘后会得到指数为x+z,x+w,z+y,y+w,那如果我们将z和w分别为-x，-y，那就会得到x-x，x-y，y-x，y-y，这不正是x和y任意两数的差，该差是否存在就看他们的系数是否为1
这样就在N*logN求出所有差，（注意FFT中是没有指数为负的，所有我们加入一个偏移量MAX，让MAX-x，最后得到结果再加回去就行）
回到本题，要求是求最小的m，不是任意两数差的约数。现在我们求出所有的差并标记，然后枚举这个m，如果这个m的倍数均没有被标记，输出m
所以这算是个模板题了，会使用FFT/NTT板子

代码

NTT代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=5e5+100;
const int mx=5e5;
const int mod=998244353;
namespace IO{
    template<typename T>void write(T x)
    {
        if(x<0)
        {
            putchar('-');
            x=-x;
        }
        if(x>9)
        {
            write(x/10);
        }
        putchar(x%10+'0');
    }

    template<typename T> void read(T &x)
    {
        x = 0;char ch = getchar();int f = 1;
        while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
        while(isdigit(ch)){x = x*10+(ch-'0');ch=getchar();}x*=f;
    }
};
namespace Math{
    ll w;
    const int p=::mod;
    struct complex{
        ll real,imag;
        complex(ll a=0,ll b=0){
            real=a;
            imag=b;
        }
        friend complex operator*(const complex&a,const complex&b){
            complex ans;
            ans.real=((a.real*b.real%p+a.imag*b.imag%p*w%p)%p+p)%p;
            ans.imag=((a.real*b.imag%p+a.imag*b.real%p)%p+p)%p;
            return ans;
        }
    };
    ll x1,x2;
    ll ksm(ll a,ll b,ll p){
        ll ans=1;
        while(b){
            if(b&1) ans=(ans*a)%p;
            a=(a*a)%p;
            b>>=1;
        }
        return ans;
    }

    ll ksm(complex a,ll b,ll p){
        complex ans(1,0);
        while(b){
            if(b&1) ans=ans*a;
            a=a*a;
            b>>=1;
        }
        return ans.real%p;
    }

    bool Cipolla(ll n,ll&x0,ll&x1){
        n%=p;
        if(ksm(n,(p-1)>>1,p)==p-1) return false;
        ll a;
        while(true){
            a=rand()%p;
            w=((a*a%p-n)%p+p)%p;
            if(ksm(w,(p-1)>>1,p)==p-1) break;
        }
        complex x(a,1);
        x0=(ksm(x,(p+1)>>1,p)+p)%p;
        x1=(p-x0+p)%p;
        return true;
    }
};

namespace NTT{
    #define mul(x,y) ((1ll*x*y>=mod?x*y%mod:1ll*x*y))
    #define dec(x,y) (1ll*x-y<0?1ll*x-y+mod:1ll*x-y)
    #define add(x,y) (1ll*x+y>=mod?1ll*x+y-mod:1ll*x+y)
    #define ck(x) (x>=mod?x-mod:x)
    typedef vector<int> Poly;
    int ksm(int a,int n,int mod=::mod){
        int res=1;
        while(n){
            if(n&1)res=1ll*res*a%mod;
            a=1ll*a*a%mod;
            n>>=1;
        }
        return res;
    }
    const int img=86583718;
    const int g=3,INV=ksm(g,mod-2);
    const int mx=21;
    int R[maxn<<2],deer[2][mx][maxn<<2],inv[maxn<<2];
    void init(const int t) {
        for(int p = 1; p <= t; ++ p) {
            int buf1 = ksm(g, (mod - 1) / (1 << p));
            int buf0 = ksm(INV, (mod - 1) / (1 << p));
            deer[0][p][0] = deer[1][p][0] = 1;
            for(int i = 1; i < (1 << p); ++ i) {
                deer[0][p][i] = 1ll * deer[0][p][i - 1] * buf0 % mod;
                deer[1][p][i] = 1ll * deer[1][p][i - 1] * buf1 % mod;
            }
        }
        inv[1] = 1;
        for(int i = 2; i <= (1 << t); ++ i)
            inv[i] = 1ll * inv[mod % i] * (mod - mod / i) % mod;
    }

    int NTT_init(int n) {
        int lim = 1, l = 0;
        while(lim < n) lim <<= 1, l ++ ;
        for(int i = 0; i < lim; ++ i)
            R[i] = (R[i >> 1] >> 1) | ((i & 1) << (l - 1));
        return lim;
    }
    void ntt(Poly &A, int type, int lim) {
        A.resize(lim);
        for(int i = 0; i < lim; ++ i)
            if(i < R[i])
                swap(A[i], A[R[i]]);
        for(int mid = 2, j = 1; mid <= lim; mid <<= 1, ++ j) {
            int len = mid >> 1;
            for(int pos = 0; pos < lim; pos += mid) {
                int *wn = deer[type][j];
                for(int i = pos; i < pos + len; ++ i, ++ wn) {
                    int tmp = 1ll * (*wn) * A[i + len] % mod;
                    A[i + len] = ck(A[i] - tmp + mod);
                    A[i] = ck(A[i] + tmp);
                }
            }
        }
        if(type == 0) {
            for(int i = 0; i < lim; ++ i)
                A[i] = 1ll * A[i] * inv[lim] % mod;
        }
    }
    Poly poly_mul(Poly A, Poly B) {
        int deg = A.size() + B.size() - 1;
        int limit = NTT_init(deg);
        Poly C(limit);
        ntt(A, 1, limit);
        ntt(B, 1, limit);
        for(int i = 0; i < limit; ++ i)
            C[i] = 1ll * A[i] * B[i] % mod;
        ntt(C, 0, limit);
        C.resize(deg);
        return C;
    }
    Poly poly_inv(Poly &f, int deg) {
        if(deg == 1)
            return Poly(1, ksm(f[0], mod - 2));

        Poly A(f.begin(), f.begin() + deg);
        Poly B = poly_inv(f, (deg + 1) >> 1);
        int limit = NTT_init(deg << 1);
        ntt(A, 1, limit), ntt(B, 1, limit);
        for(int i = 0; i < limit; ++ i)
            A[i] = B[i] * (2 - 1ll * A[i] * B[i] % mod + mod) % mod;
        ntt(A, 0, limit);
        A.resize(deg);
        return A;
    }
    Poly poly_idev(Poly f) {
        int n = f.size();
        for(int i = n - 1; i-1>=0 ; -- i) f[i] = 1ll * f[i - 1] * inv[i] % mod;
        f[0] = 0;
        return f;
    }

    Poly poly_dev(Poly f) {
        int n = f.size();
        for(int i = 1; i < n; ++ i) f[i - 1] = 1ll * f[i] * i % mod;
        f.resize(n - 1);
        return f;
    }

    Poly poly_ln(Poly f, int deg) {
        Poly A = poly_idev(poly_mul(poly_dev(f), poly_inv(f, deg)));
        return A.resize(deg), A;
    }

    Poly poly_exp(Poly &f, int deg) {
        //cerr<<deg<<endl;
        if(deg == 1)
            return Poly(1, 1);

        Poly B = poly_exp(f, (deg + 1) >> 1);
        B.resize(deg);
        Poly lnB = poly_ln(B, deg);
        for(int i = 0; i < deg; ++ i)
            lnB[i] = ck(f[i] - lnB[i] + mod);

        int limit = NTT_init(deg << 1);
        ntt(B, 1, limit), ntt(lnB, 1, limit);
        for(int i = 0; i < limit; ++ i)
            B[i] = 1ll * B[i] * (1 + lnB[i]) % mod;
        ntt(B, 0, limit);
        B.resize(deg);
        return B;
    }
    Poly poly_pow(Poly&f,int k){
        f=poly_ln(f,f.size());
        for(auto&x:f)x=1ll*x*k%mod;
        return poly_exp(f,f.size());
    }
    Poly power(Poly f,int k1,int k2,int deg){
        int s=0;
        while(f[s]==0&&s<f.size())++s;
        if(1ll*s*k1>=deg){
            return vector<int>(deg);
        }
        int Inv=ksm(f[s],mod-2,mod);
        int Mul=ksm(f[s],k2);
        deg-=s;
        for(int i=0;i<deg;++i)f[i]=f[i+s];
        f.resize(deg);
        for(int i=0;i<deg;++i)f[i]=1ll*f[i]*Inv%mod;
        auto res1=poly_ln(f,deg);
        for(int i=0;i<res1.size();++i)res1[i]=1ll*res1[i]*k1%mod;
        auto res2=poly_exp(res1,deg);
        for(int i=0;i<deg;++i)res2[i]=1ll*res2[i]*Mul%mod;
        deg+=s;
        int now=s*k1;
        Poly res;res.resize(deg);
        for(int i=deg-1;i>=now;--i)res[i]=res2[i-now];
        for(int i=now-1;i>=0;--i)res[i]=0;
        return res;
    }
    Poly Poly_Sqrt(Poly&f,int deg){
        if(deg==1)return Poly(1,1);
        Poly A(f.begin(),f.begin()+deg);
        Poly B=Poly_Sqrt(f,(deg+1)>>1);
        Poly IB=poly_inv(B,deg);
        int lim=NTT_init(deg<<1);
        ntt(A,1,lim),ntt(IB,1,lim);
        for(int i=0;i<lim;++i){
            A[i]=1ll*A[i]*IB[i]%mod;
        }
        ntt(A,0,lim);
        for(int i=0;i<deg;++i){
            A[i]=(1ll*A[i]+B[i])%mod*inv[2]%mod;
        }
        A.resize(deg);
        return A;
    }
    Poly Sqrt(Poly&f,int deg){
        const int Pow=ksm(2,mod-2);
        int k1=1;
        if(f[0]!=1){
            k1=ksm(f[0],mod-2);
            for(int i=1;i<f.size();++i){
                f[i]=1ll*k1*f[i]%mod;
            }
            ll x0,x1;
            assert(Math::Cipolla(f[0],x0,x1));
            k1=min(x1,x0);
            f[0]=1;
        }
        auto Ln=poly_ln(f,deg);
        for(int i=0;i<f.size();++i){
            Ln[i]=1ll*Ln[i]*Pow%mod;
        }
        auto Exp=poly_exp(Ln,deg);
        for(int i=0;i<Exp.size();++i)Exp[i]=1ll*Exp[i]*k1%mod;
        return Exp;
    }
    Poly poly_sin(Poly&f,int deg){
        Poly A(f.begin(),f.begin()+deg);
        Poly B(deg),C(deg);
        for(int i=0;i<deg;++i){
            A[i]=1ll*A[i]*img%mod;
        }
        B=poly_exp(A,deg);
        C=poly_inv(B,deg);
        const int inv2i=ksm(img<<1,mod-2);
        for(int i=0;i<deg;++i){
            A[i]=1ll*(1ll*B[i]-C[i]+mod)%mod*inv2i%mod;
        }
        return A;
    }
    Poly poly_cos(Poly&f,int deg){
        Poly A(f.begin(),f.begin()+deg);
        Poly B(deg),C(deg);
        for(int i=0;i<deg;++i){
            A[i]=1ll*A[i]*img%mod;
        }
        B=poly_exp(A,deg);
        C=poly_inv(B,deg);
        const int inv2=ksm(2,mod-2);
        for(int i=0;i<deg;++i){
            A[i]=(1ll*B[i]+C[i])%mod*inv2%mod;
        }
        return A;
    }

    Poly poly_arcsin(Poly f,int deg){
        Poly A(f.size()),B(f.size()),C(f.size());
        A=poly_dev(f);
        B=poly_mul(f,f);
        for(int i=0;i<deg;++i){
            B[i]=dec(mod,B[i]);
        }
        B[0]=add(B[0],1);
        C=Poly_Sqrt(B,deg);
        C=poly_inv(C,deg);
        C=poly_mul(A,C);
        C=poly_idev(C);
        return C;
    }

    Poly poly_arctan(Poly f, int deg) {
        Poly A(f.size()), B(f.size()), C(f.size());
        A = poly_dev(f);
        B = poly_mul(f, f);
        B[0] = add(B[0], 1);
        C = poly_inv(B, deg);
        C = poly_mul(A, C);
        C = poly_idev(C);
        C.resize(deg);
        return C;
    }
};
using NTT::Poly;
using namespace IO;
int n,t;
Poly a,b;
bool vis[maxn];

signed main(){
    //freopen("in.txt","r",stdin);
    //clock_t c1 = clock();
    NTT::init(NTT::mx-1);
    //for(auto x:tmp)cerr<<x<<" ";cerr<<endl;
    a.resize(maxn),b.resize(maxn);
    int n;read(n);
    if(n==1){
        cout<<1<<endl;
        return 0;
    }
    for(int i=0;i<n;++i){
        int x;read(x);
        a[x]=1;
        b[mx-x]=1;
    }
    auto res=NTT::poly_mul(a,b);
    for(int i=mx;i<=2*mx;++i){
        if(res[i]){
            vis[i-mx]=1;
        }
    }
    bool flag=0;
    for(int i=1;i<=mx+1;++i){
        int now=0;
        for(int j=i;j<=mx;j+=i){
            now|=(vis[j]!=0);
            if(now)break;
        }
        if(!now){
            cout<<i<<endl;
            flag=1;
            break;
        }
    }
    return 0;
}

FFT代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=2e6+50;
const double pi=acos(-1);
ll r[N],bits;
complex<double>A[N],B[N],w[N];
int dp[500005], vis[500005];
void FFT(complex<double> *P,ll op,ll N)
{
    for(ll i=1;i<N;i++)
    {
        if(i>r[i])
            swap(P[i],P[r[i]]);
    }
    for(ll i=1;i<N;i<<=1)
    {
        for(ll p=i<<1,j=0;j<N;j+=p)
        {
            for(ll k=0;k<i;k++)
            {
                complex<double>W=w[N/i*k];
                W.imag(W.imag()*op);
                complex<double> X=P[j+k],Y=W*P[j+k+i];
                P[j+k]=X+Y;
                P[j+k+i]=X-Y;
            }
        }
    }
}
 
ll a[N],b[N],cnt[N];
 
void solve(ll *a,ll *b,ll n,ll m)
{
    ll len;
    for(len=1,bits=0;len<=n+m;len<<=1)
        bits++;
    bits--;
    for(ll i=0;i<len;i++)
        A[i].real(0),A[i].imag(0),B[i].real(0),B[i].imag(0);
    for(ll i=0;i<=n;i++)
        A[i].real(a[i]);
    for(ll i=0;i<=m;i++)
        B[i].real(b[i]);
    for(ll i=0;i<len;i++)
        r[i]=(r[i>>1]>>1)|((i&1)<<bits);
    for(ll i=0;i<len;i++)
        w[i].real(cos(pi/len*i)),w[i].imag(sin(pi/len*i));
    FFT(A,1,len);
    FFT(B,1,len);
    for(ll i=0;i<len;i++)
        A[i]=A[i]*B[i];
    FFT(A,-1,len);
    for(ll i=0;i<=n+m;i++)
        a[i]=(ll)(A[i].real()/len+0.5);
}
 
ll  hh[1500150];
ll cii=0;
 
int main()
{
    ll n,m,k,x;
    scanf("%lld",&n);
    for(ll i=0;i<n;i++)
    {
        scanf("%lld",&x);
        a[x]=1;
        b[500050-x]=1;
    }
    solve(a,b,500050,500050);
 
    //printf("a=%lld \n",a[1000]);
    for(ll i=0;i<=1000100;i++)
    {
        if(a[i]!=0)
            hh[cii++]=abs(i-500050);
    }
    int Max=0;
    for(ll i=0;i<cii;i++)
    {
        if(hh[i]>Max)
        {
            Max=hh[i];
        }
        dp[hh[i]]=1;
    }
    int ans=Max+1;
    for(int i=Max;i>=n;i--)
    {
        if(dp[i]==0)
        {
            ans=i;
            continue;
        }
        if(vis[i]==1)
        {
            continue;
        }
        for(int j=2;j*j<=i;j++)
        {
            if(i%j==0)
            {
                vis[j]=1;
                vis[i/j]=1;
                dp[j]=1;
                dp[i/j]=1;
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}
Jozky86
关注
专栏目录
unordered_set，unordered_map中自定义hashfunction
A_Bo的博客
02-22 3743
写在前面 在c++11新标准中引入了unordered_set以及unordered_map，其背后是根据hash实现，而set、map等背后是根据RB_tree实现，在实现hash时，需要将数据转换为对应的hash码，放入对应的bucket中，所以这里的hash function是至关重要的 简单的hash function 我们可以通过hash_function()函数得到对应的hash...
Data.HashFunction.Documentation:Data.HashFunction C＃库的文档存储库
05-06
《Data.HashFunction.Documentation: 深入理解C#库中的哈希函数》 在软件开发中，数据处理和验证是至关重要的环节，而哈希函数则是其中的关键工具。Data.HashFunction C#库提供了一组丰富的哈希算法实现，使得...
hash function比较（一）
晨雪无痕
09-28 4964
由于工作需要，针对千万级别的数据，使用stl::map着实存在着效率问题，最后使用boost::unordered_map替代前者，发现效率上有很大的提升，但是还是无法达到我们的需求； stl::map  底层算法：B+tree 实现 boost::unordered_map 底层算法：hash 实现 所以可能要针对不同的数据类型编写hash function来优化查找和插入的效率，自己编写
几种流行的hash函数
企鹅漫步
08-26 2160
A comprehensive collection of hash functions, a hash visualiser and some test results [see Mckenzie et al. Selecting a Hashing Algorithm, SP&E 20(2):209-224, Feb 1990] will be available someday. If you
哈希函数（Hash Function）
热门推荐
一个机器学习的学习之旅
07-23 1万+
哈希函数（散列函数）说明应用解释Q：冲突是不是可以避免的？hash函数的构造准则：简单、均匀hash函数的构造方法：处理冲突的方法：参考 说明 散列的概念属于查找，它不以关键字的比较为基本操作，采用直接寻址技术。在理想情况下，查找的期望时间为O(1)。 简单的说，hash函数就是把任意长的输入字符串变化成固定长的输出字符串的一种函数。输出字符串的长度称为hash函数的位数。（下图来源于维基百科） ...
POSEIDON: A New Hash Function for Zero-Knowledge Proof Systems 学习笔记
mutourend的博客
12-08 4276
1. 引言 Grassi等人2019年论文《POSEIDON: A New Hash Function for Zero-Knowledge Proof Systems》。 相关代码实现有： https://github.com/dusk-network/Poseidon252 https://github.com/shamatar/poseidon_hash https://github.com/daira/pasta-hadeshash https://github.com/zcash/orchard
golang: panic: crypto: requested hash function #2 is unavailable
test1280
06-11 879
panic: crypto: requested hash function #2 is unavailable
常见的Hash算法(General Purpose Hash Function Algorithms)
05-14 2349
本文属于转载，一且版权(@Copyright) 属于原作者Arash Partow Introduction Hash functions are by definition and implementation generally regarded as Pseudo Random Number Generators (PRNG). From this generalization it c...
自定义unordered_map、unordered_set的hash function、compare function
y_m_h的博客
12-26 724
1.问题 C++ STL容器类unordered_map、unordered_set使用起来非常方便，但当向容器中添加自定义类型的元素时，需提供自定义的hash function、compare function，原因：C++ STL只提供了基本类型（如int、string等）的hash function、compare function，其中，自定义hash function用于计算自定义类型对象的hash value，但由于hash function存在碰撞现象，所以自定义compare functi
General Purpose Hash Function Algorithms Library
05-14
(* General Purpose Hash Function Algorithms Library *) (* *) (* Author: Arash Partow - 2002 *) (* URL: http://www.partow.net *) (* URL: ...
An ASIC Design for a High Speed Implementation of the Hash Function SHA-256
12-02
An implementation of the hash functions SHA-256, 384 and 512 is presented, obtaining a high clock rate through a re- duction of the critical path length, both in the Expander and in the Compressor of ...
New multivariate hash function quadratic polynomials multiplying linear polynomials
02-09
In this study the authors propose a new multivariate hash function with HAsh Iterative FrAmework framework which we call the hash function quadratic polynomials multiplying linear polynomials (QML)....
FWT(快速沃尔什变换)
qq_35975367的博客
10-23 2014
待更。。
置换群，Polya引理和burnside引理（等价类计数问题）
qq_35975367的博客
10-17 867
参考文章： 等价类计数问题 Burnside引理&Pólya定理 Burnside引理与Polya定理 置换群和Burnside引理，Polya定理 概念引入： 离散数学应该学过置换群的相关概念，置换本质就是映射，可以理解成一个正方形绕其中心逆时针旋转90度，就可以看作是正方形四个顶点的置换。 置换会形成一个环。且如果一个状态经过置换后跟原来相同，可以认为该状态为f的不动点。 有些题目中经常出现”本质不同的方案数“，一般是指等价类的数目，题目定义一个等价关系，满足等价关系的元素属于同一等价类。等价关
欧拉函数（简单介绍+例题）
qq_35975367的博客
07-10 852
Acwing视频讲解 欧拉函数：正整数n，欧拉函数是小于n的正整数中与n互质的数的数目 N=p1a1 * p1a2 * p1a3 * …* p1ak 如果pj是i的最小质因子 红色区域一样 经推导得：phi[i * pj] = phi[i] * pj 如果pj不是i的最小质因子 经推导：phi[i * pj]=phi[i] * (pj-1) #include<bits/stdc++.h> #define debug(a,b) printf("%s = %d\n",a,b); typedef
LGV定理
qq_35975367的博客
10-01 705
老早就听说，一直没学，今天遇到一个LGV比较裸的题，特地学习一下 选自oi-wiki 定义： e(u,v)表示u到v这条路径上所有边的边权之积(路径计数时，可以将边权都设为1),很多路径统计问题就是用到这一点 引理： 答案就是矩阵的行列式(可以用高斯消元来搞) 用法： 在路径统计问题中，我们会将边权设为1，e(u,v)常常用于表示从(a,b)走到(c,d)的方案数，一共要走sum=abs(c-a)+abs(d-b),其中挑选c-a步选择向下走,即Cc−a+d−bc−aC_{c-a+d-b}^{c-a}C
二项式反演(非详细)
qq_35975367的博客
10-13 619
引入 二项式反演又名广义容斥定理 二项式反演可以表示成： f[n]=∑i=0n(−1)iCnigi⟺gn=∑i=0n(−1)iCnif[i]f[n]=\sum_{i=0}^n(-1)^iC_{n}^{i}g_{i}⟺g_{n}=\sum_{i=0}^{n}(-1)^iC_{n}^{i}f[i]f[n]=∑i=0n​(−1)iCni​gi​⟺gn​=∑i=0n​(−1)iCni​f[i] 常用表达为： f[n]=∑i=0nCnig[i]⟺g[n]=∑i=0n(−1)n−iCnif[i]f[n]=\sum_{i
P2480 [SDOI2010]古代猪文(数论好题)
qq_35975367的博客
08-26 443
P2480 [SDOI2010]古代猪文 题意： 给你n和g，求g∑d∣nCnd mod pg^{\sum_{d|n}C_{n}^{d}}\bmod pg∑d∣n​Cnd​modp p=999911659 题解： 这个一个综合性很强的数论题 涉及到欧拉定理，Lucas定理，中国剩余定理，挺好的一个题 首先根据欧拉定理推论： 若正整数a，n互质，对于任意的正整数b，有ab≡ab mod ϕ(n)( mod n)a^b \equiv a^{b\bmod \phi(n)}(\bmod n)ab≡abmodϕ(n
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值