子序列

    给出一个长度为n的序列，你需要计算出所有长度为k的子序列中，除最大最小数之外所有数的乘积相乘的结果。

 

    链接：https://ac.nowcoder.com/acm/problem/18203

    来源：牛客网

输入描述:

第一行一个整数T，表示数据组数。

对于每组数据，第一行两个整数N，k，含义如题所示

接下来一行N个整数，表示给出的序列

保证序列内的数互不相同

输出描述:

对于每组数据，输出一个整数表示答案，对10⁹+7取模

每组数据之间以换行分割

数据范围:

${\mathrm{对于30\%的数据：T⩽10,N⩽100,k⩽N}}^{}$

${\mathrm{对于60\%的数据：T⩽10,N⩽1000,k⩽N}}^{}$

${\mathrm{对于100\%的数据：T⩽1000,N⩽1000,k⩽N}}^{}$

${\mathrm{保证序列中的元素互不相同且⩽106，k⩾3}}^{}$

    （好像吞行了，用图片代替0.0）

分析

    首先可以确定的是，长度为k的子序列有C(n,k)种，枚举一定超时。
    如果得到a1, a2, ... an在所有子序列中出现的次数，那么可以通过快速幂在O(q*n*log(n))时间内计算出结果，算法可行。

    由于要排除最小数和最大数，不妨先对数组排个序。设排序后的数组为

a1<a2<a3<...<an

    显然在任意子序列中，a1与an都不会计算在内。
    对于计算了a2的全部子序列，一定包含比a2小的a1，以及大于a2剩下k-2个数；

    对于计算了a3的全部子序列，一定包含比a3小的a1和a2中至少一个，以及大于a3部分剩下的数；
    ...

    所以对于ai, 出现的总次数为C(i-1, j)*C(n-i, k-1-j), 1<=j<k-1.

    于是很容易就写好了代码(WA)：

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn = 1010;
const int mod = 1e9+7;
ll C[maxn][maxn];
ll arr[maxn];
void pre() {
    for(int i=0;i<maxn;i++) {
        C[i][0] = 1;
        C[i][i] = 1;
    }
    
    for(int i=1;i<maxn;i++) {
        for(int j=1;j<maxn;j++) {
            C[i][j] = C[i-1][j] + C[i-1][j-1];
            C[i][j] %= mod;
        }
    }
}

ll pow(ll a, ll n) {
    ll res = 1;
    while(n>0) {
        if(n&1) res = res*a % mod;
        a = a*a % mod;
        n >>= 1;
    }
    return res;
}

int main() {
    
    int t, n, k;
    cin>>t;
    while(t--) {
        scanf("%d %d", &n, &k);
        /*for(int i=0;i<n;i++) {
            scanf("%lld", &arr[i]);
        }
        
        sort(arr, arr+n);
        
        ll ans = 0;
        for(int i=0;i<n;i++) {
            ll exp = C[n-1][k-1]-C[max(n-i+1,i)][k-1];
            exp %= mod-1;
            ans *= pow(arr[i], exp);
        }
        
        printf("%lld\n", ans);*/
    }
       
    return 0;
}

  

    使用原始表达式计算，复杂度O(q*N²)，显然超时，但通过了60%的测试。

    TLE(60%)

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn = 1010;
const int mod = 1e9+7;
ll C[maxn][maxn];
ll arr[maxn];
void pre() {
    for(int i=0;i<maxn;i++) {
        C[i][0] = 1;
        C[i][i] = 1;
    }
    
    for(int i=1;i<maxn;i++) {
        for(int j=1;j<maxn;j++) {
            C[i][j] = C[i-1][j] + C[i-1][j-1];
            C[i][j] %= mod-1;  // 由欧拉（费马小）定理，a，p互质时，有a^b % p == a^(b%φ(p)) % p
        }
    }
}

ll pow(ll a, ll n) {
    ll res = 1;
    while(n>0) {
        if(n&1) res = res*a % mod;
        a = a*a % mod;
        n >>= 1;
    }
    return res;
}

int main() {
    pre();
    int t, n, k;
    cin>>t;
    while(t--) {
        scanf("%d %d", &n, &k);
        for(int i=1;i<=n;i++) {
            scanf("%lld", &arr[i]);
        }
        
        sort(arr+1, arr+n+1);
        
        ll ans = 1;
        for(int i=2;i<=n-1;i++) {
            ll exp = 0;
            for(int j=1;j<i&&j<k-1;j++) {
                exp += C[i-1][j]*C[n-i][k-1-j];
                exp %= mod-1;
            }
            ans = ans*pow(arr[i], exp) % mod;
        }

        printf("%lld\n", ans);
    }
       
    return 0;
}

 

    

    直接用循环计算上面的表达式，复杂度有点高，于是手算化简：
    包含ai的子序列有C(n-1, k-1)种，把全部选取小于ai和全部选取大于ai的情况排除即可，即

C(n-1, k-1) - C(i-1, k-1) - C(n-i, k-1)

 

    在第一次WA的基础上改进，依旧0%。

    重新推导验算了半天，实在感觉没有任何错误了，最终参考了别人的代码，加上一行就AC了。。。

int main() {
    pre();
    int t, n, k;
    cin>>t;
    while(t--) {
        scanf("%d %d", &n, &k);
        for(int i=1;i<=n;i++) {
            scanf("%lld", &arr[i]);
        }
        
        sort(arr+1, arr+n+1);
        
        ll ans = 1;
        for(int i=2;i<=n-1;i++) {
            ll exp = C[n-1][k-1];
            if(i-1>=k-1) {
                exp -= C[i-1][k-1];
            }
            if(n-i>=k-1) {
                exp -= C[n-i][k-1];
            }

            exp = exp%(mod-1)+(mod-1);    // 加上这一行就通过了，否则0%
            exp %= mod-1;
            ans = ans*pow(arr[i], exp) % mod;
        }
        
        printf("%lld\n", ans);
    }
       
    return 0;
}

 

     以后一定要特别小心负数取模的问题！！！

// 负数取模

a = (a%mod + mod) % mod;

 

 

---

   （完）