Mathematics:X-factor Chains(POJ 3421)

　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　X链条

　　题目大意，从1到N，1 = X₀, X₁, X₂, …, X_m = X中间可以分成很多数，另X_i < X_i+1 X_i 可以整除X_i+1 ，求最大长度m和m长度的链有多少条

　　思路：

　　很简单，只要把数分解质因数就可以了，最后链条的长度为质因数的个数，组合数为质因数个数的阶乘除以各自重复质因数的阶乘。还记得我发过的GCM和LCM反转的那道题吗，可以用pallord_rho算法分解质因数。

　　贴代码，第一个是最坑爹的，这一题会专门出数据坑Miller_Rabin算法，所以必须素数验证必须执行8次以上，不能用srand改变种子，否则你就是在和上帝玩骰子。

　　

#include <iostream>
#include <algorithm>
#include <functional>
#include <time.h>

using namespace std;
typedef long long LL_INT;

bool Miller_Rabin(const LL_INT);
LL_INT witness(const LL_INT,const LL_INT,const LL_INT);
void Find_Factors(const LL_INT, int *const, const int);
LL_INT Pallord_Rho_Theorem(const LL_INT, const int);
LL_INT Multi_Function(LL_INT,const LL_INT);
LL_INT gcd(LL_INT, LL_INT);

static LL_INT factors[10000], factors_num[10000]; 
static long long coe[23];
static int factors_sum[10000];

void Inivilize(void)
{
    coe[1] = 1;
    for (int i = 2; i <= 20; i++)
        coe[i] = coe[i - 1] * i;
}

int main(void)
{
    LL_INT x;
    long long chains_sum;
    int prime_sum, len, i;

    Inivilize();
    while (~scanf("%lld", &x))
    {
        prime_sum = 0; len = 0;
        if (x <= 1)
            printf("0 1
");
        else if (Miller_Rabin(x))//如果是素数，直接返回1 1
            printf("1 1
");
        else
        {
            Find_Factors(x, &prime_sum, 120);//120是经验值
            sort(factors, factors + prime_sum);
            factors_num[0] = factors[0]; 
            memset(factors_sum, 0, sizeof(factors_sum));
            factors_sum[0] = 1;
            for (i = 1; i < prime_sum; i++)
            {
                if (factors[i - 1] == factors[i])
                    factors_sum[len]++;
                else
                {
                    factors_num[++len] = factors[i];
                    factors_sum[len] = 1;
                }
            }
            chains_sum = coe[prime_sum];
            for (int i = 0; i <= len; i++)
                chains_sum /= coe[factors_sum[i]];
            printf("%d %lld
", prime_sum, chains_sum);
        }
    }
    return 0;
}

bool Miller_Rabin(const LL_INT n)
{
    if (n == 2)
        return true;//如果是2，就不用判断了
    else
    {
        for (int i = 0; i < 8; i++)
        {
            if (!(witness((LL_INT)(rand() % (n - 1)) + 1, n - 1, n) == 1))
                return false;
        }
        return true;
    }
}

LL_INT witness(const LL_INT coe, const LL_INT level, const LL_INT n)
{
    LL_INT y, x;
    if (level == 0)
        return 1;
    x = witness(coe, level >> 1, n);

    if (x == 0)
        return 0;
    y = (x*x) % n;
    if (y == 1 && x != 1 && x != n - 1)
        return 0;//费马小定理的运用
    if (level % 2 == 1)
        y = (coe*y) % n;

    return y;
}

void Find_Factors(const LL_INT n, int *const len, const int times)
{
    if (n == 1)
        return;
    else if (Miller_Rabin(n))
        factors[(*len)++] = n;
    else
    {
        LL_INT p = n;
        int c = times;
        while (p >= n)
            p = Pallord_Rho_Theorem(n, c--);
        Find_Factors(p, len, times);
        Find_Factors(n / p, len, times);
    }
}

LL_INT Pallord_Rho_Theorem(const LL_INT n, const int c)
{
    LL_INT x, y, k = 2, d;
    x = y = rand() % n;//随意取一个随机数

    for (int i = 1;; i++)
    {
        x = (Multi_Function(x, n) + c) % n;
        d = gcd(n, (y - x + n) % n);//计算|y-x|与n的最大公因数
        if (1 < d && d < n)
            return d;
        else if (y == x)
            return n;//相当于这个因数分解是失败的，所以直接返回n让外层循环继续
        else if (i == k)//brent判据，目的就是找到在偶数周期内找到gcd(x(k)-x(i/2))
        {
            y = x;//重新y=x,定义循环
            k <<= 1;
        }
    }
    return n;
}

LL_INT Multi_Function(LL_INT x,const LL_INT mod)
{
    LL_INT y = x, ans = 0;
    while (y)//计算y=x^2的取模算法
    {
        if (y & 1)
            ans = (ans + x) % mod;
        x = (x << 1) % mod;
        y >>= 1;
    }
    return ans;
}

LL_INT gcd(LL_INT a, LL_INT b)
{
    if (b == 0)
        return a;
    return gcd(b, a%b);
}

挺慢的，其实直接用筛法更快，先把表打好，然后再一个一个选就可以了，用筛法的话可以到100ms以内

#include <iostream>
#include <functional>
#include <algorithm>

using namespace std;

static bool primes[(1 << 20) + 5];
static int primes_set[500000];
static long long fact[22];

void Inivilize(int *const primes_sum)
{
    int i, j;
    primes[1] = primes[0] = 1;
    for (i = 2; i <= 1 << 20; i++)
    {
        if (!primes[i]) primes_set[(*primes_sum)++] = i;
        for (j = 2; j*i <= 1 << 20 && j <= i; j++)
        {
            if (primes[j] == 0)
                primes[j*i] = 1;
        }
    }
    fact[1] = 1;
    for (i = 2; i <= 21; i++)
        fact[i] = fact[i - 1] * i;
}

int main(void)
{
    int x, last, i, tmp_div_sum, tmp_last, longest_length, primes_sum = 0, prime_num;
    long long div_sum, chain_sum;
    Inivilize(&primes_sum);

    while (~scanf("%d", &x))
    {
        if (x == 1)
            printf("0 1
");
        else
        {
            div_sum = 1; last = x; longest_length = 0; 
            for (i = 0; last != 1; i++)
            {
                if (!primes[last])
                {
                    longest_length++;
                    break;
                }
                prime_num = primes_set[i];
                for (tmp_div_sum = 0, tmp_last = last; tmp_last%prime_num == 0;)
                {
                    if (!tmp_last) break;
                    tmp_last /= prime_num;
                    tmp_div_sum++; longest_length++;
                }
                last = tmp_last;
                if (tmp_div_sum)
                    div_sum *= fact[tmp_div_sum];
            }
            chain_sum = fact[longest_length];
            chain_sum /= div_sum;
            printf("%d %lld
", longest_length, chain_sum);
        }
    }
    return 0;
}