BZOJ 2190 仪仗队(线性筛欧拉函数)

简化题意可知,实际上题目求得是gcd(i,j)=1(i,j<=n)的数对数目。

线性筛出n大小的欧拉表,求和*2+1即可。需要特判1.

# include <cstdio>
# include <cstring>
# include <cstdlib>
# include <iostream>
# include <vector>
# include <queue>
# include <stack>
# include <map>
# include <bitset>
# include <set>
# include <cmath>
# include <algorithm>
using namespace std;
# define lowbit(x) ((x)&(-x))
# define pi acos(-1.0)
# define eps 1e-8
# define MOD 30031
# define INF 1000000000
# define mem(a,b) memset(a,b,sizeof(a))
# define FOR(i,a,n) for(int i=a; i<=n; ++i)
# define FO(i,a,n) for(int i=a; i<n; ++i)
# define bug puts("H");
# define lch p<<1,l,mid
# define rch p<<1|1,mid+1,r
# define mp make_pair
# define pb push_back
typedef pair<int,int> PII;
typedef vector<int> VI;
# pragma comment(linker, "/STACK:1024000000,1024000000")
typedef long long LL;
int Scan() {
    int x=0,f=1;char ch=getchar();
    while(ch<‘0‘||ch>‘9‘){if(ch==‘-‘)f=-1;ch=getchar();}
    while(ch>=‘0‘&&ch<=‘9‘){x=x*10+ch-‘0‘;ch=getchar();}
    return x*f;
}
const int N=40005;
//Code begin...

int phi[N], prime[N], tot;
bool check[N];

void getEuler(int n){
    mem(check,0); phi[1]=1; tot=0;
    FOR(i,2,n) {
        if (!check[i]) prime[tot++]=i, phi[i]=i-1;
        FO(j,0,tot) {
            if (i*prime[j]>n) break;
            check[i*prime[j]]=true;
            if (i%prime[j]==0) {phi[i*prime[j]]=phi[i]*prime[j]; break;}
            else phi[i*prime[j]]=phi[i]*(prime[j]-1);
        }
    }
}
int main ()
{
    LL ans=0;
    int n;
    scanf("%d",&n);
    if (n==1) {puts("0"); return 0;}
    --n; getEuler(n);
    FOR(i,1,n) ans+=phi[i];
    ans=ans*2+1;
    printf("%lld\n",ans);
    return 0;
}

时间: 2024-10-31 13:18:33

BZOJ 2190 仪仗队(线性筛欧拉函数)的相关文章

The Euler function(线性筛欧拉函数)

/* 题意:(n)表示小于n与n互质的数有多少个,给你两个数a,b让你计算a+(a+1)+(a+2)+......+b; 初步思路:暴力搞一下,打表 #放弃:打了十几分钟没打完 #改进:欧拉函数:具体证明看po主的博客 ^0^ #超时:这里直接用欧拉函数暴力搞还是不可以的,用到线性筛欧拉函数,这里总和爆int,要用long long */ #include<bits/stdc++.h> #define ll long long using namespace std; /***********

素数的线性筛 &amp;&amp; 欧拉函数

O(n) 筛选素数 #include<bits/stdc++.h> using namespace std; const int M = 1e6 + 10 ; int mindiv[M] ;//每个数的最小质因数 int prim[M] , pnum ;//存素数 bool vis[M] ; void prim () { for (int i = 2 ; i < M ; i ++) { if (!vis[i]) { mindiv[i] = i ; prim[ pnum++ ] = i ;

线性筛欧拉函数

#include <bits/stdc++.h> using namespace std; int P[40005]={1,1},phi[40005]; vector<int> prime; void getphi(int n){ for(int i=2;i<=n;i++){ if(!P[i])prime.push_back(i),phi[i]=i-1; for(int j=0;j<prime.size()&&prime[j]*i<=n;j++){

线性(欧拉)筛&amp;欧拉函数

线性筛法 what is 线性筛??就是基于最基本的筛法的优化. 在基础的筛法上,我们发现有的数字会被重复筛,例如6既会被2枚举到也会被3枚举到,必然有重复运算. 我们的做法就是让每一个数的最小因数筛. \(FOR\) \(EXAMPLE:\) 有一个数\(2 * 2 * 3 * 5\) 有另一个数 \(3 * 3 * 3* 5\) 那么第一个数枚举到3的话,筛到的数字是\(2 * 2 * 3 * 3 * 5\) 但是在第二个数字再次枚举的时候 枚举到2时 也会枚举到\(2 * 2 * 3 *

noip复习——线性筛(欧拉筛)

整数的唯一分解定理: \(\forall A\in \mathbb {N} ,\,A>1\quad \exists \prod _{i=1}^{s}p_{i}^{a_{i}}=A\),其中\({\displaystyle p_{1}<p_{2}<p_{3}<\cdots <p_{s}}\)而且 \(p_{i}\)是一个质数, \(a_{i}\in \mathbb {Z} ^{+}\)(摘自维基百科) 欧拉筛通过使每个整数只会被它的最小质因子筛到来保证时间复杂度,可以用来筛质数

线性求欧拉函数

我们都知道欧拉筛又称线性筛,能在O(n)的时间复杂度内筛出n以内的所有质数,而我们只要在线性筛的代码上改良一下就能求出n以内所有数的欧拉函数了.筛质数时,设外层在枚举i,内层枚举到prime[j],这时有两种情况: i%prime[j]不为0,也就是说,i与j互质,根据欧拉函数的积性可得phi[ i * prime[j] ]=phi[ i ]*phi[ prime[j] ]而这些是前面求出来的,可以直接拿来推. i%prime[j]为0,也就是说,i内有一个质因子是prime[j],不过没有关系

bzoj 1408 [Noi2002]Robot(欧拉函数)

[题目链接]  http://www.lydsy.com/JudgeOnline/problem.php?id=1408 [题意] 求m的所有约数中,满足可以分解成(奇数个不同素数/偶数个不同素数/其他)的所有的phi之和. [思路] ans1表示目前为止有偶数个奇质因子的欧拉函数的前缀和 ans2表示目前为止有奇数个奇质因子的欧拉函数的前缀和. 注意2不是奇质因子,需要去掉. 第三种可以由m-1减去前两种,减1为去掉1,1不是老师. [代码] 1 #include<cstdio> 2 #in

欧拉筛 + 欧拉函数

1 /** 2 * Fuck you. 3 * I love you too. 4 */ 5 #include<bits/stdc++.h> 6 #define lson i<<2 7 #define rson i<<2|1 8 #define LS l,mid,lson 9 #define RS mid+1,r,rson 10 #define mem(a,x) memset(a,x,sizeof(a)) 11 #define gcd(a,b) __gcd(a,b) 1

bzoj 2693: jzptab 线性筛积性函数

2693: jzptab Time Limit: 10 Sec  Memory Limit: 512 MBSubmit: 444  Solved: 174[Submit][Status][Discuss] Description Input 一个正整数T表示数据组数 接下来T行 每行两个正整数 表示N.M Output T行 每行一个整数 表示第i组数据的结果 Sample Input 1 4 5 Sample Output 122 HINT T <= 10000 N, M<=10000000