UVa12298（生成函数的简单应用+FFT）

I have a set of super poker cards, consisting of an infinite number of cards. For each positive composite integer p, there are exactly four cards whose value is p: Spade(S), Heart(H), Club(C) and Diamond(D).

There are no cards of other values.

我有一副超级扑克包含无数张牌，如果数字是正合数的话，那就有四种牌：黑桃（S）、红桃（H）、梅花（C）、方片（D）。

By “composite integer”, we mean integers that have more than 2 divisors. For example, 6 is a composite integer, since it has 4 divisors: 1, 2, 3, 6; 7 is not a composite number, since 7 only has 2 divisors: 1 and 7. Note that 1 is not composite (it has only 1 divisor).

比如6有4个因子（1，2，3，6）所以它是合数；7只有两个（1，7）那就不是合数。

Given a positive integer n, how many ways can you pick up exactly one card from each suit (i.e. exactly one spade card, one heart card, one club card and one diamond card), so that the card values sum to n? For example, if n = 24, one way is 4S + 6H + 4C + 10D, shown below:

给定一个整数n，从四种花色各选一张牌，使得四张牌点数和为n，求解有多少种选法组合。比如n=24时，其中的一种选法可以为24=4+6+4+10，如下图所示：

Unfortunately, some of the cards are lost, but this makes the problem more interesting. To further make the problem even more interesting (and challenging!), I’ll give you two other positive integers a and b, and you need to find out all the answers for n = a, n = a + 1, ..., n = b.

不幸的是有的牌丢失了，样例会给出哪些丢了。并且为了题目更加因吹斯听，实际上不是给你n，而是给两个数a、b，输出所有n=a、n=a+1、n=a+2、……、n=b时的答案。

Input
The input contains at most 25 test cases. Each test case begins with 3 integers a, b and c, where c is the number of lost cards. The next line contains c strings, representing the lost cards. Each card is formatted as valueS, valueH, valueC or valueD, where value is a composite integer. No two lost cards are the same. The input is terminated by a = b = c = 0. There will be at most one test case where a = 1, b = 50,000 and c ≤ 10,000. For other test cases, 1 ≤ a ≤ b ≤ 100, 0 ≤ c ≤ 10.

输入有多组数据，每组数据第一行三个整数a、b、c，a、b如上，c为丢失卡牌数；第二行给出c个具体的卡牌为丢失的。abc均为0时输入结束。

Output
For each test case, print p integers, one in each line. Print a blank line after each test case.

输出如题~记得空行

Sample Input
12 20 2

4S 6H

0 0 0
Sample Output
0

0

0

0

0

0

1

0

3

拜早年啦！年夜是刷题，还是边看番边刷题，还是带亲戚家小孩刷题啊？

口胡思路：

先以只有两色四张牌的简单题为例。假如第一个花色S有4和6两个点数，则可以用一个多项式表示所有可选情况：x^4 + x^6；第二个花色H有8和10两个点数，可用：x^8 + x^10表示。

我们将这两式相乘得（x^4 + x^6）（x^8 + x^10） = x^12 + 2 * x^14 + x^16，这个结果代表的意义就是：和为12的组合有1种，和为14的组合有2种（4S+10H或6S+8H），和为16的有1种。

好，那么对应到最开始的这道题目上来，就是稍微复杂了一点。对于每个花色，x的次幂为质数时系数为0，即多项式中只存在合数项。然后合数中也会有丢失的，其系数也置零。接下来四个多项式相乘即可，最终的多项式中x的次幂为n的项的系数，就是和为n的组合数。

事实上，这是离散数学中的一个小知识点，如题，是生成函数的一个简单应用，在此处帮大家复习一下。

另外，两多项式相乘的朴素做法显然是O（n^2）的，用FFT或者NTT加速成nlogn喽。不过快速傅里叶变换和数论变换不是一两句话可以口胡明白的，也不是本文想讲的知识，姑且略去……

最后，如果自己手写的FFT而没用complex库里的复数运算的话，这题卡精度，要用long double。

