hdu 4407,4059,3501 容斥原理

最新推荐文章于 2018-10-17 12:23:46 发布
最新推荐文章于 2018-10-17 12:23:46 发布
阅读量538 收藏
点赞数
分类专栏： 数论 文章标签： 容斥原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/S1766434333/article/details/53306957
版权

hdu 3501 传送门：点击打开链接

题意：求小与整数n不互质的数的sum。

思路：这题有2种解法 

先说第一种；用容斥原理。与n不互质 ，即gcd(x,n)!=1，即  符合这样的数 都是n的素因子的倍数，所以我们先求出n的素因子，然后用容斥来求就可以了。这里我们对于 p（素数）的倍数的和 怎么求进行一下说明。我们知道  小于n并且是p的倍数 有  p,2*p,3*p,4*p.......[(n-1)/p]*p（注：这里中括号 代表向下取整），我们可以把p因子提出来那么 p*(1+2+3+4+5......+[(n-1)/p])   这就是求p的倍数 的和，而且我们发现 后面的式子正好可以用求和公式来求   那么就等于  (我们设[(n-1)/p]＝q)  sum=p*q*(q+1)/2,为什么用容斥呢？ 例如  n＝12，那么 他的素因子 有2，3，当我们求2的倍数sum时 算了3*2=6一次  ，而我们算3的倍数sum 也有2*3=6，如果在加那么就是2次了，所以要用到容斥。。

代码：

#include <iostream>
#include <cmath>
#include <cstring>
#define  rep(i,o,u) for(int i=(int)(o);i<=(int)(u);++i)
#define  clr(a,x)  memset(a,(x),sizeof(a))
using namespace std;
typedef long long  ll;
const ll mod=1000000007;
const int maxn=1e5;
int n;int cnt=0;int inde=0;
ll data[100];
bool mark[maxn];
int prime[maxn];
void Prime()
{
    clr(mark,0);
    rep(i,2,maxn)
    {
        if(!mark[i])
            prime[inde++]=i;
        rep(j,0,inde-1)
        {
            if(i*prime[j]>=1e5-2)
                break;
            mark[i*prime[j]]=1;
            if(i%prime[j]==0)
                break;
        }
    }
}
void solve()
{
    cnt=0;
    int t=n;
    rep(i,0,inde-1)
    {
        if(prime[i]*prime[i]>t)
            break;
        if(t%prime[i]==0)
        {
            data[cnt++]=prime[i];
            while(t%prime[i]==0)
                t/=prime[i];
        }
    }
    if(t!=1)
        data[cnt++]=t;
    int e=1<<cnt;ll ans=0;
    rep(i,1,e-1)
    {
        int num=0;ll tmp=1;
        rep(j,0,i)
        {
            if((1<<j)&i)
            {
                ++num;
                tmp*=data[j];
            }
            if((1<<j)>i)
                break;
        }

        if(num&1)
        {
            ll t=(n-1)/tmp;
            if(t%2==0)
                ans+=((t/2*(t+1))%mod)*tmp%mod;
            else
                ans+=(((t+1)/2)*t%mod)*tmp%mod;
        }
        else
        {
            ll t=(n-1)/tmp;
            if(t%2==0)
                ans-=((t/2*(t+1))%mod)*tmp%mod;
            else
                ans-=(((t+1)/2)*t%mod)*tmp%mod;
        }
    }
    //cout<<n<<" "<<(ans+mod)%mod<<endl;
    cout<<(ans%mod+mod)%mod<<endl;
}
int main(int argc, const char * argv[])
{
    Prime();
    while(cin>>n,n)
    {
        solve();
    }
    return 0;
}

第二种 比第一种简单：我们先求出 与n互质的sum ，用后用n*(n+1)/2-sum就是我们要求的答案了，sum可以根据欧拉函数的应用就可以求， 即 sum=n*phi(n)/2;

首先我们先证明   如果 gcd(i,n)=1那么 gcd(n-i,n)=1.

我们可以用反证法，设 gcd(i,n)=1,gcd(n-i,n)!=1, 因为  gcd(n-i,n)=k,k>1 ，我们可以知道 k整除n,同时 k整除(n-i),有以上所知再通过整除的性质，k也整除i，与gcd(i,n)=1矛盾  证毕。

所以我们知道  i与n互质,n-i也与n互质 ，所以他们的和 为n，我们就可以n*互质的组数＝sum,组数 就可以欧拉函数 可以求出 phi(n)/2,所以可以得到上式 sum=n*phi(n)/2;

