POJ 3421 素数+组合数学

　　　　　　　　　　　　　　　　　　　　X-factor Chains

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 5741		Accepted: 1808

Description

Given a positive integer X, an X-factor chain of length m is a sequence of integers,

1 = X₀, X₁, X₂, …, X_m = X

satisfying

X_i < X_i+1 and X_i | X_i+1 where a | b means a perfectly divides into b.

Now we are interested in the maximum length of X-factor chains and the number of chains of such length.

Input

The input consists of several test cases. Each contains a positive integer X (X ≤ 2²⁰).

Output

For each test case, output the maximum length and the number of such X-factors chains.

Sample Input

2
3
4
10
100

Sample Output

1 1
1 1
2 1
2 2
4 6

Source

POJ Monthly--2007.10.06, ailyanlu@zsu

 

 

 

分析：

x=a1^p1*a2^p2*...*an^pn

由于要求构造的序列最长，我们从序列最后一个开始，每次除以x的一个素因子

而一共可以除以∑pi次，所以可以构造的最长的长度就是∑pi

而有多少种方式呢？

其实就等价于p1个a1,p2个a2,...,pn个an,可以有多少种排列方式

明显，有(∑pi) ! / (p1!*p2!*...*pn!)个排列。

 

 

预处理：打出素数表

 

但是这道题还是tle了2次，原因：

1.打素数表不够高效(现在的打表方式很好)

2.有个地方还可以有很大的优化，写在注释了

 

#include<cstdio>
#include<cstring>
#include<cmath>

using namespace std;

const int maxn=1050000;

bool is_prime[maxn];
int prime[maxn>>1];
int p[100];

void init_prime()
{
    memset(is_prime,true,sizeof is_prime);
    int i;
    is_prime[1]=false;
    for(i=4;i<maxn;i+=2)
        is_prime[i]=false;
    int e=(int)(sqrt(0.0+maxn)+1.0);
    int tot=1;
    prime[tot++]=2;
    for(i=3;i<e;i+=2)
    {
        if(is_prime[i])
        {
            prime[tot++]=i;
            int s;
            for(int j=i*i,s=2*i;j<maxn;j+=s)
                is_prime[j]=false;
            //因为i为奇数，j也为奇数，j+奇数为偶数，不用考虑
            //由于j<n,i*i<n,则i<sqrt(n)
        }
    }
    for(;i<maxn;i+=2)
        if(is_prime[i])
            prime[tot++]=i;
}

int main()
{
    init_prime();
    int x;
    while(~scanf("%d",&x))
    {
        if(x==1)
        {
            printf("0 0
");
            continue;
        }
        if(is_prime[x])
        {
            printf("1 1
");
            continue;
        }
        int cnt=1;
        int tot=0;
        while(x>1)
        {
            if(x%prime[cnt]==0)
            {
                tot++;
                p[tot]=0;
                while(x%prime[cnt]==0)
                {
                    x/=prime[cnt];
                    p[tot]++;
                }
            }
            cnt++;
        }
        
        /*
        刚开始的做法
        memset(p,0,sizeof p);
        while(x>1)
        {
            while(x%prime[cnt]==0)
            {
                x/=prime[cnt];
                p[cnt]++;
            }
        cnt++;
        }
        这样的做法，数组p在范围1~cnt会有很多的无谓的0
        大大增加了后面循环的次数
        而且数组p也必须开得很大
        这样tle了
        优化之后，数组p在范围1~tot没有0
        tot相对于cnt小了很多
        数组p也只要100就够了
        一个优化，从tle到125ms
        */
        
        int sum=0;
        for(int i=1;i<=tot;i++)
            sum+=p[i];
        long long ans=1;
        for(int i=2;i<=sum;i++)
            ans*=(long long)i;
        for(int i=1;i<=tot;i++)
        {
            for(int j=2;j<=p[i];j++)
                ans/=(long long)j;
        }
        printf("%d %lld
",sum,ans);
    }
    return 0;
}