数学：二次剩余与n次剩余

二次剩余求的是这个东西

如果给定x，再给定若干个大的质数p，如果结果a相同，那么x是完全平方数？

 /*poj 1808
   题意：
   判断平方剩余，即判断(x^2)%p=a是否有解。
   限制：
   |a| <= 1e9 && a % p !=0; 2 < p < 1e9 && p为奇素数。
   思路：
   用欧拉准则计算勒让德符号(用来判断平方剩余)
  */
 #include<iostream>
 #include<cstdio>
 using namespace std;
 #define LL __int64
 LL a_b_MOD_c(LL a,LL b,LL mod){
     LL ret = ;
     a %= mod;
     while(b){
         if(b & ) ret = ret * a % mod;
         a = a * a % mod;
         b >>= ;
     }
     return ret;
 }
 //(x^2)%n=a 求平方剩余，n必须是奇素数
 //注意：如果a为负，则看题意，是否要化为a=(a%n+n)%n
 int modsqr(int a,int n){
     int b,k,i,x;
     if(n==) return a%n;
     if(a_b_MOD_c(a,(n-)/,n)==){
         if(n%==)
             x=a_b_MOD_c(a,(n+)/,n);
         else{
             for(b=;a_b_MOD_c(b,(n-)/,n)==;b++){
                 i=(n-)/;
                 k=;
             }
             do{
                 i/=;
                 k/=;
                 if((a_b_MOD_c(a,i,n)*a_b_MOD_c(b,k,n)+)%n==)
                     k+=(n-)/;
             }
             while(i%==);
             x=(a_b_MOD_c(a,(i+)/,n)*a_b_MOD_c(b,k/,n))%n;
         }
         if(x*>n)
             x=n-x;
         return x;
     }
     return -;
 }
 //用欧拉准则计算勒让德符号(用来判断平方剩余)
 //表示为(a|p) a为整数，p为奇素数(所以m=2不适用勒让德符号)，有三种情况。
 //1. (a|p)=0, if(a%p==0)
 //2. (a|p)=1, if(a%p!=0 && (x^2)%p=a 有整数解)
 //3. (a|p)=-1,if((x^2)%p=a 无整数解)
 //注意：如果a为负，则看题意，是否要化为a=(a%p+p)%p
 int lrd(LL a,LL p){
     LL ret=a_b_MOD_c(a,(p-)>>,p);
     if(ret==)
         return ;
     return -;
 }
 int main(){
     int T,cas=;
     int a,n;
     scanf("%d",&T);
     while(T--){
         scanf("%d%d",&a,&n);
         a=(a+n)%n;    //以后注意给出余数的时候，要注意它是不是负的

         //求平方剩余
         //cout<<modsqr(a,n)<<endl;
         printf("Scenario #%d:\n%d\n\n",++cas,lrd(a,n));
     }
     return ;
 }

