hdu2421-Deciphering Password-（欧拉筛+唯一分解定理+积性函数+立方求和公式）

Deciphering Password

Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2357    Accepted Submission(s):
670

Problem Description

Xiaoming has just come up with a new way for
encryption, by calculating the key from a publicly viewable number in the
following way:
Let the public key N = A^B, where 1 <= A, B <=
1000000, and a₀, a₁, a₂, …, a_k-1 be
the factors of N, then the private key M is calculated by summing the cube of
number of factors of all ais. For example, if A is 2 and B is 3, then N =
A^B = 8, a₀ = 1, a₁ = 2, a₂ = 4,
a₃ = 8, so the value of M is 1 + 8 + 27 + 64 = 100.
However,
contrary to what Xiaoming believes, this encryption scheme is extremely
vulnerable. Can you write a program to prove it?

 

Input

There are multiple test cases in the input file. Each
test case starts with two integers A, and B. (1 <= A, B <= 1000000). Input
ends with End-of-File.
Note: There are about 50000 test cases in the input
file. Please optimize your algorithm to ensure that it can finish within the
given time limit.

Output

For each test case, output the value of M (mod 10007)
in the format as indicated in the sample output.

 

Sample Input

2 2
1 1
4 7

 

Sample Output

Case 1: 36 Case 2: 1 Case 3: 4393

 

翻译：输入a和b，n=a^b,求n的因子有哪些，这些因子又有多少个因子数，对于这些因子数的立方和累加

 

唯一分解定理

定义：任何一个数可以表示成 素数的次方 的乘积

分解公式： 

求N的因子个数公式 num=(a1+1)*(a2+1)*......*(an+1);

 

积性函数

对于任意互质的整数a和b有性质f(ab)=f(a)f(b)的数论函数。

 

素数的之间互质，素数的幂次方也互质

对于求因子个数，也是积性函数

素数的n次方有(n+1)个因子，并且这些因子的因子个数从1到n+1递增，这就可以套用1到n的立方和公式

比如3^4=81，因子有1，3，9，27，81

 1-1

 3-1,3

 9-1,3,9

27-1,3,9,27

81-1,3,9,27,81

AC代码：

注：这段代码比较玄，用c++提交WA，用g++提交能AC，中间有一句避免多次循环找大素数没有加上的话，c++提交WA，g++提交TLE

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<algorithm>
#include<string>
#include<vector>
#include<iostream>
#include<cstring>
#define inf 0x3f3f3f3f
using namespace std;
#define ll long long
const int p=;
const int maxx=1e6+;
ll a,b;
int prime[maxx];
bool vis[maxx];
int cnt;
void init()///欧拉筛
{
    cnt=;
    memset(vis,true,sizeof(vis));
    vis[]=vis[]=false;
    for(int i=;i<=maxx;i++)
    {
        if(vis[i])
            prime[cnt++]=i;
        for(int j=;j<cnt && prime[j]*i<=maxx;j++)
        {
            vis[ i*prime[j] ]=false;
            if( i%prime[j]== ) break;///prime[j]必定是prime[j]*i和i的最小质因子
        }
    }
}
ll sum(ll n)///立方和公式
{
   return ( (n*n+n)/ )%p * ( (n*n+n)/ )%p;
}

int main()
{
    init();
    int x=;
    while(scanf("%lld%lld",&a,&b)!=EOF)
    {
        ll ans=;
        if(vis[a])//a是素数，则直接求,节省时间
            ans=sum(+b);
        else
        {//prime[i]*prime[i]<=a;不加就会超时，大素数的因子一般只有一个，没必要一个一个找,也可以改成!vis[a],都是避免多次循环找大素数
            for(int i=; i<cnt && prime[i]*prime[i]<=a; i++)
            {
                int num=;
                if(a==) break;
                while(a%prime[i]==)
                {
                    a=a/prime[i];
                    num++;
                }
                if(num!=)
                {
                    ans*=sum(num*b+);//积性函数
                    ans%=p;
                }
            }
            if(a!=)///应对大素数的情况
            {
                ans*=sum(b+);
                ans%=p;
            }
        }
        printf("Case %d: %lld\n",++x,ans%p);
    }
    return ;
}
/*
手撸36=2^2 * 3^2  ans=(1^3 + 2^3 +3^3)^2=1296
36的因子有    1  2  3  4  6  9  12  18  36
对应的因子数  1  2  2  3  4  3  6   6   9
累加后也是1296
*/