2018 Multi-University Training Contest 4 Problem B. Harvest of Apples 【莫队+排列组合+逆元预处理技巧】

任意门：http://acm.hdu.edu.cn/showproblem.php?pid=6333

Problem B. Harvest of Apples

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 4043    Accepted Submission(s): 1560

Problem Description

There are n apples on a tree, numbered from 1 to n.
Count the number of ways to pick at most m apples.

 

Input

The first line of the input contains an integer T (1≤T≤105) denoting the number of test cases.
Each test case consists of one line with two integers n,m (1≤m≤n≤105).

 

Output

For each test case, print an integer representing the number of ways modulo 109+7.

 

Sample Input

2

5 2

1000 500

 

Sample Output

16

924129523

 

Source

2018 Multi-University Training Contest 4

题意概括：

有 N 个苹果，问最多选 m 个苹果的方案有多少种？

解题思路：

大佬讲的很好了。

https://blog.csdn.net/codeswarrior/article/details/81359075

推出四个公式，算是一道比较裸的莫队了。

Sm−1n=Smn−CmnSnm−1=Snm−Cnm
Sm+1n=Smn+Cm+1nSnm+1=Snm+Cnm+1(或者Smn=Sm−1n+CmnSnm=Snm−1+Cnm)

Smn+1=2Smn−CmnSn+1m=2Snm−Cnm
Smn−1=Smn+Cmn−12Sn−1m=Snm+Cn−1m2(或者Smn=Smn+1+Cmn2Snm=Sn+1m+Cnm2)

需要注意的点较多：

1、精度问题，注意数据范围

2、为了保证精度，除法需要转换为逆元，预处理逆元的技巧

 

AC code:

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<set>
#define INF 0x3f3f3f3f
#define LL long long
using namespace std;
const LL MOD = 1e9+7;
const int MAXN = 1e5+10;
LL N, M;
LL fac[MAXN], inv[MAXN];
struct Query
{
    int L, R, id, block;
    bool operator < (const Query &p)const{
        if(block == p.block) return R < p.R;
        return block < p.block;
    }
}Q[MAXN];
LL res, rev2;
LL ans[MAXN];

LL q_pow(LL a, LL b)
{
    LL pans = 1LL;
    while(b){
        if(b&1) pans = pans*a%MOD;
        b>>=1LL;
        a = a*a%MOD;
    }
    return pans;
}

LL C(int n, int k)
{
    return fac[n]*inv[k]%MOD*inv[n-k]%MOD;
}

void init()
{
    rev2 = q_pow(2, MOD-2);                     // 2的逆元
    fac[0] = fac[1] = 1;
    for(LL i = 2; i < MAXN; i++){              //预处理阶乘
        fac[i] = fac[i-1]*i%MOD;
    }

    inv[MAXN-1] = q_pow(fac[MAXN-1], MOD-2);    //逆推预处理阶乘的逆元
    for(int i = MAXN-2; i >= 0; i--){
        inv[i] = inv[i+1]*(i+1)%MOD;
    }
}

void  addN(int posL, int posR)
{
    res = (2*res%MOD-C(posL-1, posR)%MOD + MOD)%MOD;
}

void addM(int posL, int posR)
{
    res = (res+C(posL, posR))%MOD;
}

void delN(int posL, int posR)
{
    res = (res+C(posL-1, posR))%MOD*rev2%MOD;
}

void delM(int posL, int posR)
{
    res = (res - C(posL, posR) + MOD)%MOD;
}

int main()
{
    int T_case;
    init();
    int len = (int)sqrt(MAXN*1.0);
    scanf("%d", &T_case);
    for(int i = 1; i <= T_case; i++){
        scanf("%d%d", &Q[i].L, &Q[i].R);
        Q[i].id = i;
        Q[i].block = Q[i].L/len;
    }
    sort(Q+1, Q+1+T_case);
    res = 2;
    int curL = 1, curR = 1;
    for(int i = 1; i <= T_case; i++){
        while(curL < Q[i].L) addN(++curL, curR);
        while(curR < Q[i].R) addM(curL, ++curR);
        while(curL > Q[i].L) delN(curL--, curR);
        while(curR > Q[i].R) delM(curL, curR--);
        ans[Q[i].id] = res;
    }
    for(int i = 1; i <= T_case; i++){
        printf("%lld
", ans[i]);
    }

    return 0;

}