HDU1695素数打表欧拉函数容斥原理（再看）

最新推荐文章于 2019-07-15 12:50:47 发布

Sky-J

最新推荐文章于 2019-07-15 12:50:47 发布

阅读量674

点赞数

分类专栏： ACM-数学题

ACM-数学题专栏收录该内容

35 篇文章 0 订阅

订阅专栏

转自：http://blog.csdn.net/shiren_bod/article/details/5787722

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

大体思路：

枚举[1..y]中每个数i 判断[1..min(x,i)]中有多少数与i互质，统计个数。（注意，枚举的是比较大的区间[1..y]）。

显然如果i是质数，则[1..min(x,i)]中与i互质的个数是全体的个数或者i-1个。（取决于x和i的大小）。

当i不是质数时，i分解质因数后，质因数的次数不影响结果。我们看另外那个区间有多少个和i不互质（减一下就好了），于是我们只要看另外那个区间中有多少个数是i质因数的倍数就好了。

区间[1..w]中 p的倍数显然有 w/p个。

我们枚举i的质因数利用容斥原理：

看另外那个区间有多少个数与i不互质。

容斥原理的具体如下：

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

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

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

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

题目意思好懂,在[1...b]中选x,在[1....d]中选y,使gcd(x,y)=k,求不重复的对数

有一个小小的变形:在[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的元素的数的个数.

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

[cpp]view plaincopyprint? 
   
 #include<iostream>  
 using namespace std;  
 const int MAXN = 100005;  
 int a, b, c, d, k;  
 __int64 euler[MAXN];    //存放每个数的欧拉函数值；  
 int num[MAXN];          //存放当前数的素因子个数；  
 int primes[MAXN][10];   //存放当前数的素因子；  
 void EulerPrime()   //筛选法，求每个数的素数因子 和 每个数的欧拉函数值；  
 {  
     int i, j;  
     euler[1] = 1;  
     for(i=2; i<MAXN; i++)  
     {  
         if( ! euler[i])  
         {  
             for(j=i; j<MAXN; j+=i)  
             {  
                 if( ! euler[j])  
                     euler[j] = j;  
                 euler[j] = euler[j] * (i - 1) / i;  
                 primes[j][num[j]++] = i;  
             }  
         }  
         euler[i] += euler[i-1];  
     }  
 }  
 __int64 dfs(int x, int b, int now)  //求不大于b的数中与now不互质的数的个数；  
 {                                   //dfs()的容斥原理  
     __int64 res = 0;  
     for(int i=x; i<num[now]; i++)//容斥原理来求A1并A2并A3.....并Ak的元素的数的个数.  
         res += b / primes[now][i] - dfs(i+1, b/primes[now][i], now);  
     return res;  
 }  
 int main()  
 {  
     int i, cs, t;  
     __int64 ans;  
     EulerPrime();  
     while(scanf("%d",&t) != EOF)  
     {  
         for(cs=1; cs<=t; cs++)  
         {  
             printf("Case %d: ",cs);  
             scanf("%d%d%d%d%d",&a,&b,&c,&d,&k);  
             if(k == 0)  
             {  
                 printf("0/n"); continue;  
             }  
             if(b > d)  
                 swap(b, d);  
             b /= k; d /= k;  
             ans = euler[b];   
             for(i=b+1; i<=d; i++)    //求 b+1—>d 之间  
                 ans += b - dfs(0, b, i);//0—>b 之间；用b减去与i不互质的数的个数得到  
             printf("%I64d/n", ans);  
         }  
     }  
     return 0;  
 }  

再来一个程序

#include <iostream>
#include <stdio.h>
#include <memory.h>
#include <math.h>
#include <vector>
using namespace std;

const int N = 100005;
typedef long long LL;
#define maxn 100005
LL phi[N];
vector<LL> link[N];
int vis[1000000 + 5], c;
LL prime[79000];
void get_prime()  //打印素数表模板
{
    int i, j, n, m;
    c = 0;
    n = 1000000;
    m = (int)sqrt(n + 0.5);
    memset(vis, 0, sizeof(vis));
    for (i = 2; i <= m; i++)
        if (!vis[i])
        {
            for (j = i * i; j <= n; j += i)
                vis[j] = 1;
        }
    for (i = 2; i <= n; i++)
        if (!vis[i])
            prime[c++] = i;
}


void get_PHI()  //模板  得到1->n之内 与n互质的数的个数  存入phi[n]
{
    int i, j;
    for (i = 1; i <= maxn; i++)
        phi[i] = i;
    for (i = 2; i <= maxn; i += 2)
        phi[i] /= 2;
    for (i = 3; i <= maxn; i += 2)
        if (phi[i] == i)
        {
            for (j = i; j <= maxn; j += i)
                phi[j] = phi[j] / i * (i - 1);
        }
}

void init()     //求每一个数的质因数，vector储存
{
    LL i, j, k;
    for (i = 1; i < N; i++) //求n的质因数  也是模板
    {
        k = i;
        for (j = 0; prime[j]*prime[j] <= k; j++)
        {
            if (k % prime[j] == 0)
            {
                link[i].push_back(prime[j]);
                while (k % prime[j] == 0)
                    k /= prime[j];
            }
            if (k == 1) break;
        }
        if (k > 1) link[i].push_back(k);
    }
}

LL make_ans(LL num, LL n)
//1到num中的所有数与n的m个质因子不互质的数的个数 注意是不互质哦    容斥原理
{
    LL ans = 0, tmp, i, j, flag;
    for (i = 1; i < (LL)(1 << link[n].size()); i++)
    {
        //用二进制来1,0来表示第几个素因子是否被用到,如m=3，三个因子是2,3,5，则i=3时二进制是011，表示第2、3个因子被用到
        tmp = 1, flag = 0;
        for (j = 0; j < link[n].size(); j++)
            if (i & ((LL)(1 << j))) //判断第几个因子目前被用到
                flag++, tmp *= link[n][j]; //第j个质因子link[n][j]
        if (flag & 1) //容斥原理，奇加偶减
            ans += num / tmp;
        else
            ans -= num / tmp;
    }
    return ans;
}


int main()
{
    LL i, a, b, c, d, k, sum, t, zz = 1;//longlong型的数据 可以用%I64d 来输入输出
    get_prime();
    get_PHI();
    init();
    scanf("%I64d", &t);
    while (t--)
    {
        scanf("%I64d %I64d %I64d %I64d %I64d", &a, &b, &c, &d, &k);
        if (k == 0 || k > b || k > d)
        {
            printf("Case %I64d: 0\n", zz++);
            continue;
        }
        if (b > d) swap(b, d); //保持d较大
        b /= k;
        d /= k;
        sum = 0;
        for (i = 1; i <= b; i++)
        {
            sum += phi[i];
        }
        for (i = b + 1; i <= d; i++)
        {
            sum += b - make_ans(b, i);
        }
        printf("Case %I64d: %I64d\n", zz++, sum);
    }

    return 0;
}

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

题目有比较恶心的一点，数据有k==0的，这时显然答案是0，没有2个数的gcd为0。

首先，gcd是没啥用的。因为约掉gcd后两个数互质。于是我们可以让x/=k y/=k并且假设 x<=y

然后题目变成了 2个数分别在区间[1..x]和[1..y]中的互质数有多少对。