诸君来看代码吧：

 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <algorithm>
 using namespace std;

 const int maxn = ;
 const long double PI = acos(-1.0);

 struct Complex {
     long double x, y;
     Complex(long double a = , long double b = ):x(a), y(b){}
 };
 //手写复数运算
 Complex operator + (Complex A, Complex B) { return Complex(A.x + B.x, A.y + B.y); }
 Complex operator - (Complex A, Complex B) { return Complex(A.x - B.x, A.y - B.y); }
 Complex operator * (Complex A, Complex B) { return Complex(A.x * B.x - A.y * B.y, A.x * B.y + A.y * B.x); }

 Complex n[maxn * ], m[maxn * ];//像线段树一样要开4倍
 int r[maxn * ], l, limit, nl;
 /*---以上为FFT所需部分---*/

 int a, b, c;//abc含义见题面
 bool composite[maxn];//合数记录
 bool lost[][maxn];//卡牌丢失记录

 void init(int n) {//求50000以内的合数
     int m = int(sqrt(n) + 0.5);
     for (int i = ; i <= m; i++)
         if (!composite[i])
             for (int j = i * i; j <= n; j += i)
                 composite[j] = ;
 }

 const char *ss = "SHCD";
 int idx(char c) {//巧得丢失字符位置
     return strchr(ss, c) - ss;
 }

 /*--以下为一个普通的FFT板子--*/
 void fft_init() {
     limit = , l = ;
     while (limit < *(b + )) {
         limit <<= ;
         l++;
     }

     for (int i = ; i < limit; i++)
         r[i] = (r[i>>] >> ) | ((i&) << (l-));
 }

 void fft(Complex *A, int type) {
     for (int i = ; i < limit; i++)
         if (i < r[i])
             swap(A[i], A[r[i]]);

     for (int mid = ; mid < limit; mid <<= ) {
         Complex Wn(cos(PI / mid), type * sin(PI / mid));
         for (int R = mid << , j = ; j < limit; j += R) {
             Complex w(, );
             for (int k = ; k < mid; k++, w = w * Wn) {
                 Complex x = A[j+k], y = w * A[j+k+mid];
                 A[j+k] = x + y;
                 A[j+k+mid] = x - y;
             }
         }
     }
 }

 void Fourier(Complex *A, Complex *B) {
     fft(A, );
     fft(B, );
     for (int i = ; i < limit; i++)
         A[i] = A[i] * B[i];
     fft(A, -);
     for (int i = ; i < nl + b + ; i++)
         A[i].x /= limit, A[i].y = 0.0;
 }
 /*---FFT结束---*/

 int main() {
     init();//求5万以内合数
     while (~scanf("%d%d%d", &a, &b, &c) && a) {
         memset(lost, false, sizeof(lost));//丢牌数组
         for (int i = ; i < c; i++) {
             int temp; char ch;
             scanf("%d%c", &temp, &ch);
             lost[idx(ch)][temp] = ;//这张牌丢了
         }

         n[].x = 1.0, n[].y = 0.0;//同下方m数组注释
         nl = ;
         fft_init();//这个东西反复调用没意义就先拿出来了
         for (int i = ; i < ; i++) {
             //n是上一轮结束时的多项式结果，nl是多项式n的长度
             //答案只要求a到b的多项式系数，所以次幂为b以上可以置零
             for (int j = nl; j <= limit; j++)
                 n[j].x = n[j].y = 0.0;
             //m数组用来表示当前花色的多项式，所以先全置零
             for (int j = ; j <= limit; j++)
                 m[j].x = m[j].y = 0.0;

             for (int j = ; j <= b; j++) {
                 if (composite[j] && !lost[i][j])
                     m[j].x = 1.0, m[j].y = 0.0;
                     //将这个合数的多项式系数设为复数（1 + 0*i），即实数的1
             }
             Fourier(n, m);//n和m这两个多项式相乘
             nl = b + ;//b+1的原因是常数项也是一项
         }

         for (int i = a; i <= b; i++)//x为实数项，即系数
             printf("%lld\n", (long long)(n[i].x + 0.5));
         puts("");
     }
     return ;
 }