容斥原理部分例题及板子

最新推荐文章于 2025-07-12 17:07:20 发布

zsmj_sy

最新推荐文章于 2025-07-12 17:07:20 发布

阅读量571

点赞数

CC 4.0 BY-SA版权

分类专栏：组合数学数学数论容斥

本文链接：https://blog.youkuaiyun.com/neuq_zsmj/article/details/82946746

数学数论同时被 3 个专栏收录

20 篇文章

订阅专栏

组合数学

12 篇文章

订阅专栏

容斥

3 篇文章

订阅专栏

本文介绍了几个利用高精度计算和容斥原理解决的数论问题，包括求解一定范围内满足特定指数形式的数的数量、求解最大指数之和以及涉及质因子和最大公约数的问题。通过分析题意，转换思路，运用数学方法和算法，如高精度开根号、容斥原理中的奇加偶减策略，来解决这些竞赛题目。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

高精度开k次根号


ll pow_mul(ll x,ll k)
{
    ll ans=1;
    while(k)
    {
        if(k&1)
        {
            double judge=1.0*INF/ans;
            if(x>judge)return -1;
            ans*=x;
        }
        k>>=1;
        if(x>T&&k>0)return -1;
        x*=x;
    }
    return ans;
}

ll find(ll x,ll k)
{
    ll r=(ll)pow(x,1.0/k);
    ll p=pow_mul(r,k);
    if(p==x)return r;
    if(p>x||p==-1)r--;
    else
    {
        ll tmp=pow_mul(r+1,k);
        if(tmp!=-1&&tmp<=x)r++;
    }
    return r;
}

hdu 2204

https://vjudge.net/problem/HDU-2204

题意：求1到n中满足a=m^k的数量(m>=2) (n<=1e18)

假如k为合数，我们一定可以把它转为 m'^k'（k'为素数）的形式，所以我们只要考虑k为素数的情况

2^60>1e18,所以满足要求且在范围内的k最大不超过60。对于一个给定的n，我们求出最大的k，将所有小于等于k的素数全部放入vector中。当n和k给定时，所有满足a=m^k的数量就是m的最大值，也就是pow(n,1/k)，这个地方需要注意精度。

而对于一个数a，最多只有一组m^k是合法的，例如16=2^4=4^2，但k要取最大只能是2^4

所以这个地方需要容斥，奇加偶减

ll n;
vector<int>p;
bool check(int a)
{
    for(int i=2;i*i<=a;i++)
    {
        if(a%i==0)
        {
            return 0;
        }
    }
    return 1;
}

void get_prime(ll n)
{
    p.clear();
    for (int i = 2; i <= 65; i++)
    {
        if(!check(i))continue;
        if ((1ll << i )> n)
        {
            break;
        }
        p.push_back(i);
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);

    while(cin>>n)
    {
        ll ans=0;
        get_prime(n);
        int len=p.size();
        for(int i=1;i<(1ll<<len);i++)
        {
            ll mul=1;
            int flag=0;
            for(int j=0;j<len;j++)
            {
                if(i&(1<<j))
                {
                    mul*=p[j];
                    flag++;
                }
            }
            ll now=(ll)(pow((double)n,(1.0/mul))+eps);
            if(flag%2)
            {
                ans+=now;
            }
            else
            {
                ans-=now;
            }
        }
        cout<<ans<<endl;
    }

    return 0;
}

hdu 3208

https://vjudge.net/problem/HDU-3208

题意：求[a-b]中每个数可以被分解为m^k（k取最大）的最大指数之和

可以求1-n的最大指数之和，然后减一下。

设一个num数组，num[i]表示指数为i的数的数量，最后遍历乘i就得到了总数。

num[i]的求法和上一题很像，1-n中满足a=m^i的数量就是确定了n和i之后pow(n,1/k)这个地方要高精度开k次根。

最后需要倒着容斥，比如num[6]，num[2]和num[3]之中肯定包含num[6]，需要倒序循环在小的里面把大的减掉

最后在算num[i]的时候最后需要减掉1，题目说明了中不包含1

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <stack>
#include <map>
#include <cmath>
#include <unordered_set>
#include <vector>
#include <queue>
#define MP make_pair
#define PB emplace_back
#define fi first
#define se second
#define ZERO(x) memset((x), 0, sizeof(x))
#define ALL(x) (x).begin(),(x).end()
#define rep(i, a, b) for (repType i = (a); i <= (b); ++i)
#define per(i, a, b) for (repType i = (a); i >= (b); --i)
#define QUICKIO                  \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0);
using namespace std;
#define ll long long
const ll INF=1e18+5;
const ll T=1ll<<31;
#define eps 1e-8

ll pow_mul(ll x,ll k)
{
    ll ans=1;
    while(k)
    {
        if(k&1)
        {
            double judge=1.0*INF/ans;
            if(x>judge)return -1;
            ans*=x;
        }
        k>>=1;
        if(x>T&&k>0)return -1;
        x*=x;
    }
    return ans;
}

