PKU_campus_2018_H Safe Upper Bound

思路：

题目链接http://poj.openjudge.cn/practice/C18H/

用2147483647除以最大素因子。

这里用了Pollard_rho因子分解算法，模板参考了http://www.cnblogs.com/kuangbin/archive/2012/08/19/2646396.html

实现：

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <time.h>
 #include <iostream>
 #include <algorithm>
 #include <map>
 using namespace std;
 typedef long long ll;
 //****************************************************************
 // Miller_Rabin 算法进行素数测试
 //速度快，而且可以判断 <2^63的数
 //****************************************************************
 const int S = ;//随机算法判定次数，S越大，判错概率越小

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

 //计算  x^n %c
 ll pow_mod(ll x, ll n, ll mod)//x^n%c
 {
     if (n == ) return x % mod;
     x %= mod;
     ll tmp = x;
     ll ret = ;
     while (n)
     {
         if (n & ) ret = mult_mod(ret, tmp, mod);
         tmp = mult_mod(tmp, tmp, mod);
         n >>= ;
     }
     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 = ; i <= t; i++)
     {
         ret = mult_mod(ret, ret, n);
         if (ret ==  && last !=  && last != n - ) return true;//合数
         last = ret;
     }
     if (ret != ) return true;
     return false;
 }

 // Miller_Rabin()算法素数判定
 //是素数返回true.(可能是伪素数，但概率极小)
 //合数返回false;

 bool Miller_Rabin(ll n)
 {
     if (n < ) return false;
     if (n == ) return true;
     if ((n & ) == ) return false;//偶数
     ll x = n - ;
     ll t = ;
     while ((x & ) == ) { x >>= ; t++; }
     for (int i = ; i < S; i++)
     {
         ll a = rand() % (n - ) + ;//rand()需要stdlib.h头文件
         if (check(a, n, x, t))
             return false;//合数
     }
     return true;
 }

 //************************************************
 //pollard_rho 算法进行质因数分解
 //************************************************
 ll factor[];//质因数分解结果（刚返回时是无序的）
 int tol;//质因数的个数。数组小标从0开始

 ll gcd(ll a, ll b)
 {
     if (a == ) return ;
     if (a < ) 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 = , k = ;
     ll x0 = rand() % x;
     ll y = x0;
     while ()
     {
         i++;
         x0 = (mult_mod(x0, x0, x) + c) % x;
         ll d = gcd(y - x0, x);
         if (d !=  && d != x) return d;
         if (y == x0) return x;
         if (i == k) { y = x0; k += k; }
     }
 }
 //对n进行素因子分解
 void findfac(ll n)
 {
     if (Miller_Rabin(n))//素数
     {
         factor[tol++] = n;
         return;
     }
     ll p = n;
     while (p >= n) p = Pollard_rho(p, rand() % (n - ) + );
     findfac(p);
     findfac(n / p);
 }

 int main()
 {
     srand(time(NULL));//需要time.h头文件//POJ上G++不能加这句话
     ll n;
     while (scanf("%lld", &n) != EOF && n)
     {
         tol = ;
         findfac(n);
         sort(factor, factor + tol);
         ll ans = ((1ll << ) - ) / factor[tol - ];
         printf("%lld\n", ans);
     }
     return ;
 }