代码：

#include <iostream>
#include <cstring>
#include <cmath>
#define rep(i,u,o) for(int i=(int)(u);i<=(int)(o);++i)
using namespace std;
typedef long long ll;
ll n,m;int tol;
const ll mod=1e9+7;
ll phi()
{
    ll rea=n;
    rep(i,2,sqrt(n))
    {
        if(n%i==0)
        {
            rea=rea-rea/i;
            while(n%i==0)
                n/=i;
        }
    }
    if(n>1)
        rea=rea-rea/n;
    return rea;
}
int main(int argc, const char * argv[])
{
    while(cin>>n,n)
    {
        m=n;
        cout<<(((m*(m-1)/2)%mod-(phi()*m/2)%mod)+mod)%mod<<endl;
    }
    return 0;
}

hdu 4407题目传送门： 点击打开链接

题意：求一个区间 [x,y]与p互质sum,其中区间的数可以改动。

思路：这题就是上题的思路，然后加了几步改动数据，求区间的sum，首先我们可以看到题中的m<=1000，也就是说 改动的操作很少 ，所以我们先保存改动的操作，然后求区间的和的时候我们先求出原来[x,y]的符合题意的sum，这里我们可以用上题的思路求和  ，我们知道[x,y] 的sum＝[1,y]的sum－[1,x-1]的sum 就可以了 ，那么对于这个区间改动的数据怎么办，我们可以暴力判断 是否符合条件 反正m<=1000。

代码：

#include <iostream>
#include <cstring>
#include <map>
#define  rep(i,o,u) for(int i=(int)(o);i<=(int)(u);++i)
#define  rrep(i,o,u) for(int i=(int)(o);i>=(int)(u);--i)
#define  clr(a,x)  memset(a,(x),sizeof(a))
using namespace std;
typedef long long  ll;
const int maxn=1e3+100;
const int MAXSIZE=1e3;
bool Mark[MAXSIZE+100];
int prime[maxn];
int inde=0,num;ll data[100];
ll n,m;
int gcd(int a,int b)
{
    return b?gcd(b,a%b):a;
}
void Prime()
{
    clr(Mark,0);
    rep(i,2,MAXSIZE)
    {
        if(!Mark[i])
            prime[inde++]=i;
        rep(j,0,inde-1)
        {
            if(prime[j]*i>=MAXSIZE)
                break;
            Mark[i * prime[j]] = 1;
            if(i%prime[j]==0)
                break;
        }
    }
}
void fprime(ll a)
{
    num=0;
    rep(i,0,inde-1)
    {
        if(prime[i]*prime[i]>a)
            break;
        if(a%prime[i]==0)
        {
            data[num++]=prime[i];
            while(a%prime[i]==0)
                a/=prime[i];
        }
    }
    if(a!=1)
        data[num++]=a;
}
void solve()
{
    map<ll,ll> mp;
    ll t,a,b;
    cin>>n>>m;
    while(m--)
    {
        cin>>t;
        if(t==2)
        {
            cin>>a>>b;
            mp[a]=b;
        }
        else
        {
            ll p;
            cin>>a>>b>>p;
            fprime(p);
            int e=1<<num;ll ans=0;
            rep(i,1,e-1)
            {
                int nn=0;ll tt=1;
                rep(j,0,i)
                {
                    if((1<<j)>i)
                        break;
                    if((1<<j)&i)
                    {
                        ++nn;
                        tt*=data[j];
                    }
                }
                if(nn&1)
                {
                    ll b1=(ll)b/tt,a1=(ll)(a-1)/tt;
                    ans=ans+b1*(b1+1)/2*tt-a1*(a1+1)/2*tt;
                }
                else
                {
                    ll b1=b/tt,a1=(a-1)/tt;
                    ans=ans-b1*(b1+1)/2*tt+a1*(a1+1)/2*tt;
                }
               // cout<<ans<<endl;
            }
            ans=(b-a+1)*(a+b)/2-ans;
            for(auto it=mp.begin();it!=mp.end();++it)
            {
               // cout<<it->first<<" "<<it->second<<endl;
                if(it->first>=a&&it->first<=b)
                {
                    if(it->first>b)
                        break;
                    if(gcd(it->first,p)==1)
                        ans-=it->first;
                    if(gcd(it->second,p)==1)
                    ans+=it->second;
                }
            }
            cout<<ans<<endl;
        }
    }
}
int main(int argc, const char * argv[])
{
    ios::sync_with_stdio(false);
    int t;
    cin>>t;
    Prime();
    while(t--)
    {
        solve();
    }
    return 0;
}