ll find(ll x,ll k)
{
    ll r=(ll)pow(x,1.0/k);
    ll p=pow_mul(r,k);
    if(p==x)return r;
    if(p>x||p==-1)r--;
    else
    {
        ll tmp=pow_mul(r+1,k);
        if(tmp!=-1&&tmp<=x)r++;
    }
    return r;
}
ll num[105];
ll solve(ll n)
{
    memset(num,0,sizeof(num));
    num[1]=n;
    int tot=0;
    for(int i=2;i<65;i++)
    {
        num[i]=find(n,i)-1;//减去不考虑的1
        if(num[i]==0)
        {
            tot=i;
            break;
        }
    }
    for(int i=tot-1;i>=1;i--)
    {
        for(int j=1;j<i;j++)
        {
            if(i%j==0)
            {
                num[j]-=num[i];//容斥掉重复的
            }
        }
    }
    ll ans=num[1];
    for(int i=2;i<=tot-1;i++)
    {
        ans+=i*(num[i]);
    }
    return ans;
}


int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);

    ll l,r;
    while (cin>>l>>r&&(l!=0&&r!=0))
    {
        //cout<<solve(r)<<endl;
        //if(l==r==0)return 0;
        ll ans=solve(r)-solve(l-1);
        cout<<ans<<endl;
    }



    return 0;
}

hdu 1796

https://vjudge.net/problem/HDU-1796

题意：给定n和一个有m个数的集合，输出共有多少数可以被集合中至少一个数整除

板子题，需要注意的是在容斥更新now值的时候是更新两个数的lcm，记得考虑集合中的数为0的情况。。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <stack>
#include <map>
#include <cmath>
#include <unordered_set>
#include <vector>
#include <queue>
#define MP make_pair
#define PB emplace_back
#define fi first
#define se second
#define ZERO(x) memset((x), 0, sizeof(x))
#define ALL(x) (x).begin(),(x).end()
#define rep(i, a, b) for (repType i = (a); i <= (b); ++i)
#define per(i, a, b) for (repType i = (a); i >= (b); --i)
#define QUICKIO                  \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0);
using namespace std;
#define ll long long
const ll INF=1e18+5;
const ll T=1ll<<31;
#define eps 1e-8


int n,m;
vector<int> vec;
ll work()
{
    //n--;
    ll ans=0,cnt;
    ll tem;
    for(int i=1;i<(1<<vec.size());i++)
    {
        cnt=0,tem=1;
        for(int j=0;j<vec.size();j++)
        {
            if(i&(1<<j))
            {
                tem=tem*vec[j]/__gcd((ll)tem,(ll)vec[j]);
                cnt++;
            }
        }
        if(cnt&1) ans+=(n-1)/tem;
        else ans-=(n-1)/tem;
    }
    return ans;
}


int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);

    while(cin>>n>>m)
    {
        vec.clear();
        int tem;
        //memset(s,0,sizeof(s));
        for(int i=1;i<=m;i++)
        {
            cin>>tem;
            if(tem>0)
            vec.push_back(tem);
        }
        for(int i=0;i<vec.size();i++)
        {
            if(vec[i]>n)
                vec.erase(vec.begin()+i);
        }
        ll ans=work();
        cout<<ans<<endl;
    }




    return 0;
}

hdu-2841

https://vjudge.net/problem#OJId=HDU&probNum=2841&title=&source=&category=all

题意：人在(0,0)，三点共线只能看见第一棵，问可以直接看到多少树

转换一下思路(1,2)可以看见，(2,4)就会被(1,2)挡住，也就是说(i,j)会被(i/gcd(i,j) , j/gcd(i,j))挡住，可以之间看到的树就是gcd(i,j)==1的点

转而求[1-n]中选一个a，[1-m]中选一个b，gcd(a,b)==1的组数

互质的不好求，转而去求不互质的，然后用总数减一下

先预处理所有数的质因子，假设较大的数为m，固定区间[1-m]

遍历循环n，对于每一个n，求其不互质的数的数量，然后奇减偶加。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <stack>
#include <map>
#include <cmath>
#include <unordered_set>
#include <vector>
#include <queue>
#define MP make_pair
#define PB emplace_back
#define fi first
#define se second
#define ZERO(x) memset((x), 0, sizeof(x))
#define ALL(x) (x).begin(),(x).end()
#define rep(i, a, b) for (repType i = (a); i <= (b); ++i)
#define per(i, a, b) for (repType i = (a); i >= (b); --i)
#define QUICKIO                  \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0);
using namespace std;
#define ll long long
const ll INF=1e18+5;
const ll T=1ll<<31;
#define eps 1e-8
#define N 100005
vector<int > prime_factor[N];
void init(){
    for(int i = 2; i < N; i ++){
        if(prime_factor[i].size() == 0){//如果i是质数
            for(int j = i; j < N; j += i){
                prime_factor[j].push_back(i);
            }
        }
    }
}

