HDU 4910 / BC 3D Problem about GCD

首先打表，发现一部分是n-1其他是1

找规律发现，对于 素数的n次方 及 2倍素数的n次方 其结果是 n-1 （除2和4外 不能是2的n次方）

对于判断一个数是不是素数 直接米勒罗宾即可 对于判断是不是素数的n次方 有两种方法 

可以先判能否开平方和三次方 再暴力处理10^4之内素数即可

我直接套pollard_rho 分解质因数 发现不同质因数就否定

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<vector>
#include<list>
#include<set>
#include<map>
#include<stack>
#include<queue>
#include<deque>
#define mem(x,y) memset(x,y,sizeof(x))
#define pb push_back
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,double> pii;
#define bug puts("===========");
#define zjc puts("");
const double pi=(acos(-1.0));
const double eps=1e-8;
const ll INF=1e18+10;
const ll inf=1e9+10;
const int mod=1e9+7;
const int maxn=40000+10;
/*=======================================*/
const int S = 20; //随机算法判定次数，S越大，判错概率越小

//计算 (a*b)%c.   a,b都是long long的数，直接相乘可能溢出的
//  a,b,c <2^63
ll mult_mod(ll a, ll b, ll c) {
    a %= c;
    b %= c;
    ll ret = 0;
    while(b) {
        if(b & 1) {
            ret += a;
            ret %= c;
        }
        a <<= 1;
        if(a >= c)a %= c;
        b >>= 1;
    }
    return ret;
}

//计算  x^n %c
ll pow_mod(ll x, ll n, ll mod) { //x^n%c
    if(n == 1)return x % mod;
    x %= mod;
    ll tmp = x;
    ll ret = 1;
    while(n) {
        if(n & 1) ret = mult_mod(ret, tmp, mod);
        tmp = mult_mod(tmp, tmp, mod);
        n >>= 1;
    }
    return ret;
}

//以a为基,n-1=x*2^t      a^(n-1)=1(mod n)  验证n是不是合数
//一定是合数返回true,不一定返回false
bool check(ll a, ll n, ll x, ll t) {
    ll ret = pow_mod(a, x, n);
    ll last = ret;
    for(int i = 1; i <= t; i++) {
        ret = mult_mod(ret, ret, n);
        if(ret == 1 && last != 1 && last != n - 1) return true; //合数
        last = ret;
    }
    if(ret != 1) return true;
    return false;
}

// Miller_Rabin()算法素数判定
//是素数返回true.(可能是伪素数，但概率极小)
//合数返回false;
bool Miller_Rabbin(ll n) {
    if(n < 2)return false;
    if(n == 2)return true;
    if((n & 1) == 0) return false; //偶数
    ll x = n - 1;
    ll t = 0;
    while((x & 1) == 0) {
        x >>= 1;
        t++;
    }
    for(int i = 0; i < S; i++) {
        ll a = rand() % (n - 1) + 1; //rand()需要stdlib.h头文件
        if(check(a, n, x, t))
            return false;//合数
    }
    return true;
}


/*=========================================
    pollard_rho 算法进行大数质因数分解
=========================================*/

ll factor[100];//质因数分解结果（刚返回时是无序的）
int tot;//质因数的个数。数组小标从0开始

//计算 (a*b)%c.   a,b都是long long的数，直接相乘可能溢出的
//  a,b,c <2^63
int flag=0;

ll gcd(ll a, ll b) {
    if(a == 0) return 1;
    if(a < 0) return gcd(-a, b);
    while(b) {
        ll t = a % b;
        a = b;
        b = t;
    }
    return a;
}

ll Pollard_rho(ll x, ll c) {
    ll i = 1, k = 2;
    ll x0 = rand() % x;
    ll y = x0;
    while(1) {
        i++;
        x0 = (mult_mod(x0, x0, x) + c) % x;
        ll d = gcd(y - x0, x);
        if(d != 1 && d != x) return d;
        if(y == x0) return x;
        if(i == k) {
            y = x0;
            k += k;
        }
    }
}
//对n进行素因子分解
void findfac(ll n) {
    if(flag) return;
    if(Miller_Rabbin(n)) { //素数
        factor[tot++] = n;
        if(tot>1&&factor[tot-1]!=factor[tot-2]) flag=1;
        return;
    }
    ll p = n;
    while(p >= n) p = Pollard_rho(p, rand() % (n - 1) + 1);
    findfac(p);
    findfac(n / p);
}
bool go(ll n){
    if(Miller_Rabbin(n)) return 1;
    tot=0; flag=0;
    findfac(n);
    if(flag==0) return 1;
    return 0;
}
int main()
{
    ll n;
    while(~scanf("%I64d",&n)&&n!=-1){
        if(n%2==0){
            if(n==2||n==4) { printf("%I64d\n",n-1); continue; }
            if(n%4==0) {puts("1"); continue; }
        }
        if(n==1||go(n)||(n%2==0&&go(n/2))) printf("%I64d\n",n-1);
        else puts("1");
    }
    return 0;
}