hdu 4059题目传送门： 点击打开链接

题意：求与每个n互质的四次方的和

思路：这题就是3501 的变形 ，我们先算  不互质的四次方和，然后总的－sum就可以，3501是提出p 这里我们可以提出p^4 .这里我们要知道 1+2^4+3^4..  的求和公式

即n*(n+1)*(2*n+1)*(3*n^2+3*m-1)/30    因为取余 我们还要求出 30的逆元就可以了

代码：

#include <iostream>
#include <cstring>
#include <cmath>
#define rep(i,o,u) for(int i=(int)(o);i<=(int)(u);++i)
#define clr(a,x) memset(a,(x),sizeof(a))
using namespace std;
typedef long long  ll;
const int MAXSIZE=1e5;
const int maxn=1e5;
const int mod=1e9+7;
bool Mark[MAXSIZE+100];
int prime[maxn];
int inde=0,num;ll data[100];
ll xx,yy;
void ex_gcd(ll a,ll b,ll &x,ll& y)
{
    if(!b)
    {
        x=1,y=0;
        return;
    }
    ll x1,y1;
    ex_gcd(b,a%b,x1,y1);
    x=y1,y=x1-(a/b)*y1;
}
void Prime()
{
    clr(Mark,0);
    rep(i,2,MAXSIZE)
    {
        if(!Mark[i])
            prime[inde++]=i;
        rep(j,0,inde-1)
        {
            if(prime[j]*i>=MAXSIZE)
                break;
            Mark[i * prime[j]] = 1;
            if(i%prime[j]==0)
                break;
        }
    }
}
void fprime(int a)
{
    num=0;
    rep(i,0,inde-1)
    {
        if(prime[i]*prime[i]>a)
            break;
        if(a%prime[i]==0)
        {
            data[num++]=prime[i];
            while(a%prime[i]==0)
                a/=prime[i];
        }
    }
    if(a!=1)
        data[num++]=a;
}
void solve()
{
    ll n;
    cin>>n;
    if(n==1)
    {
        cout<<0<<endl;
        return;
    }
    fprime((int)n);
    ll ans=0;
    int e=1<<num;
    rep(i,1,e-1)
    {
        ll tmp=1;int nn=0;
        rep(j,0,i)
        {
            if((1<<j)>i)
                break;
            if((1<<j)&i)
            {
                ++nn;
                tmp*=data[j];
            }
        }
        ll tt=1;
        rep(j,0,3)
            tt=tt*tmp%mod;
        ll m=n/tmp;
        tmp=(((((m%mod)*(m+1)%mod)*((2*m%mod)+1)%mod)*((3*m%mod*m%mod)+3*m%mod-1)%mod)*xx%mod)*tt%mod;
        if(nn&1)
            ans=(ans+tmp)%mod;
        else
            ans=(ans-tmp)%mod;
    }
    ll sum=((((n%mod)*(n+1)%mod)*((2*n%mod)+1)%mod)*((3*n%mod*n%mod)+3*n%mod-1)%mod)*xx%mod;
    //cout<<(sum+mod)%mod<<endl;
    cout<<((sum-ans)%mod+mod)%mod<<endl;
}
int main(int argc, const char * argv[])
{
    ios::sync_with_stdio(false);
    Prime();
    ex_gcd((ll)30,(ll)mod,xx,yy);
    xx=((xx%mod)+mod)%mod;
    int t;
    cin>>t;
    while(t--)
    {
        solve();
    }
    return 0;
}