然后是n次剩余

 /*hdu 3930
   题意：
   给定newx, k, m, 方程 (x^k)%m=newx, 求在模m意义下的所有解x。
   限制：
   0 <= newx, m, k <= 1.5*10^15; m是素数。
   思路：
   N次剩余
  */
 #include <iostream>
 #include <cstdio>
 #include <cmath>
 #include <cstring>
 #include <vector>
 #include <algorithm>
 using namespace std;
 #define LL __int64
 #define PB push_back
 LL mul(LL a,LL b,LL m){
     LL ret = ;
     a %= m;
     while(b){
         if(b & ) ret = (ret + a) % m;
         a = (a + a) % m;
         b >>= ;
     }
     return ret;
 }
 LL a_b_MOD_c(LL a,LL b,LL m){
     LL ret = ;
     a %= m;
     while(b){
         if(b&) ret = mul(ret,a,m);
         a = mul(a,a,m);
         b >>= ;
     }
     return ret;
 }

 LL ext_gcd(LL a,LL b,LL &x,LL &y){
     if(b==) { x=, y=; return a; }
     LL ret= ext_gcd(b,a%b,y,x);
     y-= a/b*x;
     return ret;
 }
 vector<LL> a;
 bool g_test(LL g,LL p){
     for(LL i=;i<a.size();++i)
         if(a_b_MOD_c(g,(p-)/a[i],p)==)
             return ;
     return ;
 }
 LL pri_root(LL p){
     a.clear();
     LL tmp=p-;
     for(LL i=;i<=tmp/i;++i)
         if(tmp%i==){
             a.push_back(i);
             while(tmp%i==)
                 tmp/=i;
         }
     if(tmp!=)
         a.push_back(tmp);
     LL g=;
     while(true){
         if(g_test(g,p))
             return g;
         ++g;
     }
 }
 const int HASH_MOD=;
 LL key[HASH_MOD], val[HASH_MOD];
 int head[HASH_MOD], next[HASH_MOD];
 struct Hash{
     int tot;
     void init(){
         memset(head, -, sizeof(head));
         tot = ;
     }
     LL insert(LL x, LL y){
         int k = x % HASH_MOD;
         key[tot] = x;
         val[tot] = y;
         next[tot] = head[k];
         head[k] = tot++;
     }
     LL find(LL x){
         int k = x % HASH_MOD;
         for(int i = head[k]; i != -; i = next[i])
             if(key[i] == x)
                 return val[i];
         return -;
     }
 }hs;
 //求解模方程a^x=b(mod m),n为素数,无解返回-1
 //注意：要求0 < a < m; 0 <= b < m; 否则按题意自己转化。
 //复杂度O(sqrt(m))
 LL log_mod(LL a, LL b, LL m){
     hs.init();
     LL s = ceil(sqrt(m + 0.5));
     LL cur = ;
     for (int i = ; i < s; ++i){
         if(hs.find(cur)==-) hs.insert(cur,i);    //记得先判重，在插入
         cur = cur * a % m;
     }

     LL v = a_b_MOD_c(a, (m - s -  + m) % m, m);
     for(int i = ; i < s; ++i){
         LL tmp = hs.find(b);
         if(tmp!=-)
             return s * i + tmp;
         b=b*v%m;
     }
     return -;
 }
 /*n次剩余
   任务：
   给定N, a, p, 求出(x^N)%p=a 在模p意义下的所有解x。
   说明：
   令g为p的原根，因为p为素数，所以phi(p)=p-1。
   由原根的性质得：
   如果g为p的原根，则：g^i mod p != g^j mod p (p为素数), 其中i != j且i, j介於1至(p-1)之间
   所以，可以设g^y=x, g^t=a，则有：
   g^(y*N)%p=g^t
   又由原根的性质：
   g^(y*N)%p=g^t -> (y*N)%(p-1)=t (此方程可以由拓展欧几里得解)
   另外g^t=a可以由离散对数求出
  */
 vector<LL> residue(LL p, LL N, LL a){
     LL g = pri_root(p);
     g %= p;
     LL m = log_mod(g, a, p);
     vector<LL> ret;
     if(a == ){
         ret.PB();
         return ret;
     }
     if(m == -)
         return ret;
     LL A = N, B = p - , C = m, x, y;
     LL d = ext_gcd(A, B, x, y);
     if(C % d != ) return ret;
     x = x * (C / d) % B;
     LL delta = B / d;
     for(int i = ; i < d; ++i){
         x = ((x + delta) % B + B) % B;
         ret.PB(a_b_MOD_c(g, x, p));
     }
     sort(ret.begin(), ret.end());
     ret.erase(unique(ret.begin(), ret.end()), ret.end());
     return ret;
 }
 int main(){
     int cas = ;
     LL k,m,newx;
     while(scanf("%I64d%I64d%I64d",&k, &m, &newx)!=EOF){
         vector<LL> ans;
         ans = residue(m,k,newx);
         printf("case%d:\n",++cas);
         if(ans.size()==) puts("-1");
         for(int i = ; i < ans.size(); ++i)
             printf("%I64d\n",ans[i]);
     }
     return ;
 }