[Google Code Jam] 2013-1A-C Good Luck 解法

问题的陈述在：https://code.google.com/codejam/contest/2418487/dashboard#s=p2&a=1，

官方的分析在：https://code.google.com/codejam/contest/2418487/dashboard#s=a&a=2。

这篇文章是结合官方的分析以及Dlougach的solution总结的解题思路。

1. 列举所有的可能的数字组合

由[2,M]区间内的数字组成长度为N的数组组合，本身有(M-1)^N可能性，因为组合中的每一个数字都可以从[2,M]这M-1个数字中随机选取。

但是由于这些数字组合本身不存在顺序的问题，比如（5, 2, 3, 2）和（2, 2, 3, 5）是相同的，所以可以排除掉很多相同的情况。

可以编程列举出所有的数字组合，思路是从N个2的数字组合开始，顺序加1，直到N个M的组合。代码如下：

 1 // all possible combinations
 2 vector<vector<int>> digits;
 3 vector<int> dig(N, 2);
 4 while (dig != vector<int>(N, M))
 5 {
 6     digits.push_back(dig);
 7     int i = N-1;
 8     while (dig[i] == M) i--;
 9     dig[i]++;
10     for (int j = i + 1; j < N; j++)
11         dig[j] = dig[i];
12 }
13 digits.push_back(dig);
14 int total = digits.size();

经过所有的列举，共有18564种可能的数字组合。

2. 计算每一种数字组合出现的概率。

当给出的所有的K个products都为1的时候应该选择哪一个数字组合呢？选择N个2还是其他？

要注意到，即便给出的所有K个products都为1，由于每一种数字组合出现的概率也有区别，也可以从中选取出可能出现概率最高的数字组合。

对于一个数字组合，计算这个数字组合可能出现的概率：

比如M = 8, N = 12的情况下，222333445558出现的可能性为：(C(12,3)*C(9,3)*C(6,2)*C(4,3)*C(1,1)) / (8-1)¹²，即在所有的12个位置中找3个位置摆放2，再在剩下的9个位置中找3个位置摆放3，再在剩下的6个位置中找2个位置摆放4.....最后除以总数(8-1)¹²。

其中C(n,k)就是我们在学概率时学到的C_n^k。

所以要想求概率，首先需要统计出每个数字重复出现的次数，具体代码如下：

 1 vector<double> prob(total, 0);
 2 for (int i = 0; i < total; ++i)
 3 {
 4     vector<int> count(M+1, 0);
 5     for (int j = 0; j < N; ++j)
 6         count[digits[i][j]]++;
 7     double p = 0;
 8     int size = N;
 9     for (int j = 2; j <= M; ++j)
10     {
11         p += log(C[size][count[j]]);
12         size -= count[j];
13     }
14     prob[i] = p;
15 }

这段代码中有两点技巧：一是C(n,k)的计算方法，二是取对数(log)问题。

a) C(n,k)的计算

C(n,k)本身有一个计算公式是我们很熟悉的：C(n,k) = n! / (k!(n-k)!)。这样计算牵涉到阶乘，考虑到要计算多个C(n,k)，为了重复利用计算好的结果，这里有一个比较简单的方法，就是杨辉三角型(Pascal's triangle)以及。

首先构建一个杨辉三角形存放于二维数组C中，如下图所示。这样的摆放有一个规律C[n][m] = C[n-1][m-1]+C[n-1][m]，恰好是C(n,k)的另一种计算方法。

m = 0 m = 1 m = 2 m = 3 m = 4 m = 5...

n = 0 1 0 0 0 0 0...

n = 1 1 1 0 0 0 0...

n = 2 1 2 1 0 0 0...

n = 3 1 3 3 1 0 0...

n = 4 1 4 6 4 1 0...

这样一来只要提取数组元素C[n][k]，就是C(n,k)的值，比如C(4,2) = C[4][2] = 6。数组搭建过程实现如下：

1 double C[13][13];
2 memset(C, 0, sizeof(C));
3 C[0][0] = 1;
4 for (int i = 1; i < 13; ++i)
5 {
6     C[i][0] = 1;
7     for (int j = 1; j <= i; ++j)
8         C[i][j] = C[i-1][j-1] + C[i-1][j];
9 }

b) 取对数(log)问题

对数运算有一个性质：log(ABC...Z)=log(A)+log(B)+log(C)...log(Z)。

如果要比较几个元素的大小（所有元素都大于0），并且每个元素都由多个数的乘积构成，则可以简化为判断所有元素对数的大小（取对数不会影响增减性），这样一来对于每个元素来讲，并不需要计算多个数的乘法了，而是这些数取对数之后的加法。

这样计算有一个很大的好处，就是乘法运算本身很容易导致结果溢出，取对数变加法之后可以避免溢出，并且大大减小运算范围。

3. 对于每一种数字组合，列举所有可能出现的products，并对其进行计数

用一个mask，从1到1<<N遍历一遍，mask的二进制为1的相应位将参与product计算。比如mask为21，二进制表示为10101，那么该数字组合中，将从右数起的第1、3、5个数字相乘得到product。

 1 vector<unordered_map<long long, int>> products(total);
 2 for (int i = 0; i < total; ++i)
 3 {
 4     for (int mask = 1; mask < (1<<N); ++mask)
 5     {
 6         long long prod = 1;
 7         for (int j = 0; j < N; ++j)
 8             if (mask & (1<<j))
 9                 prod *= digits[i][j];
10         products[i][prod] += 1;
11     }
12 }

以上三步都是进行pre-computation，下面就是真正运行测试数据了。

4. 遍历每一种数字组合，计算该数字组合出现的概率，最后选取概率最高者输出。

给定product 1, 2, 3, ..., K的情况下，数字组合A出现的概率p(A) = A本身出现的概率prob[A] * product 1出现的概率products[A][product1] * .... * product K出现的概率products[A][product K]。

由于这些算好的概率都已经取号对数，所以应该用加法。

 1 while (R--)
 2 {
 3     vector<int> test_products;
 4     for (int i = 0; i < K; ++i)
 5         test_products.push_back(rll());
 6     int res_i = 0;
 7     double resProb = INT_MIN;
 8     for (int i = 0; i < total; ++i)
 9     {
10         double p = prob[i];
11         for (int k = 0; k < K; ++k)
12         {
13             if (test_products[k] == 1) break;
14             unordered_map<long long, int>::iterator it = products[i].find(test_products[k]);
15             if (it != products[i].end())
16             {
17                 p += log((double)it->second);
18             }
19             else
20             {
21                 p = INT_MIN;
22                 break;
23             }
24         }
25         if (resProb < p)
26         {
27             res_i = i;
28             resProb = p;
29         }
30     }
31     for (int i = 0; i < digits[res_i].size(); ++i)
32         printf("%d", digits[res_i][i]);
33     printf("\n");
34 }