HDU1695 GCD 欧拉函数+容斥原理

Accepted

1695

187MS

9188K

 

题意：已知给定k,x,y求 1<=a<=x 1<=b<=y 中满足 gcd(a,b)=k 的(a,b)对数。（注意数对是无序的）。 1<=x,y<=1e5, 0<=k<=1e5

用到了欧拉函数,素因子分解,筛选法,组合数学上的容斥原理等,不失为一道好题!!!

 

大体思路：

有一个小小的变形:在[1...b/k]中选x,在[1....d/k]中选y,使gcd(x,y)=k,求不重复的对数

我们让d>=b;　　然后在[1....d/k]进行枚举,对于每一个i,我们只要在1...min(i-1,b)中找到与i互质数,记录个数,然后累加就得到结果了

当i<=b/k时,我们可以直接用欧拉函数计算出与i互质的个数　(当然要先进行因子分解,才能求欧拉函数)

当b/k<i<=d/k时,就比较难求了,我们用b/k减去与i不互质的数的个数得到,求与i不互质的数的个数时就用到容斥原理,设i的素因子分别的p1,p2...pk,则1..b/k中p1的倍数组成集合A1,p2的倍数组成集合A2,p3到A3.....pk到Ak,　由于集合中会出现重复的元素,　所以用容斥原理来求A1并A2并A3.....并Ak的元素的数的个数.

容斥原理的具体如下：

如果i因子个数num[i]为0，即i为素数，则区间中与i不互质的个数是0

否则，区间中与i不互质的个数 = （区间中i的每个质因数的倍数个数）-（区间中i的每两个质因数乘积的倍数）+（区间中i的每3个质因数的乘积的倍数个数）-（区间中i的每4个质因数的乘积）+...

    于是问题变成了统计每个数的不同质因数的个数而忽略次数。这个可以用筛法。具体做法如下：

    对每个数保存一个真质因数的列表。初始每个列表的长度为0。然后从2开始，分别检查每个数的列表长度，如果列表长度不为0，则这个数是合数，跳过；如果这个长度为0，则我们找到了一个质数，同时再把这个数的倍数（不包含本身）的列表里加入这个数。

代码

   
     

    
      
    
      #include
    
      <
    
      iostream
    
      >
    
      

    
      using
    
       
    
      namespace
    
       std;

    
      const
    
       
    
      int
    
       Max
    
      =
    
      100005
    
      ;
__int64 elur[Max];
    
      //
    
      存放每个数的欧拉函数值
    
      

    
      int
    
       num[Max];
    
      //
    
      存放数的素因子个数
    
      

    
      int
    
       p[Max][
    
      20
    
      ];
    
      //
    
      存放数的素因子
    
      

    
      void
    
       init()
    
      //
    
      筛选法得到数的素因子及每个数的欧拉函数值
    
      

    
      {
 elur[
    
      1
    
      ]
    
      =
    
      1
    
      ;
 
    
      for
    
      (
    
      int
    
       i
    
      =
    
      2
    
      ;i
    
      <
    
      Max;i
    
      ++
    
      )
 {
 
    
      if
    
      (
    
      !
    
      elur[i])
 {
 
    
      for
    
      (
    
      int
    
       j
    
      =
    
      i;j
    
      <
    
      Max;j
    
      +=
    
      i)
 {
 
    
      if
    
      (
    
      !
    
      elur[j])
 elur[j]
    
      =
    
      j;
 elur[j]
    
      =
    
      elur[j]
    
      *
    
      (i
    
      -
    
      1
    
      )
    
      /
    
      i;
 p[j][num[j]
    
      ++
    
      ]
    
      =
    
      i;
 }
 }
 elur[i]
    
      +=
    
      elur[i
    
      -
    
      1
    
      ]; 
    
      //
    
      进行累加（法里数列长度）
    
      

    
       }
}

    
      int
    
       dfs(
    
      int
    
       idx,
    
      int
    
       b,
    
      int
    
       now)
    
      //
    
      求不大于b的数中,与now不互质的数的个数;
    
      

    
      { 
    
      //
    
      dfs()写的容斥原理
    
      

    
       
    
      int
    
       ans
    
      =
    
      0
    
      ;
 
    
      for
    
      (
    
      int
    
       i
    
      =
    
      idx;i
    
      <
    
      num[now];i
    
      ++
    
      )
    
      //
    
      容斥原理来求A1并A2并A3.....并Ak的元素的数的个数.
    
      

    
       ans 
    
      +=
    
       b
    
      /
    
      p[now][i]
    
      -
    
      dfs(i
    
      +
    
      1
    
      ,b
    
      /
    
      p[now][i],now);
 
    
      return
    
       ans;
}


    
      int
    
       main()
{
 
    
      int
    
       t,a,b,c,d,k;
 init();
 scanf(
    
      "
    
      %d
    
      "
    
      ,
    
      &
    
      t);
 
    
      for
    
      (
    
      int
    
       ca
    
      =
    
      1
    
      ;ca
    
      <=
    
      t;ca
    
      ++
    
      )
 {
 scanf(
    
      "
    
      %d%d%d%d%d
    
      "
    
      ,
    
      &
    
      a,
    
      &
    
      b,
    
      &
    
      c,
    
      &
    
      d,
    
      &
    
      k);
 printf(
    
      "
    
      Case %d: 
    
      "
    
      ,ca);
 
    
      if
    
      (k
    
      ==
    
      0
    
      )
 {
 printf(
    
      "
    
      0\n
    
      "
    
      );
 
    
      continue
    
      ;
 }
 
    
      if
    
      (b
    
      >
    
      d)
 swap(b,d);
 b
    
      /=
    
      k; d
    
      /=
    
      k;
 __int64 ans
    
      =
    
      elur[b];
 
    
      for
    
      (
    
      int
    
       i
    
      =
    
      b
    
      +
    
      1
    
      ;i
    
      <=
    
      d;i
    
      ++
    
      )
 ans
    
      +=
    
      b
    
      -
    
      dfs(
    
      0
    
      ,b,i);
    
      //
    
      求不大于b的数中,与i不互质的数的个数
    
      

    
       printf(
    
      "
    
      %I64d\n
    
      "
    
      ,ans);
 }
 
    
      return
    
       
    
      0
    
      ;
}
   
     

 

这算是一道比较复杂的数论题了,参照了大牛的代码....没办法自己没有能力想出来。

参博地址：http://blog.csdn.net/shiren_Bod/archive/2010/08/04/5787722.aspx