Description
B为一个正整数,如果一个自然数N的因子分解式中没有大于B的因子,我们就称N是一个B光滑数。请你编一个程序,求出某个区间中所有的B光滑数的个数。
Analysis
首先,打一个暴力,枚举n~n+m,找出每个数的最大质因子,不大于b就算上,输出答案。
不错,得了50分。
想到:b不一定是质数,所以要找到最接近b的质数。可以用欧拉线性筛。
接下来思考新的做法,递推递归是一个不错的选择。一开始我选择了尝试递推,发现:b光滑数一定包括b-1的光滑数,所以找到一个状态转移的方式:
B[i]=B[i-1]
上面说的并不准确,因为b-1不是质数,事实上b-1指的是b的前一个质数。
当然,状态转移不止这些,可以发现前n个数中的B光滑数除去B-1光滑数后只剩下B的倍数,而B的倍数除去所有B后一定是一个B-1光滑数,又可以得出:
B[a][b]=B[a][b-1]+B[a/b][b-1]+B[a/b/b][b-1]+...+B[1][b-1]
这个方程太长,能不能简化呢,可以。利用愤怒的小鸟(无限背包问题)思想可以发现,B[a/b][b]可能已经包含了b的n倍,所以只要由其转移而来即可。
B[a][b]=B[a][b-1]+B[a/b][b]
然而,直接递推完全存不下数组..所以放弃递推打起了递归。
思考一下边界问题:B[1][b]一定是1,B[a][1]也是1,对于B[a][b]当a<=b时,显然a个数都是b光滑数,所以边界已经确定好了。
85分!1WA2TLE,那么程序还存在问题,发现大量的状态重复运算,所以针对小规模数据进行记忆化(10000*3000)基本上足够。
95分!错了一个小点,应该是数据较大时想当然的处理在数据小时出现了错误,所以对于1000以内数据进行了暴力特判,过了。
Code 高于O(b·logbm)
#include <bits/stdc++.h>
#define ll long long
const ll N=1e6;
class B_Smooth_Number{
private:
int b;
ll B[10001][3001];
bool not_prime[N];
std::vector <ll> prime;
void Euler(){
for(ll i=2;i<N;i++){
if(!not_prime[i])
prime.push_back(i);
for(ll j=0;prime[j]*i<N&&j<prime.size();j++){
not_prime[prime[j]*i]=1;
if(!(i%prime[j]))break;
}
}
}
ll Search(ll s,ll f){
if(f==-1)return 1;
if(s<=prime[f])return s;
if(s<=10000&&f<=3000&&B[s][f])return B[s][f];
ll ans=Search(s,f-1)+Search(s/prime[f],f);
if(s<=10000&&f<=3000)B[s][f]=ans;
return ans;
}
public:
void Update(ll x){
Euler();
for(ll i=0;i<prime.size();i++)
if(prime[i]>x){
b=i-1;
return;
}
}
ll Query(ll x){
return Search(x,b);
}
}B;
int revolve(int x){
int s=0;
for(int i=2;i<=x;i++)
while(!(x%i)){
s=std::max(s,i);
x/=i;
}
return s;
}
int main(){
freopen("test.in","r",stdin);
freopen("test.out","w",stdout);
ll n,m,b;
scanf("%lld%lld%lld",&n,&m,&b);
if(n+m<1000){
int ans=0;
for(int i=int(n);i<=int(n+m);i++)
if(revolve(i)<=b)ans++;
printf("%d
",ans);
return 0;
}
B.Update(b);
printf("%lld
",B.Query(m+n)-B.Query(n-1));
return 0;
}