Password Attacker

Passwords are widely used in our lives: for ATMs, online forum logins, mobile device unlock and door access. Everyone cares about password security. However, attackers always find ways to steal our passwords. Here is one possible situation:

Assume that Eve, the attacker, wants to steal a password from the victim Alice. Eve cleans up the keyboard beforehand. After Alice types the password and leaves, Eve collects the fingerprints on the keyboard. Now she knows which keys are used in the password. However, Eve won't know how many times each key has been pressed or the order of the keystroke sequence.

To simplify the problem, let's assume that Eve finds Alice's fingerprints only occurs on M keys. And she knows, by another method, that Alice's password contains N characters. Furthermore, every keystroke on the keyboard only generates a single, unique character. Also, Alice won't press other irrelevant keys like 'left', 'home', 'backspace' and etc.

Here's an example. Assume that Eve finds Alice's fingerprints on M=3 key '3', '7' and '5', and she knows that Alice's password is N=4-digit in length. So all the following passwords are possible: 3577, 3557, 7353 and 5735. (And, in fact, there are 32 more possible passwords.)

However, these passwords are not possible:

1357 // There is no fingerprint on key '1'
3355 // There is fingerprint on key '7',
so '7' must occur at least once.
357 // Eve knows the password must be a 4-digit number.
With the information, please count that how many possible passwords satisfy the statements above. Since the result could be large, please output the answer modulo 1000000007(109+7).

Input

The first line of the input gives the number of test cases, T.
For the next T lines, each contains two space-separated numbers M and N, indicating a test case.

Output

For each test case, output one line containing "Case #x: y", where x is the test case number (starting from 1) and y is the total number of possible passwords modulo 1000000007(109+7).

Limits

Small dataset

T = 15.
1 ≤ M ≤ N ≤ 7.
Large dataset

T = 100.
1 ≤ M ≤ N ≤ 100.
Sample

Input
4
1 1
3 4
5 5
15 15

Output

Case #1: 1
Case #2: 36
Case #3: 120
Case #4: 674358851

google在线笔试题。这题一直没做出来。有人说有公式，看到大牛们提交的代码又觉得像是dp。后来学了生成函数之后，觉得应该是一道指数型生成函数的题。

 #include <iostream>
 #include <cstdio>
 #include <vector>

 using namespace std;
 const double epi = 0.000001;
 int frac(int k) {
     int ans = ;
     for (int i = ; i <= k; ++i) {
         ans *= i;
     }
     return ans;
 }

 int enumPassword(int n, int m) {
     vector<vector<double> > params(, vector<double>(n + , ));
     params[][] = ;
     int cur = , next = ;

     for (int i = ; i < m; ++i) {
         params[next].assign(n + , );
         for (int j = ; j <= n; ++j) {
             if (params[cur][j] < epi) continue;
             for (int k = ; k + j <= n; ++k) {
                 params[next][k + j] = params[next][k + j] + params[cur][j] *  / frac(k);
             }
         }
         cur = !cur; next = !next;
     }

     return params[cur][n] * frac(n);
 }

 int main(int argc, char** argv) {
     if (argc < ) return -;
     freopen(argv[], "r", stdin);
     int test;
     scanf("%d", &test);
     for (int i = ; i < test; ++i) {
         int m, n;
         scanf("%d%d", &m, &n);
         cout << "Case #" << i +  << ": " << enumPassword(n, m) << endl;
     }

     return ;
 }

但是数太大，要取模。除操作不能直接除模。

在网上搜到一个定理：

定理12.2：设$a_n$,$b_n$的指数生成函数分别为f(x)和g(x)，则：

$f(x)*g(x) = \sum_{n=0}^{\infty}c_n\frac{x^n}{n!}, c_n = \sum_{k=0}^{n}C(n,k)a_kb_{n-k}$。

对应到我们这里，Line 25里就变成params[cur][j]*1*C(j+k, k)，params[cur][j]对应的是$\frac{x^j}{j!}$的系数，1对应的是$\frac{x^k}{k!}$，所以乘以的就是C(j+k, k)了。

代码如下：

 #include <iostream>
 #include <cstdio>
 #include <vector>

 using namespace std;
 enum {MOD = };
 typedef long long llong;
 llong combination[][];
 void getCombination() {
     for (int i = ; i <= ; ++i) {
         for (int j = ; j <= i; ++j) {
             if (j == ) {
             combination[i][j] = ;
             } else {
                 combination[i][j] = (combination[i - ][j] + combination[i - ][j - ]) % MOD;
             }
         }
     }
 }

 llong enumPassword(int n, int m) {
     vector<vector<llong> > params(, vector<llong>(n + , ));
     params[][] = ;
     int cur = , next = ;

     for (int i = ; i < m; ++i) {
         params[next].assign(n + , );
         for (int j = ; j <= n; ++j) {
             if (params[cur][j] == ) continue;
             for (int k = ; k + j <= n; ++k) {
                 params[next][k + j] = (params[next][k + j] + params[cur][j] * combination[j + k][k]) % MOD;
             }
         }
         cur = !cur; next = !next;
     }

     return params[cur][n];
 }

 int main(int argc, char** argv) {
     if (argc < ) return -;
     freopen(argv[], "r", stdin);
     if (argc >= ) freopen(argv[], "w", stdout);
     getCombination();
     int test;
     scanf("%d", &test);
     for (int i = ; i < test; ++i) {
         int m, n;
         scanf("%d%d", &m, &n);
         //cout << "Case #" << i + 1 << ": " << enumPassword(n, m) << endl;
         printf("Case #%d: %lld\n", i + , enumPassword(n, m));
     }

     return ;
 }

注意这里求组合数要用递推公式来求，这样可以在运算中取模，避免溢出。

$C(n, m) = C(n - 1, m) + C(n - 1, m - 1)$。

以后指数型生成函数的题都可以这么做。get！