洛谷·bzoj·沙拉公主的困惑

初见安~由于个人喜好，这里是洛谷传送门：洛谷P2155

题目描述

大富翁国因为通货膨胀，以及假钞泛滥，政府决定推出一项新的政策：现有钞票编号范围为1到N的阶乘，但是，政府只发行编号与M!互质的钞票。房地产第一大户沙拉公主决定预测一下大富翁国现在所有真钞票的数量。现在，请你帮助沙拉公主解决这个问题，由于可能张数非常大，你只需计算出对R取模后的答案即可。R是一个质数。

输入格式：

第一行为两个整数T，R。R<=10^9+10，T<=10000，表示该组中测试数据数目，R为模 后面T行，每行一对整数N，M，见题目描述 m<=n

输出格式：

共T行，对于每一对N，M，输出1至N！中与M！素质的数的数量对R取模后的值

输入样例#1： 

1 11
4 2

输出样例#1： 

1

数据范围：
对于100%的数据，1 < = N , M < = 10000000

 

题解

首先——这道题很难。嗯对【啪！】

咳咳。很明显，整个题的意思说白了就是求1 ~ n！中与m！互质的数的个数。暴力找百分之百会爆，所以我们尝试着找通性——n！是m！的倍数（n > m），若存在x与m！互质，则x + k＊ｍ！也一定与ｍ！互质（ｋ为整数），所以这里就存在一个倍数关系——如果ｍ！内存在φ（ｍ！）个与ｍ！互质的数，则ｎ！内就存在ｎ！／ｍ！＊φ（ｍ！）个与ｍ！互质的数。

我们再继续尝试化简——φ（ｍ！），也就是欧拉函数（传送门：文末欧拉函数），我们知道：

其中p为x的质因数，一共有t个质因数。

所以我们直接套用这个公式就可以得到：

所以我们带入之前求出来的式子就可以约掉m！得到；

【p重名了，这里我们要取的模就是mod了】

到了这一步我们就可以暴力了【？！咳咳，其实还可以优化一下——因为1－１／ｐ1中涉及到分数，不太好计算，遇到个类似于1/3的就很容易精度不对，所以我们适当再处理一下——

这样化过后，我们还可以考虑一下优化——因为涉及到除法仍然精度不高，所以我们可以为了把p约掉，除以再乘上p的逆元（传送门建设中），变成：

【这里的p-1并不等于1/p】

至此——n！我们可以预处理，质因子可以预处理，逆元可以预处理，最后直接输出就行了。【撒花！！】

为什么要预处理，你看看T的范围就知道最坏会重复算的东西很多了。

下面展示在线算法——

#include<bits/stdc++.h>
#define maxn 10000005
using namespace std;
int mod, T, m, n;
long long stp[maxn + 100];
long long pri[500500], ans[maxn + 100], inv[maxn + 100], tot = 0;//这里要+100才够，我也不知道为什么
bool inpri[maxn + 100];
void prime()//处理质数，欧拉筛法
{
    for(int i = 2; i <= maxn; i++)
    {
        if(!inpri[i]) pri[++tot] = i;
        for(int j = 1; j <= tot && i * pri[j] <= maxn; j++)
        {
            inpri[i * pri[j]] = 1;
            if(i % pri[j] == 0) break;
        }
    }	
}

void stpon()//处理阶乘，可以边乘边模
{
    stp[1] = 1;
    for(int i = 2; i <= maxn; i++)
        stp[i] = stp[i - 1] * i % mod;
}

void niyuan()//求逆元
{
    inv[1] = 1;
    for(int i = 2; i <= maxn && i < mod; i++)
        inv[i] = (mod - mod / i) * inv[mod % i] % mod;
    
    ans[1] = 1;//顺便求答案
    for(int i = 2; i <= maxn; i++)
    {
        if(!inpri[i]) ans[i] = ans[i - 1] * (i - 1) % mod * inv[i % mod] % mod;
        else ans[i] = ans[i - 1];
    }
}

int main()
{
    scanf("%d%d", &T, &mod);
    prime();
    stpon();
    niyuan();
    while(T--)
    {
        scanf("%d%d", &n, &m);
        printf("%d\n", stp[n] * ans[m] % mod);//记得取余
    }
    return 0;
}

在洛谷上的话，这么写是可以过的（我也不知道为什么第一次交TLE了三个），但是我们可以发现：

910ms的简直就是铤而走险，数据再大一点儿就要TLE了。而我们预处理的时候也没有考虑到的：如果事实上m和n都挺小的，这样算反而浪费时间（尽管比暴搜好），所以更加支持离线算法，存储m和n，得到上限过后再来预处理。

下面是离线算法——

#include<bits/stdc++.h>//思路相同，就不注释了
#define maxn 10000001
using namespace std;
int mod, T, m[10003], n[10003], N = 0, tot = 0;
long long stp[maxn + 100];
long long pri[500500], ans[maxn + 100], inv[maxn + 100];
bool inpri[maxn + 100];
void prime()
{
	for(int i = 2; i <= N; i++)
	{
		if(!inpri[i]) pri[++tot] = i;
		for(int j = 1; j <= tot && i * pri[j] <= N; j++)
		{
			inpri[i * pri[j]] = 1;
			if(i % pri[j] == 0) break;
		}
	}	
}

void stpon()
{
	stp[1] = 1;
	for(int i = 2; i <= N; i++)
		stp[i] = stp[i - 1] * i % mod;
}

void niyuan()
{
	inv[1] = 1;
	for(int i = 2; i <= N && i < mod; i++)
		inv[i] = (mod - mod / i) * inv[mod % i] % mod;
	
	ans[1] = 1;
	for(int i = 2; i <= N; i++)
	{
		if(!inpri[i]) ans[i] = ans[i - 1] * (i - 1) % mod * inv[i % mod] % mod;
		else ans[i] = ans[i - 1];
	}
}

int main()
{
	scanf("%d%d", &T, &mod);
	for(int i = 1; i <= T; i++)
	{
		scanf("%d%d", &n[i], &m[i]);
		N = max(N, n[i]);
	}
	prime();
	stpon();
	niyuan();
	for(int i = 1; i <= T; i++)
	{
		printf("%lld\n", stp[n[i]] * ans[m[i]] % mod);
	}
	return 0;
}

 

这样的话显然我们还是可以优化出很多时间来的，大部分都在100ms以内了，甚至是10ms以内：）

当然那个915ms的就真的没办法了【#pragma开O2优化可以优化到700ms左右】，可能因为数据太大存取的时候时间耗得比多余预处理的时间长吧，但是还是能稳住更多的数据，所以建议离线。

就是这么一个可怕的题！！！！！！以上就是全部啦~

迎评：）
——End——