HDU 5768 Lucky7 （中国剩余定理 + 容斥 + 快速乘法）

Lucky7

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=5768

Description

When ?? was born, seven crows flew in and stopped beside him. In its childhood, ?? had been unfortunately fall into the sea. While it was dying, seven dolphins arched its body and sent it back to the shore. It is said that ?? used to surrounded by 7 candles when he faced a extremely difficult problem, and always solve it in seven minutes.

?? once wrote an autobiography, which mentioned something about himself. In his book, it said seven is his favorite number and he thinks that a number can be divisible by seven can bring him good luck. On the other hand, ?? abhors some other prime numbers and thinks a number x divided by pi which is one of these prime numbers with a given remainder ai will bring him bad luck. In this case, many of his lucky numbers are sullied because they can be divisible by 7 and also has a remainder of ai when it is divided by the prime number pi.

Now give you a pair of x and y, and N pairs of ai and pi, please find out how many numbers between x and y can bring ?? good luck.

Input

On the first line there is an integer T(T≤20) representing the number of test cases.

Each test case starts with three integers three intergers n, x, y(0<=n<=15,0<x<y<1018) on a line where n is the number of pirmes.

Following on n lines each contains two integers pi, ai where pi is the pirme and ?? abhors the numbers have a remainder of ai when they are divided by pi.

It is guranteed that all the pi are distinct and pi!=7.

It is also guaranteed that p1p2…*pn<=1018 and 0<ai<pi<=105for every i∈(1…n).

Output

For each test case, first output "Case #x: ",x=1,2,3...., then output the correct answer on a line.

Sample Input

2

2 1 100

3 2

5 3

0 1 100

Sample Output

Case #1: 7

Case #2: 14

Hint

For Case 1: 7,21,42,49,70,84,91 are the seven numbers.

For Case2: 7,14,21,28,35,42,49,56,63,70,77,84,91,98 are the fourteen numbers.

Source

2016 Multi-University Training Contest 4

##题意：

对于给出的区间[x, y]找出有多少个符合要求的数：
1. 能被7整除.
2. 给出不超过15组(pi, ai)，其中pi为质数;
要求找出的数x满足 x % pi != ai;


##题解：

可以先找出能被7整除但不满足条件2的数：
就得到了一组同余模方程，这里用中国剩余定理来处理.
因为只要满足任一同余方程就需要被计数，所以需要用容斥原理来做.
由于n=15，所以最多只有2^15种方程组合，用状态压缩记录每个组合对应的方程，对于每种组合跑一遍中国剩余定理，找出在区间范围内的个数，再用容斥原理累加起来(奇数个元素就加，偶数个则减).

以上思路很好想，坑点在于：由于数据规模比较大
中国剩余定理中 ans = (ans+x*w*a[i])%M; 乘法的3个因子和M的规模都可能达到longlong上限，所以一乘就可能导致爆掉longlong.
这里的解决方案是：用快速乘法取模(类似快速幂)代替上述乘法.


##代码：
``` cpp
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define LL long long
#define eps 1e-8
#define maxn 25
#define inf 0x3f3f3f3f
#define IN freopen("in.txt","r",stdin);
using namespace std;

LL _left, _right;

LL x,y,gcd;

void ex_gcd(LL a,LL b)

{

if(!b) {x=1;y=0;gcd=a;}

else {ex_gcd(b,a%b);LL temp=x;x=y;y=temp-a/b*y;}

}

int BitCount2(int n) {

int c =0 ;

for(; n; ++c) {

n &= (n -1) ;

}

return c ;

}

LL quickmul(LL a, LL b, LL mod) {

a %= mod;

LL ret = 0;

while(b) {

if(b & 1) ret = (ret + a) % mod;

b >>= 1;

a = (a + a) % mod;

}

return ret;

}

int n, m[maxn],a[maxn];

LL M;

LL China(int state)

{

LL w,ans=0; M=1;

for(int i=0;i<=n;i++)

if(!i || state&(1<<(i-1)))

M *= m[i];

for(int i=0;i<=n;i++) if(!i || state&(1<<(i-1))){

w=M/m[i];

ex_gcd(w,m[i]); while(x<0) {x+=m[i];y-=w;}

    //ans=(ans+x*w*a[i])%M;
    //上式乘法会爆longlong，所以需要用快速乘法来防暴.
    ans = (ans + quickmul(a[i] ,quickmul(x,w,M), M)) % M;
}

LL cur = (ans+M)%M;
LL T = M;
cur = cur % T;

LL l_ans, r_ans;
if(_left <= cur) l_ans = cur;
else l_ans = _left - (_left-cur) % T + T;

if(_right < cur) return 0LL;
else if(_right == cur) return 1LL;
else r_ans = _right - (_right-cur) % T;

if(l_ans > r_ans) return 0LL;
return (r_ans-l_ans) / T + 1LL;

}

int main(int argc, char const *argv[])

{

//IN;

int t; cin >> t; int ca = 1;
while(t--)
{
    cin >> n >> _left >> _right;
    m[0] = 7LL; a[0] = 0LL;
    for(int i=1; i<=n; i++) {
        scanf("%I64d %I64d", &m[i], &a[i]);
    }

    LL ans = 0;
    for(int i=1; i<(1<<n); i++) {
        int flag = (BitCount2(i)%2? 1:0);
        if(flag) ans += China(i);
        else ans -= China(i);
    }

    LL tmp = _right/7LL - _left/7LL;
    if(_left%7LL==0) tmp++;

    printf("Case #%d: %I64d\n", ca++, tmp-ans);
}

return 0;

}