程序员最近都爱上了这个网站  程序员们快来瞅瞅吧！  it98k网:it98k.com

G - Super Subarray

题意：给一个n个大小的数组，求给数组中有几个超子数组，超子数组的意思是：子区间的区间和是该区间各个元素的倍数。
Input

2
5
1 2 3 4 5
5
2 3 4 3 6

Output

6
6

比赛的时候这道题用了三重循环做的，超时了。但是当时也是使用了前缀和进行优化，其实就差一点了。这道题需要知道lcm函数以及一些基础的数学性质。

lcm可以实现求两个数的最小公倍数，求前n个数的最小公倍数很类似于求n个数的最大值：对于一个序列来说，前n个索引的最小公倍数类似于从从1~n 的哈弗曼树，比如 1 和2 的最小公倍数是2 ，2就可以和3求前三个数的最小公倍数6，依次类推。__gcd( )函数具有同样的性质，也可以用这种方式求出前n个数的最大公约数。

如果手写lcm的要小心a*b 爆掉的边界错误，需要改成先除再乘才可以。

回到这道题目：
首先前缀和可以快速求出一个区间的区间和，而从前往后的顺序枚举就可以用lcm实现快速求出区间的最小公倍数，如果一个区间和可以整除一个区间的最小公倍数，那么这个区间和就可以整除这个区间里所有的数。（必要性剪枝：如果当前的最小公倍数大于了最大的一个区间和，那么就不存在一个区间和可以整除这个区间里的所有数，就可以停止枚举本次循环）
基于以上思路就可以写出代码：

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=2010;
typedef long long int LL;
LL a[N];
LL b[N];
LL lcm(LL a,LL b)//最小公倍数 
{
    return a/__gcd(a,b)*b;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {   
        LL ans=0;
        int n;
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
        }
        b[1]=a[1];
        LL mx=b[1];
        for(int i=2;i<=n;i++)
        {
            b[i]=b[i-1]+a[i];//前缀和
            if(b[i]>mx) mx=b[i];//找出区间和的最大值
        }
        
        for(int i=1;i<=n;i++)
        {   
            LL count=a[i];
            for(int j=i;j<=n;j++)
            {
                LL sum=b[j]-b[i-1];//区间和
                count=lcm(count,a[j]);//区间最小公倍数
                if(count>mx) break;//必要性剪枝
                if(sum%count==0) ans++;
            }
        }
        cout<<ans<<endl;
    }
}

D - Counting Paths

题目描述：给定两个数a和b ， a代表一个完全二叉树的深度，b代表转向次数（转向指的是，存在一条路径，当前节点来自于上个节点的左/右儿子，那么它走向了它的右/左儿子，称为转向）

就比如第一个样例，深度为2，转向1次的路径在这棵完全二叉树中有两条。
数据范围：
答案取modulo 109 + 7的值
1 ≤ T ≤ 105
0 ≤ b < a ≤ 10^5

2
2 1
4 3

Output

2
2

这道题左右两边的路径对称，可以看一边。在深度为a的路径中选择b次转向，这b次转向的每一次都是独立的，且互不影响的。所以可以看成一个组合数的问题。因为从样例中可以看出，根节点走向左右儿子的第一步增加了深度但是并不算一次转向，所以就相当于在剩下的a-1个岔口选择b次转向，所以最终的答案为：

从这道题的数据范围可以看出，是一个1e^5的组合数mod p的组合数问题，因为p是一个质数，可以使用费马小定理求逆元，求出逆元之后可以直接求组合数：
组合数传送门

#include <iostream>
using namespace std;

const int N = 100010;
const int mod = 1e9 + 7;

typedef long long LL;

LL fact[N], infact[N];
// 符合费马小定理求逆元,为a^p-2, 使用快速幂来求解
LL inv(LL a, LL b, LL p)
{
    LL ans = 1;
    while (b > 0)
    {
        if (b & 1)
            ans = (LL)ans * a % p;
        a = (LL)a * a % p;
        b >>= 1;
    }
    return ans;
}

int main()
{
    fact[0] = infact[0] = 1;
    for (LL i = 1; i < N; i++)
    {
        fact[i] = i * (LL)fact[i - 1] % mod;
        infact[i] = (LL)infact[i - 1] * inv(i, mod - 2, mod) % mod;
    }

    LL n;
    cin >> n;
    while (n--)
    {
        LL a, b;
        cin >> a >> b;
        printf("%d\n", (LL)2*fact[a-1] * infact[b] % mod * infact[a -1- b] % mod);
    }
}