HDU 5812 Distance

题目：Distance

链接：http://acm.hdu.edu.cn/showproblem.php?pid=5812

题意：定义d(x,y)是x 变成y 至少需要的操作次数，每一次操作可以乘以或除以一个质数（必须能整除）。现在，有一个集合s，初始为空，每一次有可能插入一个数（如果已经存在就无视），有可能删除一个数（如果没有就无视），有可能给出一个数x，问d(x,y)的最小值，y属于集合s，如果集合为空输出-1。

思路：

　　首先想到最普通的做法，对于每一次询问x，遍历集合中已经存在的数y，令num[i]为i 的质因子数目，那么d(x,y)=num[x/gcd(x,y)]+num[y/gcd(x,y)]，就是要加上y 独有的质因子，再减去x 独有的质因子。这里，num数组可以预处理，但每一次询问就要遍历集合中所有元素，时间复杂度高达O(n^2)，肯定是要超时的。

　　不过，从上面的做法可以得到启发，每一次询问x，我们可以枚举x 的约数g，然后对于集合中的y，d(x,y)=d(x,g)+d(g,y)。很容易想到，约数最多100万个，那么我们用d 数组保存每个约数到集合中的y 的最小变化次数（暂不考虑删除），然后枚举x 的所有约数（最多也就几十个），就可以计算出解，也就是 num[x/g]+d[g]。d 数组的维护就是在插入的时候进行的，比如插入x，枚举x 的所有约数g，d[g]=min(d[g],num[x/g])。当然，这是对付没有删除的情况下，有删除，肯定不能只保存最小的那个了。

　　不过，现在问题就很简单了，我们可以弄100万个类型为Node的优先队列，Node包含val（集合中已经存在的数），num（val到这个优先队列表示的约数i 的变化次数）排序方式就是num越小越好，再开一个标记数组u，初始化为0，u[i]=0就表示i 不存在，也就是说q[j]的队头，u[val]如果为0，那么说明val已经被删除，就不能充数，而是出队，继续判断下一个。

AC代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<map>
#include<queue>
using namespace std;
#define N 1000010
#define LL long long
#define INF 2147483647
int num[N]={0};
int prim[N],po=0;


int gcd(int a,int b)
{
  return b?gcd(b,a%b):a;
}
int min(int x,int y)
{
  return x<y?x:y;
}

int gg[N],go;
pair<int,int> bt[100000];
int bo;
void dfs(int i,int all)
{
  if(i==bo)
  {
    gg[go++]=all;
    return ;
  }
  int k=1;
  for(int j=0;j<=bt[i].second;j++)
  {
    dfs(i+1,all*k);
    k=k*bt[i].first;
  }
}

void fun(int x)
{
  bo=0;
  int i=0;
  while(i<po && prim[i]*prim[i]<=x)
  {
    int flag=0;
    bt[bo].second=0;
    while(x%prim[i]==0)
    {
      bt[bo].second++;
      flag=1;
      x/=prim[i];
    }
    if(flag==1) bt[bo++].first=prim[i];
    i++;
  }
  if(x!=1)
  {
    bt[bo].first=x;
    bt[bo++].second=1;
  }
  dfs(0,1);
}
bool u[N];
struct Node
{
  int num,val;
  bool friend operator < (Node a,Node b)
  {
    return a.num>b.num;
  }
};

priority_queue<Node> q[N];
int main()
{
  num[1]=0;
  for(int i=2;i<=N-10;i++)
  {
    if(!num[i])
    {
      num[i]=1;
      prim[po++]=i;
    }
    for(int j=0;j<=po && (LL)i*prim[j]<N;j++)
    {
      num[i*prim[j]]=num[i]+1;
    }
  }
  int n,cas=1;
  while(scanf("%d",&n)!=EOF)
  {
    if(n==0) break;
    char t[10];
    int x;
    printf("Case #%d:
",cas++);
    memset(u,0,sizeof(u));
    while(n--)
    {
      scanf("%s%d",t,&x);
      if(t[0]=='I')
      {
        if(u[x]==0)
        {
          go=0;
          fun(x);
          for(int i=0;i<go;i++)
          {
            Node tmp;
            tmp.num=num[x/gg[i]];
            tmp.val=x;
            q[ gg[i] ].push(tmp);
          }
        }
        u[x]=1;
      }
      else if(t[0]=='D')
      {
        u[x]=0;
      }
      else
      {
        go=0;
        fun(x);
        int mint=INF;
        for(int i=0;i<go;i++)
        {
          int mm=INF;
          int m=gg[i];
          while(q[m].size())
          {
            Node tmp=q[m].top();
            if(u[tmp.val]==0) q[m].pop();
            else
            {
              mm=tmp.num;
              break;
            }
          }
          if(mm==INF) continue;
          mint=min(mint,num[x/gg[i]]+mm);
        }
        if(mint==INF) printf("-1
");
        else printf("%d
",mint);
      }
    }
  }
  return 0;
}