沈阳网络赛G-Spare Tire【容斥】

17.64%
1000ms
131072K

A sequence of integer \lbrace a_n \rbrace{an} can be expressed as:

\displaystyle a_n = \left\{ \begin{array}{lr} 0, & n=0\\ 2, & n=1\\ \frac{3a_{n-1}-a_{n-2}}{2}+n+1, & n>1 \end{array} \right.an=⎩⎨⎧0,2,23an−1−an−2+n+1,n=0n=1n>1

Now there are two integers nn and mm. I'm a pretty girl. I want to find all b_1,b_2,b_3\cdots b_pb1,b2,b3⋯bp that 1\leq b_i \leq n1≤bi≤n and b_ibiis relatively-prime with the integer mm. And then calculate:

\displaystyle \sum_{i=1}^{p}a_{b_i}i=1∑pabi

But I have no time to solve this problem because I am going to date my boyfriend soon. So can you help me?

Input

Input contains multiple test cases ( about 1500015000 ). Each case contains two integers nn and mm. 1\leq n,m \leq 10^81≤n,m≤108.

Output

For each test case, print the answer of my question(after mod 1,000,000,0071,000,000,007).

Hint

In the all integers from 11 to 44, 11 and 33 is relatively-prime with the integer 44. So the answer is a_1+a_3=14a1+a3=14.

样例输入复制

4 4

样例输出复制

题目来源

ACM-ICPC 2018 沈阳赛区网络预赛

题意：

已知一个数列a 和整数n， m

现在想知道1-n中所有与m互质的数作为下标的a的和

思路：

预先打表处理的话内存不够推公式能推出a[i] = （i + 1） * i【虽然我好像没有推出来...】

所以Sn也是可以推出来的

某一个数的倍数的a求和也是可以推的因为是ki 那么提出一个k来就可以代入公式求了

小于n 与m互质的数没有什么特殊的规律但应该想到素数筛时的做法用上容斥

先求出1-n所有的a的和再减去所有与m不互质的数

用容斥来求不互质的数是正是负与质因数的个数有关如果是奇数个质因数之积的话就是加偶数就是减

用到了乘法逆元的模板

cal（）函数注释掉的部分是WA的改成了题解的方法就AC了

 #include<iostream>

 #include<stdio.h>

 #include<string.h>

 #include<algorithm>

 #include<stack>

 #include<queue>

 #include<map>

 #include<vector>

 #include<cmath>

 #include<cstring>

 #include<set>

 //#include<bits/stdc++.h>

 #define inf 0x7f7f7f7f7f7f7f7f

 using namespace std;

 typedef long long LL;

 const int maxn = 1e5 + ;

 const LL mod = 1e9 + ;

 LL inv6, inv2;

 LL n, m;

 LL p[maxn];

 int cnt;

 void getprime(LL x)

 {

     cnt = ;

     for (LL i = ; i * i <= x; i++) {

         if (x % i == ) {

             p[cnt++] = i;

         }

         while (x % i == ) {

             x /= i;

         }

     }

     if (x > ) {

         p[cnt++] = x;

     }

 }

 void ex_gcd(int a, LL b, LL &d, LL &x, LL &y)

 {

     if(!b){

         d = a;

         x = ;

         y = ;

     }

     else{

         ex_gcd(b, a % b, d, y, x);

         y -= x * (a / b);

     }

 }

 int mod_inverse(int a, LL m)

 {

     LL x, y, d;

     ex_gcd(a, m, d, x, y);

     return (m + x % m) % m;

 }

 LL cal(LL n, LL k)

 {

     /*LL ans = n / k * (n / k + 1) % mod;

     ans = ans * (2 * n / k + 1) % mod;

     ans = ans * inv6 % mod * k % mod * k % mod;

     ans = ans + k * (1 + n / k) % mod * n / k % mod * inv2 % mod;*/

     n=n/k;

     return (n%mod*(n+)%mod*(*n+)%mod*inv6%mod*k%mod*k%mod+n%mod*(n+)%mod*inv2%mod*k%mod)%mod;

     //return ans;

 }

 int main()

 {

     inv6 = mod_inverse(, mod);

     inv2 = mod_inverse(, mod);

     //cout<<mod_inverse(6, mod)<<endl<<mod_inverse(2, mod)<<endl;

     while (scanf("%lld%lld", &n, &m) != EOF) {

         memset(p, , sizeof(p));

         getprime(m);

         LL ans = ;

         for(int i = ; i < ( << cnt); i++){

             int flag = ;

             LL tmp = ;

             for(int j = ; j < cnt; j++){

                 if(i & ( << j)){

                     flag++;

                     tmp = tmp * p[j] % mod;

                 }

             }

             tmp = cal(n, tmp) % mod;

             if(flag % ){

                 ans = (ans % mod + tmp % mod) % mod;

             }

             else{

                 ans = (ans % mod - tmp % mod + mod) % mod;

             }

         }

         printf("%lld\n", (cal(n, ) % mod - ans % mod + mod) % mod);

     }

     return ;

 }