HDU5812 Distance（枚举 + 分解因子）
题目
Source
http://acm.hdu.edu.cn/showproblem.php?pid=5812
Description
In number theory, a prime is a positive integer greater than 1 that has no positive divisors other than 1 and itself. The distance between two positive integers x and y, denoted by d(x, y), is defined as the minimum number of multiplications by a prime or divisions (without a remainder) by a prime one can perform to transform x into y. For example, d(15, 50) = 3, because 50 = 15 * 2 * 5 / 3, and you have to perform two multiplications (*2, *5) and one division (/3) to transform 15 into 50.
For a set S of positive integers, which is initially empty, you are asked to implement the following types of operations on S.
1. I x: Insert x into S. If x is already in S, just ignore this operation.
2. D x: Delete x from S. If x is not in S, just ignore this operation.
3. Q x: Find out a minimum z such that there exists a y in S and d(x, y) = z.
Input
The input contains multiple test cases. The first line of each case contains an integer Q (1 <= Q <= 50000), indicating the number of operations. The following lines each contain a letter ‘I’, ‘D’ or ‘Q’, and an integer x (1 <= x <= 1000000).
Q = 0 indicates the end of the input.
The total number of operations does not exceed 300000.
Output
For each case, output “Case #X:” first, where X is the case number, starting from 1. Then for each ‘Q’ operation, output the result in a line; if S is empty when a ‘Q’ operation is to perform, output -1 instead.
Sample Input
12
I 20
I 15
Q 30
I 30
Q 30
D 10
Q 27
I 15
D 15
D 20
D 30
Q 5
0
Sample Output
Case #1:
1
0
3
-1
分析
题目大概说，定义d(x,y)为x通过乘或除以质数变为y的最少运算次数。现在有一个集合，有插入一个数到集合的操作，也有从集合中删除一个数的操作，还有查询操作：输出最小的d(a,b)，a是所查询的数，b是集合中的任一数。
题解这么说的：
不难发现d(a, b) = f(a/gcd(a, b)) + f(b/gcd(a,b))，其中f(x)表示x的质因子个数. 因而当遇到操作Q x时，我们只需要枚举x的每个约数y，看属于当前集合的y的所有倍数z中f(z/y)的最小值为多少. 为了快速求出这个最小值，我们用C[y][s]表示当前集合中y的所有倍数z中使得f(z/y)=s的z的数量. 因为s的值不会超过20，所以可以用位压缩的方法，用D[y]表示y的倍数中哪些s值出现了，这样查询最小的s值可以通过位运算快速求出（因为时限是标程的3倍，所以也不会特意卡掉其它方法）. 插入和删除x时同样可以通过枚举x约数的方法来更新C[y][s]和D[y]的值. 设M表示元素的最大值，因为1到M所有约数的数量是O(MlogM)的，所以算法的时间和空间复杂度也都是O(MlogM)的. 又因为操作数少于M，所以实际情况还会更好一些.
首先是d(a, b) = f(a/gcd(a, b)) + f(b/gcd(a,b))，这个是显然的，而f(x)可以通过线性筛求得。
然后，对于每一个查询，枚举约数cd（注意，这个约数的个数在1000000内最多为128个，即2*3*5*7*11*13*17=510510的约数个数）。
- f(a/cd)这个能求得；而对于f(b/cd)，这个就需要在更新集合过程中做一些处理——
- 插入数x到集合时，同样也是枚举数x的约数d，然后把f(x/d)的值更新到各个约数d的信息中。对于从集合中删除数的操作同样反过来做。
- 于是对于各个cd，我们就能获得集合更新过程中最小的f(b/cd)。
更新集合维护各个约数最小的那个值，可以用官方题解说的那样，也能用网上其他题解用的multiset。
我都有尝试，代码见下。不过官方题解的做法我跑了1000多秒，写得太挫了吧。另外感觉，对一些东西都不敏感，约数个数，质因子个数等等其实都是很小的，没这种概念。
代码
multiset
#include<cstdio>
#include<cstring>
#include<set>
#include<algorithm>
using namespace std;
int prime_cnt[1000001],prime[1000001],pn;
bool vis[1000001];
multiset<int> mset[1000001];
void insert(int n){
if(vis[n]) return;
vis[n]=1;
for(long long i=1; i*i<=n; ++i){
if(n%i==0){
int tmp=n/i;
mset[i].insert(prime_cnt[tmp]);
if(tmp!=i) mset[tmp].insert(prime_cnt[i]);
}
}
}
void remove(int n){
if(!vis[n]) return;
vis[n]=0;
for(long long i=1; i*i<=n; ++i){
if(n%i==0){
int tmp=n/i;
mset[i].erase(mset[i].find(prime_cnt[tmp]));
if(tmp!=i) mset[tmp].erase(mset[tmp].find(prime_cnt[i]));
}
}
}
int query(int n){
int res=11111111;
for(long long i=1; i*i<=n; ++i){
if(n%i==0){
int tmp=n/i;
if(!mset[i].empty()){
res=min(res,prime_cnt[tmp]+*mset[i].begin());
}
if(tmp!=i && !mset[tmp].empty()) res=min(res,prime_cnt[i]+*mset[tmp].begin());
}
}
if(res==11111111) return -1;
return res;
}
int main(){
for(long long i=2; i<1000001; ++i){
if(!vis[i]) prime[pn++]=i,prime_cnt[i]=1;
for(int j=0; j<pn && i*prime[j]<1000001; ++j){
vis[i*prime[j]]=true;
prime_cnt[i*prime[j]]=prime_cnt[i]+1;
if(i%prime[j]==0) break;
}
}
int q,cse=0;
while(~scanf("%d",&q) && q){
printf("Case #%d:\n",++cse);
memset(vis,0,sizeof(vis));
for(int i=0; i<1000001; ++i) mset[i].clear();
while(q--){
char op; int a;
scanf(" %c",&op); scanf("%d",&a);
if(op=='I'){
insert(a);
}else if(op=='D'){
remove(a);
}else{
printf("%d\n",query(a));
}
}
}
return 0;
}
官方题解
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int prime_cnt[1000001],prime[1000001],pn;
bool vis[1000001];
int C[1000001][20],D[1000001];
void insert(int n){
if(vis[n]) return;
vis[n]=1;
for(long long i=1; i*i<=n; ++i){
if(n%i) continue;
int j=n/i;
++C[i][prime_cnt[j]];
D[i]|=(1<<prime_cnt[j]);
if(i!=j){
++C[j][prime_cnt[i]];
D[j]|=(1<<prime_cnt[i]);
}
}
}
void remove(int n){
if(!vis[n]) return;
vis[n]=0;
for(long long i=1; i*i<=n; ++i){
if(n%i) continue;
int j=n/i;
if(--C[i][prime_cnt[j]]==0) D[i]^=(1<<prime_cnt[j]);
if(i!=j && --C[j][prime_cnt[i]]==0) D[j]^=(1<<prime_cnt[i]);
}
}
int posi[1000001];
int query(int n){
int res=1111111;
for(long long i=1; i*i<=n; ++i){
if(n%i) continue;
int j=n/i;
if(D[i]){
res=min(res,prime_cnt[j]+posi[D[i]&-D[i]]);
}
if(D[j]){
res=min(res,prime_cnt[i]+posi[D[j]&-D[j]]);
}
}
if(res==1111111) return -1;
return res;
}
int main(){
for(long long i=2; i<1000001; ++i){
if(!vis[i]) prime[pn++]=i,prime_cnt[i]=1;
for(int j=0; j<pn && i*prime[j]<1000001; ++j){
vis[i*prime[j]]=true;
prime_cnt[i*prime[j]]=prime_cnt[i]+1;
if(i%prime[j]==0) break;
}
}
for(int i=0; i<20; ++i){
posi[1<<i]=i;
}
char op; int a;
int q,cse=0;
while(~scanf("%d",&q) && q){
printf("Case #%d:\n",++cse);
memset(vis,0,sizeof(vis));
memset(C,0,sizeof(C));
memset(D,0,sizeof(D));
while(q--){
scanf(" %c",&op); scanf("%d",&a);
if(op=='I'){
insert(a);
}else if(op=='D'){
remove(a);
}else{
printf("%d\n",query(a));
}
}
}
return 0;
}
