欧拉函数，容斥定理
欧拉函数：
欧拉函数是少于或等于n的数中与n互质的数的数目.
欧拉函数和它本身不同质因数的关系：欧拉函数ψ（Ｎ）＝Ｎ｛∏ｐ｜Ｎ｝（１－１/ｐ）。（Ｐ是数Ｎ的质因数）
如：
ψ（１０）＝１０×（１－１/２）×（１－１/５）＝４；
ψ（３０）＝３０×（１－１/２）×（１－１/３）×（１－１/５）＝８；
ψ（４９）＝４９×（１－１/７）＝４２。
可以用筛选法求出欧拉函数。
memset( euler, 0, sizeof(euler) );
euler[1] = 1;
for( i=2; i<maxn; ++i )
{
if( euler[i] ) continue;
for( j=i; j<maxn; j+=i )
{
if( !euler[j] ) euler[j] = j;
euler[j] = euler[j]*(i-1)/i;
}
}
容斥原理：
在计数时，必须注意无一重复，无一遗漏。为了使重叠部分不被重复计算，人们研究出一种新的计数方法，这种方法的基本思想是：先不考虑重叠的情况，把包含于某内容中的所有对象的数目先计算出来，然后再把计数时重复计算的数目排斥出去，使得计算的结果既无遗漏又无重复，这种计数的方法称为容斥原理。
网上看到用dfs来实现，写的比较简单，但还不是很懂。蛋疼。。。
hdoj 1695代码：
#include <iostream>
#include <vector>
using namespace std;
typedef __int64 lld;
const int maxn = 100005;
int a, b, c, d, k;
lld euler[maxn]; //存放对应的欧拉函数值
vector<int> vec[maxn]; //存放每个数的质因子
void init()
{
int i, j;
for( i=0; i<maxn; ++i ) vec[i].clear();
memset( euler, 0, sizeof(euler) );
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;
vec[j].push_back( i );
}
}
euler[i] += euler[i-1];
}
}
lld dfs( int idx, int small, int big )
{
lld sum = 0;
for(int i=idx; i<vec[big].size(); ++i )
sum += small/vec[big][i] - dfs( i+1, small/vec[big][i], big );
return sum;
}
lld solve()
{
int i, j, x, y;
lld ans = 0;
if( k == 0 ) return 0;
if( b > d ) swap( b, d );
x = b / k;
y = d / k;
ans = euler[x];
for( i=x+1; i<=y; ++i )
ans += x - dfs( 0, x, i );
return ans;
}
int main()
{
// freopen( "c:/aaa.txt", "r", stdin );
int T, ca, x, y;
init();
scanf( "%d", &T );
for( ca=1; ca<=T; ++ca )
{
scanf( "%d %d %d %d %d", &a, &b, &c, &d, &k );
printf( "Case %d: %I64d\n", ca, solve() );
}
return 0;
}
而hdoj 1796 How many integers can you find 就是容斥，做完这题基本理解dfs对容斥的实现了，代码如下：
sum=(n/a[1]+n/a[2]...)-(n/(a[1]*a[2])+n/(a[1]*a[3])..)-(...) 而用容斥时，满足a[1],a[2]...互质。所以他们每项相乘作为分母前，必须排除公因子。
#include <iostream>
using namespace std;
int n, m, num[15];
int cnt;
int gcd( int a, int b ) {
if( a < b ) swap( a, b );
return ( b == 0 ) ? a : gcd( b, a%b );
}
void dfs( int idx, int len, int sum, int deep ) {
if( deep + m - idx + 1 < len ) return; //如果总长度小了就不用往下dfs了
if( deep == len && sum != 0 ) {
cnt += (n - 1) / sum;
return ;
}
for( int i=idx; i<=m; ++i ) {
int temp = num[i] / gcd( sum, num[i] );
sum *= temp;
dfs( i+1, len, sum, deep+1 );
sum /= temp;
}
}
void solve() {
int i, j, ans;
ans = 0;
for( i=1; i<=m; ++i ) {
cnt = 0;
dfs( 1, i, 1, 0 );
ans += (i&1) ? cnt : -cnt;
}
printf( "%d\n", ans );
}
int main() {
// freopen( "c:/aaa.txt", "r", stdin);
while( scanf("%d %d", &n, &m) == 2 ) {
int t = 0;
for( int i=1; i<=m; ++i ) {
scanf( "%d", &num[i] );
if( num[i] != 0 ) num[++t] = num[i];
}
m = t;
solve();
}
return 0;
}
由此，如果hdoj 1695 中用上面这种比较好理解的dfs方法来实现的话，我想应该就是这样
代码：
#include <iostream>
#include <vector>
using namespace std;
typedef __int64 lld;
const int maxn = 100005;
int a, b, c, d, k, n, m, l;
lld euler[maxn], cnt; //存放对应的欧拉函数值
vector<int> vec[maxn]; //存放每个数的质因子
void init()
{
int i, j;
for( i=0; i<maxn; ++i ) vec[i].clear();
memset( euler, 0, sizeof(euler) );
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;
vec[j].push_back( i );
}
}
euler[i] += euler[i-1];
}
}
/*
lld dfs( int idx, int small, int big )
{
lld sum = 0;
for(int i=idx; i<vec[big].size(); ++i )
sum += small/vec[big][i] - dfs( i+1, small/vec[big][i], big );
return sum;
}
*/
void dfs( int idx, int len, lld sum, int deep )
{
if( deep + m - idx < len ) return;
if( deep == len && sum != 0 ) {
cnt += n / sum;
return;
}
for( int i=idx; i<m; ++i ) {
sum *= vec[l][i];
dfs( i+1, len, sum, deep+1 );
sum /= vec[l][i];
}
}
lld rongchi( int small, int big ) //求小于small，和big不互质的数的个数
{
int i;
lld ans = 0;
m = vec[big].size();
n = small;
l = big;
for( i=0; i<m; ++i )
{
cnt = 0;
dfs( 0, i+1, 1, 0 );
ans += (i&1) ? -cnt : cnt;
}
return ans;
}
lld solve()
{
int i, j, x, y;
lld ans = 0;
if( k == 0 ) return 0;
if( b > d ) swap( b, d );
x = b / k;
y = d / k;
ans = euler[x];
for( i=x+1; i<=y; ++i )
ans += x - rongchi( x, i );
return ans;
}
int main()
{
// freopen( "c:/aaa.txt", "r", stdin );
int T, ca, x, y;
init();
scanf( "%d", &T );
for( ca=1; ca<=T; ++ca )
{
scanf( "%d %d %d %d %d", &a, &b, &c, &d, &k );
printf( "Case %d: %I64d\n", ca, solve() );
}
return 0;
}
