sgu 261

学习了元根的一些知识，哈哈。

总结一下：

几个概念：

阶：对于模数m和整数a，并且gcd(m,a)==1，那么定义a在模m下的阶r为满足a^r=1 mod m的最小正整数。

性质1：r in [1,phi(m)]   (由欧拉定理）

性质2：r | phi(m)  ( a^r=a^phi(m) mod m，然后用反证法)

性质3：r 是整数a模m的阶当且仅当满足：1）a^r=1 mod m   2) a ^r/p(r) ≠ 1 mod m (后面推前面也用反正法）。

元根：

如果对于一个模数m，存在一个数a，满足a在模m下的阶是phi(m)，那么就称a是模数m的一个元根。

性质：所有质数有元根（更一般的，2,4,p^e,2p^e有元根，p是奇质数）

元根应用

元根依靠离散对数，将对数运算引入了模数的缩系下。从而可以解决很多数论中关于指数的问题。

ind_ga=ind_gb mod phi(m) <=> a=b mod m

ind_ga^k=k ind_ga mod phi(m)

ind_gab=ind_ga+ind_gb mod phi(m)

 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <vector>
 #include <algorithm>
 using namespace std;

 typedef long long dnt;

 const int mod = ;
 const int elen = ;
 struct Hash {
     int head[mod], val[elen], rat[elen], next[elen], etot;
     void init() {
         memset( head, , sizeof(head) );
         etot = ;
     }
     void insert( int v, int r ) {
         int k = v % mod;
         etot++;
         next[etot] = head[k];
         rat[etot] = r;
         val[etot] = v;
         head[k] = etot;
     }
     int query( int v ) {
         int k = v % mod;
         for( int t=head[k]; t; t=next[t] )
             if( val[t]==v ) return rat[t];
         return -;
     }
 }hash;

 int p, a, k;
 int g, b;
 vector<int> stk;

 dnt mpow( dnt a, int b, int m ) {
     dnt rt;
     for( rt=; b; b>>=,a=(a*a)%m )
         if( b& ) rt=(rt*a)%m;
     return rt;
 }
 void exgcd( int a, int b, int &d, dnt &x, dnt &y ) {
     if( b== ) d=a, x=, y=;
     else {
         exgcd( b, a%b, d, y, x );
         y-=a/b*x;
     }
 }
 int gcd( int a, int b ) {
     return b ? gcd(b,a%b) : a;
 }
 int findroot( int n ) {        //    n is prime
     if( n== ) return ;

     vector<int> pfac;
     int maxi = (int)ceil(sqrt(n-));
     int remain=n-;
     for( int i=; i<=maxi; i++ ) {
         if( remain%i== ) {
             pfac.push_back(i);
             while( remain%i== )
                 remain/=i;
         }
     }
     if( remain!= ) pfac.push_back( remain );
     for( int i=; ; i++ ) {
         bool ok = true;
         for( int t=; t<pfac.size(); t++ )
             if( mpow(i,(n-)/pfac[t],n)== ) {
                 ok = false;
                    break;
             }
         if( ok ) return i;
     }
 }
 dnt inv( int a, int n ) {
     return mpow(a,n-,n);
 }
 dnt ind( int g, int b, int n ) {    //    n is prime, g is root, return v in [0,n-1]
     hash.init();
     int m = (int)ceil(sqrt(n-));
     dnt s = ;
     for( int i=; i<m; i++ ) {
         if( s==b ) return i;
         hash.insert( s, i );
         s = (s*g) % n;
     }
     int am = s;
     s = b;
     for( int i=m,j; i<n; i+=m ) {
         s = (s*inv(am,n)) % n;
         if( (j=hash.query(s))!=- )
             return i+j;
     }
     return -;    //    impossible
 }
 void meq( int a, int b, int m ) {
     stk.clear();
     int d = gcd(a,m);
     if( b%d ) return;
     int aa=a/d, bb=b/d, mm=m/d, dd;
     dnt x0, y0;
     exgcd( aa, mm, dd, x0, y0 );
     x0 = (x0%mm+mm)%mm;
     for( dnt k=; k<d; k++ )
         stk.push_back( (x0*bb+k*mm)%m );
 }

 int main() {
     scanf( "%d%d%d", &p, &k, &a );    //    x^k = a mod p
     if( a== ) {
         printf( "1\n0 \n" );
         return ;
     }
     //    find the root of p: g
     g = findroot(p);
     //    ind a: b
     b = ind( g, a, p );
     //    kx=b mod phi(p)
     meq( k, b, p- );
     //    decode
     for( int t=; t<stk.size(); t++ )
         stk[t] = mpow( g, stk[t], p );
     sort( stk.begin(), stk.end() );
     //    output
     printf( "%d\n", stk.size() );
     for( int t=; t<stk.size(); t++ )
         printf( "%d ", stk[t] );
     printf( "\n" );
 }