ll work(int n,int m)//固定区间[1-m]遍历n去求n在[1-m]之中有多少和其互质的数
{
    ll res=0;
    for(int i=1;i<=n;i++)//遍历n
    {
        ll ans=m;
        for(int j=1;j<(1<<prime_factor[i].size());j++)
        {
            ll now=1;
            int cnt=0;
            for(int k=0;k<prime_factor[i].size();k++)
            {
                if(j&(1<<k))
                {
                    now*=prime_factor[i][k];
                    cnt++;
                }
            }
            if(cnt&1)ans-=m/now;
            else ans+=m/now;
        }
        res+=ans;
    }
    return res;
}


int main()
{
    init();
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int n,m;
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n>>m;
        ll ans=0;
        int minn=min(n,m);
        int maxn=max(n,m);
        cout<<work(minn,maxn)<<endl;

    }




    return 0;
}

hdu 1695

https://vjudge.net/problem/HDU-1695

题意:在[1-b]和[1-d]之中找a和b满足gcd(a,b)==k的总组数，ab交换算一组

转换题意：在[1,b/k] [1,d/k]中找a和b满足 gcd(a,b)==1的总组数

这题和上题唯一不同的地方在于[a,b]交换算一组，分块处理，对于[1-n] [1-n]这块，就是求1-n的phi和

对于[1-n],[n+1,m]这块不存在重复，可以套用上一题的做法

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <stack>
#include <map>
#include <cmath>
#include <unordered_set>
#include <vector>
#include <queue>
#define MP make_pair
#define PB emplace_back
#define fi first
#define se second
#define ZERO(x) memset((x), 0, sizeof(x))
#define ALL(x) (x).begin(),(x).end()
#define rep(i, a, b) for (repType i = (a); i <= (b); ++i)
#define per(i, a, b) for (repType i = (a); i >= (b); --i)
#define QUICKIO                  \
    ios::sync_with_stdio(false); \
    cin.tie(0);                  \
    cout.tie(0);
using namespace std;
#define ll long long
const ll INF=1e18+5;
const ll T=1ll<<31;
#define eps 1e-8
#define N 100005
bool check[N];
int phi[N],prime[N],tot;
void eular()
{
    memset(check,0,sizeof(check));
    phi[1]=1;
    tot=0;
    for(int i=2;i<N;i++)
    {
        if(!check[i])
        {
            prime[tot++]=i;
            phi[i]=i-1;
        }
        for(int j=0;j<tot;j++)
        {
            if(i*prime[j]>N)break;
            check[i*prime[j]]=1;
            if(i%prime[j]==0)
            {
                phi[i*prime[j]]=phi[i]*prime[j];
                break;
            }
            else
            {
                phi[i*prime[j]]=phi[i]*(prime[j]-1);
            }
        }
    }
}


vector<int > prime_factor[N];
void init() {
    for(int i = 2; i < N; i ++){
        if(prime_factor[i].size() == 0){//如果i是质数
            for(int j = i; j < N; j += i){
                prime_factor[j].push_back(i);
            }
        }
    }
}

ll work(int n,int m)
{
    ll res=0;
    for(int i=n+1;i<=m;i++)//遍历n
    {
        ll ans=n;
        for(int j=1;j<(1<<prime_factor[i].size());j++)
        {
            ll now=1;
            int cnt=0;
            for(int k=0;k<prime_factor[i].size();k++)
            {
                if(j&(1<<k))
                {
                    now*=prime_factor[i][k];
                    cnt++;
                }
            }
            if(cnt&1)ans-=n/now;
            else ans+=n/now;
        }
        res+=ans;
    }
    return res;
}


int main()
{
    init();
    eular();
    /*for(int i=1;i<=10;i++)cout<<phi[i]<<' ';
    cout<<endl;*/
    ios::sync_with_stdio(false);
    cin.tie(0);cout.tie(0);
    int t;
    cin>>t;
    int a,b,c,d,k;
    for(int kase=1;kase<=t;kase++)
    {
        cin>>a>>b>>c>>d>>k;
        cout<<"Case "<<kase<<": ";
        if(k==0)
        {
            cout<<0<<endl;
            continue;
        }
        b=b/k;d=d/k;
        int minn=min(b,d);
        int maxn=max(b,d);
        ll ans=0;

        for(int i=1;i<=minn;i++)
        {
            ans+=phi[i];
        }//cout<<ans<<endl;
        ans+=work(minn,maxn);
        cout<<ans<<endl;
    }


    return 0;
}

以上基本上是容斥的铜牌，小于银牌的水平题目。。基本就是套个板子，然后魔改