UVALive 7040 Color

题目链接：LA-7040

题意为用m种颜色给n个格子染色。问正好使用k种颜色的方案有多少。

首先很容易想到的是\( k * (k-1)^{n-1}\)，这个算出来的是使用小于等于k种颜色给n个方格染色的方案数。

我们希望求得的是使用正好k种颜色给n个方格染色的方案数，简单的想法是，直接减去小于等于k-1种颜色的方案数。

但是，要计算使用小于等于k-1种颜色染色的方案数，不能直接减去\(C_{k}^{k-1} * (k-1) * (k-2)^{n-1}\)，原因是会有重复的部分。

我们用\(S_{k}\)表示使用小于等于k种颜色给n个格子染色的方案数。

则我们希望求出的答案可以用\(C_m^k * (S_k- \bigcup _{i=1} ^ {C_k^{k-1}} S_{k-1})\)来表示。

于是问题变成了求\( \bigcup _{i=1} ^ {C_k^{k-1}} S_{k-1}\)，因为有重复，自然而然的我们想到容斥原理。

仔细思考后（或者列表格），发现所有\(S_{k-1}\)两两相交的并等于\(S_{k-2}\)，所有\(S_{k-1}\)三三相交的并等于\(S_{k-3}\)，以此类推，减加减加即可。

代码如下：

 #include<cstring>
 #include<cstdio>
 #include<queue>
 #include<algorithm>
 #include<set>
 #include<cmath>
 using namespace std;
 typedef long long LL;
 const LL MAXK=;
 const LL MOD=1e9+;

 LL CM[MAXK+],CK[MAXK+],inv[MAXK+];
 LL extgcd(LL a,LL b,LL &x,LL &y)
 {
     LL d=a;
     if(b!=)
     {
         d=extgcd(b,a%b,y,x);
         y-=(a/b)*x;
     }
     else { x=; y=; }
     return d;
 }
 //快速幂
 //求x^n%mod
 LL powMod(LL x,LL n,LL mod)
 {
     LL res=;
     while(n>)
     {
         if(n&) res=res*x % mod;
         x=x*x % mod;
         n>>=;
     }
     return res;
 }
 //求逆元
 //a和ｍ应该互质
 LL modInverse(LL a,LL m)
 {
     LL x,y;
     extgcd(a,m,x,y);
     return (m+x%m)%m;
 }
 LL n,m,k;
 void init()
 {
     CM[]=;
     for(LL i=;i<=k-;i++)
         CM[i+]=CM[i]*(m-i) %MOD *inv[i+] % MOD;
     CK[]=;
     for(LL i=;i<=k-;i++)
         CK[i+]=CK[i]*(k-i) %MOD *inv[i+] % MOD;
 }
 LL f(LL n,LL k)
 {
     LL ans = ;
     LL flag=;
     for(LL i=k;i>=;i--)
     {
         ans = (flag * CK[i] % MOD * i % MOD * powMod(i-,n-,MOD) % MOD +ans + MOD ) % MOD;
         flag*=-;
     }
     ans = ans*CM[k]%MOD;
     return ans;
 }
 int main()
 {
 #ifdef LOCAL
     freopen("in.txt","r",stdin);
     // freopen("out.txt","w",stdout);
 #endif
     for(LL i=;i<=MAXK;i++) inv[i]=modInverse(i,MOD);
     LL t;
     scanf("%lld",&t);
     for(LL tt=;tt<=t;tt++)
     {
         scanf("%lld%lld%lld",&n,&m,&k);
         init();
         printf("Case #%lld: %lld\n",tt,f(n,k)%MOD);
     }
     return ;
 }