BZOJ 1853: [Scoi2010]幸运数字

1853: [Scoi2010]幸运数字

Time Limit: 2 Sec Memory Limit: 64 MB
Submit: 2117 Solved: 779
[Submit][Status][Discuss]

Description

在中国，很多人都把6和8视为是幸运数字！lxhgww也这样认为，于是他定义自己的“幸运号码”是十进制表示中只包含数字6和8的那些号码，比如68，666，888都是“幸运号码”！但是这种“幸运号码”总是太少了，比如在[1,100]的区间内就只有6个（6，8，66，68，86，88），于是他又定义了一种“近似幸运号码”。lxhgww规定，凡是“幸运号码”的倍数都是“近似幸运号码”，当然，任何的“幸运号码”也都是“近似幸运号码”，比如12，16，666都是“近似幸运号码”。 现在lxhgww想知道在一段闭区间[a, b]内，“近似幸运号码”的个数。

Input

输入数据是一行，包括2个数字a和b

Output

输出数据是一行，包括1个数字，表示在闭区间[a, b]内“近似幸运号码”的个数

Sample Input

【样例输入1】

1 10

【样例输入2】

1234 4321

Sample Output

【样例输出1】

2

【样例输出2】

809

HINT

【数据范围】
对于30%的数据，保证1 < =a < =b < =1000000
对于100%的数据，保证1 < =a < =b < =10000000000

Source

Day1

[Submit][Status][Discuss]

分析

不难想到用容斥原理来统计。

先预处理出所有小于1e10的幸运数字，并不是很多。但是发现枚举所有的组合还是会爆炸的，需要一些剪枝。

1. 对于两个幸运数字，x<y，如果有y为x的倍数，则y可以忽略，因为x可以完全覆盖y的倍数。

2. 对于一种组合，如果目前的积已经大于N，即再进行下去得到的都是加减0的无意义操作，可以直接跳出。

3. 可以把GCD函数写成非递归的形式，但貌似没多大用，跑出来的结果差距不是很大，也许是我写得不好。

4. 枚举的时候从大往小枚举，据说有奇效，因为懒癌晚期，我并没有对比验证。

代码

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int N = 200020;

const LL lim = 10000000000LL;

template <class T>
__inline void read(T &x)
{
x = 0; char c = getchar();

while (c < '0')
c = getchar();

while (c >= '0')
{
x = x*10 + c - '0';
c = getchar();
}
}

LL gcd(LL a, LL b)
{
if (a < b)
{
a ^= b;
b ^= a;
a ^= b;
}
while (b)
{
a %= b;
a ^= b;
b ^= a;
a ^= b;
}
return a;
}

LL num
; int tot = 0;

__inline void prework(void)
{
int t, tail = 0;

for (t = 0; num[t] <= lim; ++t)
{
num[++tail] = num[t] * 10 + 6;
num[++tail] = num[t] * 10 + 8;
}

for (int i = 1; i <= t; ++i)
{
bool flag = true;
for (int j = 1; j <= tot; ++j)
if (num[i] % num[j] == 0)
{ flag = false; break; }
if (flag)num[++tot] = num[i];
}
}

LL answer, limit;

void search(int t, bool f, LL sum)
{
if (t)
{
search(t - 1, f, sum);

LL GCD = gcd(num[t], sum);

if (sum / GCD <= limit / num[t])
{
LL LCM = sum / GCD * num[t];

if (f)
answer -= limit / LCM;
else
answer += limit / LCM;

search(t - 1, !f, LCM);
}
}
}

__inline LL count(LL n)
{
limit = n;
answer = 0;

int pos = 1;

while (pos <= tot
&& num[pos] <= n)++pos;

search(pos - 1, 0, 1);

return answer;
}

signed main(void)
{
prework();

LL a; read(a);
LL b; read(b);

printf("%lld\n",
count(b)
-    count(a - 1)
);
}

BZOJ_1853.cpp

@Author: YouSiki