UVALive - 7040-组合数+容斥原理

大意:给n朵花上色，从m种颜色里面选择恰好k种颜色，求总数MOD 1e9+7

首先如果用k种颜色给花上色的话，肯定是k∗(k−1)n−1种方案，但是要求的是恰好k种，很容易想到用容斥原理解决这个问题。 

设Ai表示没选第i种颜色的种类数目，则结果为

代码：

/**
    首先有T组数据，每组数据有 3 个数 n, m, k，分别代表一共有 n 个方格，m种颜色，
    而我们要 恰好（注意是恰好） 使用 k 中颜色对这些方格进行涂色，
    并且保证的是每两个相邻的方格的颜色必须是不一样的。

    而我们知道的是 从m中选出k种颜色对n个进行染色的 总数是 S = C(m,k) * k * (k-1)^(n-1)
        意思就是说从m个选出k个,然后对于第1个有k种选择，对于剩余(n-1)个分别有(k-1)种选择
        需要注意的是 这里是用k个颜色去染色n，但是不一定全部用上k种颜色
    这个时候我们想想怎么解决恰好只用k种颜色去染色n

    容斥原理 ans = S - (A1 + A2 + A3 + Ak) Ai 表示 不用 i 种颜色，则我们可以使用的颜色有 k-i种

    也可以认为 A0 - A1 + A2 - A3 + ... + Ak

    Ai 表示不用i种颜色

    最后的表达式为: C(m,k) * ∑ (-1)^(k-i)*C(k,i)*i*(i-1)^(n-1) | (i->[k,0])
*/
#include<bits/stdc++.h>
using namespace std;
namespace IO
{
    template <typename T>
    inline bool scan_d (T &ret)
    {
        char c;
        int sgn;
        if (c = getchar(), c == EOF)return false; //EOF
        while (c != '-' && (c < '0' || c > '9') )
            if((c = getchar()) == EOF) return false;
        sgn = (c == '-') ? -1 : 1;
        ret = (c == '-') ? 0 : (c - '0');
        while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
        ret *= sgn;
        return true;
    }

    template<typename T>
    void print(T x)
    {
        static char s[33], *s1;
        s1 = s;
        if (!x) *s1++ = '0';
        if (x < 0) putchar('-'), x = -x;
        while(x) *s1++ = (x % 10 + '0'), x /= 10;
        while(s1-- != s) putchar(*s1);
    }

    template<typename T>
    void println(T x)
    {
        print(x);
        putchar('\n');
    }
};

typedef long long ll;
const ll mod = 1e9+7;
const int maxn = 1e6+10;
/// 注意到公式中只需要计算C(m,k) 和 C(k,i) 而 m,k 都很大，用C(n,m) = n! / m! / (n-m)! 显然是不合理的
/// 我们可以用递推的方式 计算 C(m,k) 和 C(k,i);
/// k最大为1e6次方，递推是合理的  C(n,m) = C(n,m-1) * (n-m+1) / m  显然m需要用逆元求
ll cm[maxn],ck[maxn];
ll inv[maxn]; /// 我们只需要 1e6次的逆元，提前处理出来
ll power(ll a,ll b) {
    ll ans = 1;
    while(b) {
        if(b&1) ans = ans * a % mod;
        a = a * a % mod;
        b>>=1;
    }
    return ans;
}
void get_inv(){
    inv[1] = 1;
    for (ll i = 2; i < maxn; i++){
        inv[i] = (ll)(mod - mod/i) * inv[mod % i] % mod;
    }
}
void init(ll m,ll k) {
    cm[0] = ck[0] = 1;
    for(ll i=1;i<=k;i++) {
        cm[i] = cm[i-1] * (m-i+1) % mod * inv[i] % mod;
        ck[i] = ck[i-1] * (k-i+1) % mod * inv[i] % mod;
    }
}
ll solve(ll n,ll m,ll k) {
    ll ans = 0,t = 1;
    for(ll i = k ;i >= 1;i--) {
        ll temp =  t * ck[i] % mod * i % mod * power(i-1,n-1) % mod;
        ans = (ans + temp ) % mod;
        if(ans < 0) ans = (ans + mod) % mod;  /// 这里可能会得到负数！
        t = -t;
    }
    return ans * cm[k] % mod;
}
int main()
{
    get_inv();
    int caset,cas=0;IO::scan_d(caset);
    while(caset--) {
        ll n,m,k;///
        IO::scan_d(n);IO::scan_d(m);IO::scan_d(k);
        init(m,k);
        printf("Case #%d: %lld\n",++cas,solve(n,m,k));
    }
    return 0;
}