原题

2000ms 256MB

Description

众所周知，时间复杂度为O( $\frac{1}{N}$ )的算法是不可能的，但是国奖爷就爱挑战不可能！现在国奖爷想发明一种时间复杂度为O( $\frac{1}{N}+\frac{1}{M}$ )的图论算法，并命名为“国奖爷算法”，但是他触碰到了瓶颈。现在，他已经发明了复杂度为O( $\frac{1}{\frac{1}{N}+\frac{1}{M}}$ )的算法，并命名为“爷奖国算法”，为了让他的研究更近一步，他需要求解一个“爷奖国方程”，即：

$\frac{1}{\frac{1}{N}+\frac{1}{M}}=T!$

其中， $T!=\prod_{i=1}^T i$

由于国奖爷实在是太厉害了，所以你只需要帮国奖爷精确算出这个“爷奖国方程”有多少对正整数解，国奖爷就能通过海量脑细胞精确算出每一组解，你能帮国奖爷挑战不可能吗？注意，(1,2)和(2,1)算两对解。

Input Description

输入一行一个正整数 $T$ ，含义由题目给出。其中 $1\leq T\leq10^7$

Output Description

输出一行一个正整数 $a n s w e r$ ，由于答案可能比较大，你只需要输出 $answer\enspace mod\enspace 19260817$ 。

Input Sample 1

1

Output Sample 1

1

Input Sample 2

2

Output Sample 2

3

Hint

在样例1中，对于T=1，T!=1，有解(2,2)。

在样例2中，对于T=2，T!=2，有解(3,6),(4,4),(6,3)。

题解

我们不妨设 $K = T!$ ，那么有:

$\frac{1}{\frac{1}{N}+\frac{1}{M}}=K\\ \\ \Leftrightarrow \frac{1}{N}+\frac{1}{M}=\frac{1}{K}\\ \\ \Leftrightarrow (N+M)K=NM\\ \\ \Leftrightarrow -(N+M)K+NM=0\\ \\ \Leftrightarrow K^2-(N+M)K+NM=K^2\\ \\ \Leftrightarrow (N-K)(M-K)=K^2\\$

显然， $(N ? K), (M ? K)$ 为 $K^2$ 的两个因子，所以答案即为 $K^2$ 的因子个数，即 ${(T!)}^2$ 的因子个数。

我们对 $T!$ 做质因子分解，有:

$T!=p_1^{k_1} \cdot p_2^{k_2} \cdots p_n^{k_n}\\ (T!)^2=p_1^{2k_1} \cdot p_2^{2k_2} \cdots p_n^{2k_n}\\$

那么 $T!)^2$ 的因子个数为:

$answer=(2k_1+1) \cdot (2k_1+1) \cdots (2k_n+1)\\$

现在我们考虑如何对 $T!$ 做质因子分解，对于一个质数 $X$ ，在 $[1, T]$ 中，有 $\lfloor \frac{T}{X} \rfloor$ 个数含有至少1个这个质因子，有 $\lfloor \frac{T}{X^2} \rfloor$ 个数含有至少2个这个质因子……

所以我们只需要先筛出T以内的质数，再对每个质数做上述处理计算T!中含有多少个这个质因子即可。

代码实现

首先，我们要筛出所有的质数，这里用线性筛法。

const int N=1e7+1;
const int M=19260817;

vector<int> prime;
bool notPrime[N];

void filte()
{
    for(int i=2;i<N;i++)
    {
        if(!notPrime[i])
        {
            //cout<<i<<endl;
            prime.push_back(i);
            for(long long j=1ll*i*i;j<N;j+=i)
            {
                notPrime[j]=true;
            }
        }
    }
}

然后，我们对每个质数计算 $T!$ 包含多少个因子。

long long LTZ_euqition(long long T)
{
    long long answer=1;
    int cnt=0;
    for(int X:prime)
    {
        if(X>T)break;
        long long x=X;
        while(x<=T)
        {
            cnt+=T/x;
            x*=X;
        }
        answer*=(2*cnt+1);
        answer%=M;
        cnt=0;
    }
    return answer;
}

下附完整实现

// by Concyclics
//
//
#include <iostream>
#include <vector>
using namespace std;

const int N=1e7+1;
const int M=19260817;

vector<int> prime;
bool notPrime[N];

void filte()
{
    for(int i=2;i<N;i++)
    {
        if(!notPrime[i])
        {
            //cout<<i<<endl;
            prime.push_back(i);
            for(long long j=1ll*i*i;j<N;j+=i)
            {
                notPrime[j]=true;
            }
        }
    }
}

long long LTZ_euqition(long long T)
{
    long long answer=1;
    int cnt=0;
    for(int X:prime)
    {
        if(X>T)break;
        long long x=X;
        while(x<=T)
        {
            cnt+=T/x;
            x*=X;
        }
        
        answer*=(2*cnt+1);
        answer%=M;
        cnt=0;
    }
    return answer;
}

int main()
{
    
    filte();
    int T;
    cin>>T;
    cout<<LTZ_euqition(T);
}