题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6623
题意：对一个数质因数分解，求得到的指数项中最小的那个值，数字小于 ，数据总数小于50000
（这个数据出出来就是用来卡掉pollard-rho的

那么既然要卡掉pollard-rho，就必须考虑至少的算法了，比如我们只考虑所有在 内的质数然后对N进行质因数分解，复杂度就降到了。如果只做到这一步，就必须考虑额外的以下几种情况：（以下所有的满足）

1. ，即答案为4的情形
2. ，即答案为3的情形
3. 或者 ， 即答案为2的情形
4. ，即答案为1的情形

换句话说，如果把没有小于 的质因数，那么它必然属于以上四种情形之一

其中第四种情况可以用miller-rabin素性检验来判断

#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
#define FOR(i, x, y) for (decay<decltype(y)>::type i = (x), _##i = (y); i < _##i; ++i)
using namespace std;
using ll = long long;

const ll p_max = 3982;
ll pr[p_max], p_sz;
void get_prime()
{
    static bool vis[p_max];
    FOR(i, 2, p_max)
    {
        if (!vis[i])
            pr[p_sz++] = i;
        FOR(j, 0, p_sz)
        {
            if (pr[j] * i >= p_max)
                break;
            vis[pr[j] * i] = 1;
            if (i % pr[j] == 0)
                break;
        }
    }
}

ll bin(ll x, ll n, ll MOD)
{
    ll ret = MOD != 1;
    for (x %= MOD; n; n >>= 1, x = x * x % MOD)
        if (n & 1)
            ret = ret * x % MOD;
    return ret;
}

ll mul(ll u, ll v, ll p)
{
    return (u * v - ll((long double)u * v / p) * p + p) % p;
}

bool checkQ(ll a, ll n)
{
    if (n == 2 || a >= n)
        return 1;
    if (n == 1 || !(n & 1))
        return 0;
    ll d = n - 1;
    while (!(d & 1))
        d >>= 1;
    ll t = bin(a, d, n); // 不一定需要快速乘
    while (d != n - 1 && t != 1 && t != n - 1)
    {
        t = mul(t, t, n);
        d <<= 1;
    }
    return t == n - 1 || d & 1;
}

bool primeQ(ll n)
{
    static vector<ll> t = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
    if (n <= 1)
        return false;
    for (ll k : t)
        if (!checkQ(k, n))
            return false;
    return true;
}

ll factor[30], f_sz, factor_exp[30];
void get_factor(ll &x)
{
    f_sz = 0;
    // ll t = sqrt(x + 0.5);
    for (ll i = 0; pr[i] * pr[i] <= x && i < p_sz; ++i)
        if (x % pr[i] == 0)
        {
            factor_exp[f_sz] = 0;
            while (x % pr[i] == 0)
            {
                x /= pr[i];
                ++factor_exp[f_sz];
            }
            factor[f_sz++] = pr[i];
        }
    if (x > 1 && f_sz)
    {
        factor_exp[f_sz] = 1;
        factor[f_sz++] = x;
        x = 1;
    }
}

bool test2(ll val)
{
    ll t = ll(sqrt(val + 0.5) + 0.5);
    return (t * t == val);
}

bool test3(ll val)
{
    ll t = ll(pow(val + 0.5, 1.0 / 3) + 0.5);
    return (t * t * t == val);
}

bool test4(ll val)
{
    ll t = ll(sqrt(sqrt(val + 0.5)) + 0.5);
    return (t * t * t * t == val);
}

int main()
{
    get_prime();
    int round;
    scanf("%d", &round);
    while (round--)
    {
        ll val;
        scanf("%lld", &val);
        get_factor(val);
        if (primeQ(val))
        {
            puts("1");
        }
        else if (f_sz)
        {
            printf("%lld\n", *min_element(factor_exp, factor_exp + f_sz));
        }
        else
        {
            if (test4(val))
            {
                puts("4");
            }
            else if (test3(val))
            {
                puts("3");
            }
            else if (test2(val))
            {
                puts("2");
            }
            else
            {
                puts("1");
            }
        }
    }
}

素数筛，miller-rabin素性检验等部分来自 ECNU 退役队伍 F0RE1GNERS 的模板 https://github.com/zerolfx/template