Harvest of Apples (HDU多校第四场 B) (HDU 6333 ) 莫队 + 组合数 + 逆元

题意大致是有n个苹果，问你最多拿走m个苹果有多少种拿法。题目非常简单，就是求C(n,0)+...+C(n，m)的组合数的和，但是询问足足有1e5个，然后n，m都是1e5的范围，直接暴力的话肯定时间炸到奶奶都不认识了。当时想了好多好多，各种骚操作都想了一遍就是没想到居然是莫队....我用S（n,m）来记录C(n,0)+...+C(n，m)的和作为一个询问的答案

由组合数公式C(n,m) = C(n-1,m-1)+C(n-1,m)可以推的下面的式子

S(n,m) = S(n,m-1) + C(n,m);

S(n,m) = S(n,m+1) - C(n,m+1);

S(n,m) = 2*S(n-1)-C(n,m);

S(n,m) = ( S(n+1, m) + C(n,m) ) / 2;

这样发现居然是一个莫队的基本操作....然而只知道这几点也是不够的，因为组合数计算涉及到除法，所以得求逆元，还是阶乘的逆元，所以得先预处理出1~n的阶乘和它们的逆元，求逆元也是很耗时间的，但是我们可以通过递推一遍把阶乘的逆元求出来

设f(x)为x的逆元
那么 f(n!) = f( (n-)!*n ) = f((n-)!)*f(n);
将f(n)除过来 f(n!)*f(f(n)) = f((n-)!)
因为x的逆元的逆元就是x本身，  因此得到公式f(n!)*n = f((n-1)!)，这样我们只要求出最大的阶乘的逆元就可以从大到小推出所有逆元的值

就酱（顺便说一句不知道为啥hdu选c++会TLE或者WA，得用G++编译）

 #include <iostream>
 #include <string.h>
 #include <cstdio>
 #include <vector>
 #include <queue>
 #include <stack>
 #include <math.h>
 #include <string>
 #include <algorithm>
 #include <functional>

 #define SIGMA_SIZE 26
 #define lson rt<<1
 #define rson rt<<1|1
 #define lowbit(x) (x&-x)
 #define foe(i, a, b) for(int i=a; i<=b; i++)
 #define fo(i, a, b) for(int i=a; i<b; i++)
 #define pii pair<int,int>
 #pragma warning ( disable : 4996 )

 using namespace std;
 typedef long long LL;
 inline double dMax(double a, double b) { return a>b ? a : b; }
 inline double dMin(double a, double b) { return a>b ? b : a; }
 inline LL LMax(LL a, LL b) { return a>b ? a : b; }
 inline LL LMin(LL a, LL b) { return a>b ? b : a; }
 inline LL lgcd(LL a, LL b) { return b ==  ? a : lgcd(b, a%b); }
 inline LL llcm(LL a, LL b) { return a / lgcd(a, b)*b; }  //a*b = gcd*lcm
 inline int Max(int a, int b) { return a>b ? a : b; }
 inline int Min(int a, int b) { return a>b ? b : a; }
 inline int gcd(int a, int b) { return b ==  ? a : gcd(b, a%b); }
 inline int lcm(int a, int b) { return a / gcd(a, b)*b; }  //a*b = gcd*lcm
 const LL INF = 0x3f3f3f3f3f3f3f3f;
 const LL mod = 1e9+;
 const double eps = 1e-;
 const int inf = 0x3f3f3f3f;
 const int maxk = 3e6 + ;
 const int maxn = 1e5+;

 int n, m, unit;
 int belong[maxn];
 LL fac[maxn], inv[maxn],invof2;
 LL ans[maxn];
 struct node {
     int lhs, rhs, id;
 }pp[maxn];

 bool cmp(const node& a, const node& b)
 {
     if (belong[a.lhs] == belong[b.lhs])
         return (belong[a.lhs]&) ? a.rhs<b.rhs : a.rhs>b.rhs;
     return a.lhs < b.lhs;
 }

 //设f(x)为x的逆元
 //f(n!) = f( (n-1)!*n ) = f((n-1)!)*f(n);
 //将f(n)除过来 f(n!)*f(f(n)) = f((n-1)!)
 //因此可以从最大的n反向推回小的
 LL getM( LL a, LL b, LL m)
 {
     LL ans = , base = a;
     while (b)
     {
         if ( b &  )
             ans = (ans*base) % m;
         base = (base*base) % m;
         b >>= ;
     }
     return ans;
 }

 void init()
 {
     fac[] = fac[] = ;
     inv[] = inv[] = ;
     foe(i, , maxn)
         fac[i] = fac[i-]*i%mod;

     inv[maxn-] = getM(fac[maxn-], mod-, mod);
     invof2 = getM(, mod-, mod);
     for ( int i = maxn-; i >= ; i-- )
         inv[i] = (inv[i+]*(i+))%mod;
 }

 LL C(int down, int up)
 {
     if ( up > down ) return ;
     return fac[down]*inv[up]%mod*inv[down-up]%mod;
 }

 int main()
 {
     init();
     int T;
     cin >> T;
     unit = sqrt(T);

     foe(i, , T)
     {
         scanf("%d %d", &n, &m);
         pp[i].lhs = n; pp[i].rhs = m;
         pp[i].id = i;
         belong[i] = i/unit+;
     }
     sort(pp+, pp++T, cmp);

     //(l代表n， r代表m)
     int l = , r = ;
     LL sum = ;

     for ( int i = ; i <= T; i++ )
     {
         while (r < pp[i].rhs) {
             r++;
             sum = (sum + C(l, r))%mod;
         }

         while (r > pp[i].rhs) {
             sum = (sum - C(l, r)+mod)%mod;
             r--;
         }

         while (l < pp[i].lhs) {
             sum = ((LL)*sum - C(l, r)+mod)%mod;
             l++;
         }

         while (l > pp[i].lhs) {
             l--;
             sum = (sum+C(l,r))%mod*invof2%mod;
         }

         ans[pp[i].id] = sum;
     }

     foe(i, , T)
         printf("%lld\n", ans[i]);
     return ;
 }