自ran而然
关注
专栏目录
HDU 4407 Sum（容斥原理+质因数分解）
a novice
08-24 1297
HDU 4407题意：给一个长度为n的序列，序列由1~n依次组成。 对序列执行两种操作： 1.查询[x,y]内与p互素的数的和； 2.修改第x数为c.思路：往线段树的方向想了半天，发现就是容斥原理略微变形，脑残不可医啊。。修改操作可以用map进行映射。查询操作的话我们就把序列一直当做1~n的序列来查询，然后迭代器跑一遍map判断对查询有无影响即可，总之操作最多2000次； 对于查询操作，我们
hdu 4407 Sum (容斥原理)
ACM之梦
03-23 600
题意： 对于一个序列原来是1~n，现在又两个操作，操作1、给定区间[l,r]求这个区间中与p互质的数的个数；操作2、将区间的第i个数变成a。 题解： 如果没有替换的操作，对于求某个区间与p互质的个数，可以分别求[1,l]和[1,r]的，然后相减。对于求某个区间的数是否与p互质，明显不好求，那么我们可以求不互质的个数，不互质的个数就是p的质因子倍数的个数，这个显然要用容斥来计算，在计算时我们要
4407: 于神之怒加强版 莫比乌斯反演+线性筛积性函数
ws_fqk
03-02 790
好虚。。不会做啊 Ans=∑ni=1∑mj=1gcd(i,j)kAns=\sum_{i=1}^n\sum_{j=1}^mgcd(i,j)^k，我们考虑枚举公约数dd，然后令f(d)f(d)表示gcd(i,j)=dgcd(i,j)=d的数对(i,j)(i,j)的数量，然后莫比乌斯反演可得f(d)=∑⌊nd⌋x=1μ(x)⌊ndx⌋⌊mdx⌋f(d)=\sum_{x=1}^{\lfloor\frac{
hdu 4407 SUM（容斥原理）
小G的ACM之路
09-25 901
题意： 有一个元素为 1~n 的数列AnA_n，有2种操作（最多1000次）： 1. 求某段区间 [a,b][a,b] 中与 pp 互质的数的和。 2. 将数列中某个位置元素的值改变。 解析： 刚刚开始的时候想成线段树了，看了题解才明白是用容斥原理来做。 对于操作1，解的性质满足区间减法，则我们只需要考虑如何求 [1,n][1,n] 中与 pp 互质的数的和即可。 由
HDU 4407 Sum(容斥原理)
GODSPEED
08-23 722
 题意：一个元素为 1~n 的数列{An}，有2种操作（1000次）： 1、求某段区间 [a,b] 中与 p 互质的数的和。 2、将数列中某个位置元素的值改变。 思路：先预处理求出1到400000所有数的质因子保存起来。 这个问题可以转化为求[1,R]之间与p不互素的数的和，这个可以用容斥原理来做，然后用区间和减去这个值就是答案，这是静态的做法。 如果有修改的话
hdu 4407 Sum (容斥原理）
Jiandong
10-17 231
题目链接：hdu 4407   题意： 给一个长度为n的序列，序列由1~n依次组成。  对序列执行两种操作：  1.查询[x,y]内与p互素的数的和；  2.修改第x数为c.   题解： 这题我们可以先不管操作2，就按操作1去搞，因为数据很小，完全可以暴力解决操作2带来的问题， 那么我们可以求[1,n]内与p互素的和，最后结果就为 solve[1,y]-solve[1,x-1]，再处...
HDU 4407 Sum （容斥原理）
ok_again的专栏
09-05 1331
这题难点就是看出来用容斥原理做，可以先分析时间复杂度大致确定用我已知的数据结构做不了。。。我们会发现刚开始数据是1-n，如果不做任何修改的话，只查询的话的确可以用容斥原理做，就是把p质分解，然后没有p质因数的元素就是与p互质的元素，于是就很容易用容斥原理做了。但是有了修改操作，我们发现一旦做出了修改就没办法用上述方法做了。但是仔细考虑发现修改次数最多不会超过1000，于是我们可以先用容斥原理算出未
hdu4407 Sum（容斥原理）
acmer的随记
05-09 353
题意：已知序列1,2…n。存在两个操作 1,x,y,p：统计[x,y]位置区间内有多少个元素与p互素 2,x.c：将x位置上的数改成c n<=400000，操作数m<=1000 解法：由于操作数较小，所以先处理未操作的结果，然后再考虑数字置换后结果的该变量。
HDU1695 GCD(容斥原理)
riba2534的博客
01-30 384
Problem Description Given 5 integers: a, b, c, d, k, you’re to find x in a…b, y in c…d that GCD(x, y) = k. GCD(x, y) means the greatest common divisor of x and y. Since the number of choices
hdu 1695 GCD（欧拉函数+容斥原理）.docx
10-29
"hdu 1695 GCD（欧拉函数+容斥原理）" 题目大意是：给定 a, b, c, d, k，找到一队 x, y，满足 g(x, y) = k，且 x ∈ [1, b], y ∈ [1, d]，问有多少对符合要求的 (x, y)。 思路是：gcd(x, y) == k 解释 x, y 都能...
HDU - 4135 Co-prime (容斥原理典型题)
hyesuixin的博客
08-21 536
题目描述：点击打开链接题意给定一个区间[a,b]，求区间内有少个数与n互质。题意很简单但是不是很好处理，a,b的数据范围很大，肯定不能够直接遍历，欧拉函数也不很好解决这个问题，我们把这个问题转换一下，互质的数是没有规律可循的，只能一个一个找，但是不互质的数就不一样了，如果将n因式分解，假设可以得到三个因子p1,p2,p3的话，那么p1,p2,p3的倍数肯定是与n不互质的，而n以内一个数的倍数的个数...
hdu 5317 (普通素数筛的应用)+(前缀和预处理)
一切顺其自然
10-28 745
RGCDQ  Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 2917    Accepted Submission(s): 1126 Problem Description Mr. Hdu is interest
CodeForces - 615D Multipliers 费马小定理＋组合数学
一切顺其自然
11-04 568
题目传送门：点击打开链接 题意：求出整数n的所有因子的乘积对1e9+7的模。 从题目中的给出的例子1·2·3·6 = 36  可以看出前面的式子可以写成 （1*6)*(2*3)=6*6=36,而n＝6，所以我们可以想到答案可以是 (n)^m这种类型。m＝n的因子个数除以2. 那么n的因子个数怎么求呢？根据题目给的数据，我们可以知道n的素因子种类可相应的个数，那我们可以假设 n的一个素因子为p
hdu 5768 Lucky7 容斥原理 中国剩余定理
一切顺其自然
11-28 536
题目传送门：点击打开链接 题意：给你区间[a,b],在这区间里 找出 既是7的倍数 x，并且 x%pi!=ai的个数 有多少？ 思路：看到这题  跟模有关系  大概跟 中国剩余定理有关，可是题目说的 只要 符合 x%pi=ai一项 就不能算个数，所以只是中国剩余定理 不可行的，那么我们只有一个一个 求出个数，然后再用7的倍数的个数－求出的个数，可是 一个一个求这会有重复的，所以我们 就要用到容
HDU 4569 Special equations 枚举
一切顺其自然
06-02 505
点击打开链接 本题的意思：已知f(x) = a nx n+...+ a 1x +a 0  ，整数m,m一个素数的平方。求出x使f(x) mod (m)＝0; 给出a nto a 0，(0 = 3, otherwise abs(a i) 解题思路：直接枚举(1-1e8)的话会超时 因为m＝pri*pri,且 m|f(x)，那么pri| f(x)，所以我们从0-pre-1枚举x0是否符合
HDU 4565 So Easy!
一切顺其自然
06-02 452
点击打开链接 本题题意： 给出整数a,b,n,m求出Sn。 l0 解题思路： 因为a，b，n很大所以如果直接求(a+sqrt(b))^n会爆double范围 所以只能对公式化简。由题中b的范围为(a-1) 2 代码： #include #include #include using namespace std; typedef long long ll; const dou
POJ 3904 HDU 5072 容斥原理
一切顺其自然
11-29 380
poj 3904 点击打开链接     hdu 5072 点击打开链接 poj  3904 题意 ：在给出的n个数中，找出4个数 符合gcd(a,b,c,d)=1的 组数。 hdu  5072  题意：再给出n 个数中，找出 3个数  符合(a,b)=(b,c)=(a,c)=1或  (a,b)!=1,(b,c)!=1,(a,c)!=1  的组数。。。 总的来说 ：这两题的思路 都是把这n个数
LightOJ 1236 Pairs Forming LCM (算术基本定理)
一切顺其自然
11-02 375
题目传送门：点击打开链接 这题要求a，b两个数的最小公倍数等于n的对数，其中a,b 根据算术基本定理：n=p1^x1*p2^x2*p3^x3*p4^x4... a=p1^a1*p2^a2*p3^a3*p4^a4..... b=p1^b1*p2^b2*p3^b3*p4^b4..... 其中pi为素数 如果a，b的公倍数为n，那么n=p1^max(a1,b1)*p2^max(a2,b2)*
HDU 1695：使用欧拉函数与容斥原理解决最大公约数问题
"HDU 1695 GCD（欧拉函数+容斥原理）问题解析及解题思路" 该题目是HDU（杭州电子科技大学）在线评测系统中的一道编程竞赛题，主要考察了欧拉函数（Euler's Totient Function）和容斥原理在解决数论问题中的应用。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值