母函数 <普通母函数（HDU - 1028 ） && 指数型母函数（hdu1521）>

给出我初学时看的文章：母函数（对于初学者的最容易理解的）

 

 

普通母函数--------->HDU - 1028

例题：若有1克、2克、3克、4克的砝码各一 枚，能称出哪几种重量？各有几种可能方案？
如何解决这个问题呢？考虑构造母函数。
如果用x的指数表示称出的重量，则：
    1个1克的砝码可以用函数1+x表示，
    1个2克的砝码可以用函数1+x2表示，（x2表示x的2次方）
    1个3克的砝码可以用函数1+x3表示，
    1个4克的砝码可以用函数1+x4表示，
(1+x)(1+x2)(1+x3)(1+x4)
=(1+x+x2+x3)(1+x3+x4+x7)
=1+x+x2+2x3+2x4+2x5+2x6+2x7+x8+x9+x10  （2x3表示用1、2、3、4砝码组成3的方式有2种，同样2x4表示用1、2、3、4砝码组成4的方式有2种）
    从上面的函数知道：可称出从1克到10克，系数便是方案数。
    例如右端有2x5 项，即称出5克的方案有2：5=3+2=4+1；同样，6=1+2+3=4+2；10=1+2+3+4。
    故称出6克的方案有2，称出10克的方案有1

 

如果一种砝码有多个，那么母函数怎么构造？
这样一来，一个括号内有多少个x，那么就表示有多少个砝码，如果有3个值为1的砝码，那么就是（1+x+x2+x3）,其中，xk中的k就表示用k个值为1的组成，他的系数为1，也就是说用只用值为1的要配出3出来只有一种方法。

按照上面的方法，3个值为2的砝码那就是（1 + x2 + x4 + x6）,x6相当于（x2）3，就是说3 个值为2的构成6。同理如果有3个值为3的砝码，那就是（1+x3+x6+x9）

 

代码：

//母函数板子题
#include<iostream>
#include<queue>
#include<vector>
#include<string.h>
#include<stdio.h>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=125;
int c1[maxn],c2[maxn];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=0;i<=n;++i)  //给c1数组初赋值为1，就是操作的第一个括号
            c1[i]=1,c2[i]=0;
        for(int i=2;i<=n;++i)  //操作第i个括号
        {
            for(int j=0;j<=n;++j)  //对指数j进行枚举
            {
                for(int k=0;k+j<=n;k+=i)  //这个k枚举的是i可以组成的数
                {
                    c2[j+k]+=c1[j];  //记录系数
                }
            }
            for(int j=0;j<=n;++j)
            {
                c1[j]=c2[j];
                c2[j]=0;
            }
        }
        printf("%d\n",c1[n]);
    }
    return 0;
}

 

这里再给出普通母函数的一道变形题：The Balance HDU - 1709

题意：

给你一些砝码和一个天平，你要找出来在范围[1,S]中，哪些质量你称不出来并输出。。这个S是所有砝码质量之和

 

样例解析：

输入

3
9 2 1

Sample Output 

2
4 5

 

有三个质量为9，2，1的砝码，在范围[1,12]中有4，5两个质量称不出来。。。

可能有人很疑惑6，7，8怎么称出来的，，如果9这个砝码在一个盘，1，2砝码在另一个盘就可以了。。。

 

代码较原代码有就只有一点改变：

#include<iostream>
#include<queue>
#include<vector>
#include<string.h>
#include<stdio.h>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=105;
int c1[maxn*maxn],c2[maxn*maxn],v[maxn];
int main()
{
    int n;
    queue<int>r;
    while(~scanf("%d",&n))
    {
        int sum=0;
        memset(c1,0,sizeof(c1));
        memset(c2,0,sizeof(c2));
        for(int i=1;i<=n;++i)
        {
            scanf("%d",&v[i]);
            sum+=v[i];
        }
        c1[0]=1;
        for(int i=1;i<=n;++i)
        {
            for(int j=0;j<=sum;++j)
            {
                for(int k=0;k+j<=sum && k<=v[i];k+=v[i])
                {
                    if(j>k) c2[j-k]+=c1[j];
                    else c2[k-j]+=c1[j];
                    c2[k+j]+=c1[j];
                }
            }
            for(int j=0;j<=sum;++j)
                c1[j]=c2[j];//,c2[j]=0;
        }
        for(int i=1;i<=sum;++i)
        {
            if(!c1[i])
                r.push(i);
        }
        printf("%d\n",r.size());
        int flag=0;
        while(!r.empty())
        {
            if(!flag)
            printf("%d",r.front()),flag=1;
            else printf(" %d",r.front());
            r.pop();
        }
        if(flag)
        printf("\n");
    }
    return 0;
}

代码中c1[i]仍然代表能构成i质量的方法数，因为本题不涉及方法数，也就无关大小了。。。

 

指数型母函数--------->HDU - 1521

题目：

有n种物品，并且知道每种物品的数量。要求从中选出m件物品的排列数。例如有两种物品A,B，并且数量都是1，从中选2件物品，则排列有"AB","BA"两种。

Input每组输入数据有两行，第一行是二个数n,m(1<=m,n<=10)，表示物品数，第二行有n个数，分别表示这n件物品的数量。Output对应每组数据输出排列数。(任何运算不会超出2^31的范围)Sample Input

2 2
1 1

Sample Output

2

 

指数型母函数：（用来求解多重集的排列问题）
    n个元素，其中a1，a2，····，an互不相同，进行全排列，可得n!个不同的排列。
    若其中某一元素ai重复了ni次，全排列出来必有重复元素，其中真正不同的排列数应为 （n！/ni！），重复度为ni！

同理a1重复了n1次，a2重复了n2次，····，ak重复了nk次，n1+n2+····+nk=n。对于这样的n个元素进行全排列，可得不同排列的个数实际上是（n！/(n1!*n2!...nk!)）.若只对其中的r个元素进行排列呢，那就用到了指数型母函数。

 

 

 

 

 

 仔细看指数型母函数和普通母函数的构造函数之间的差别就是指数型多了一个分母，其他的还是没有变化。具体见代码：

#include<iostream>
#include<queue>
#include<vector>
#include<string.h>
#include<stdio.h>
#include<queue>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=105;
double c1[maxn*maxn],c2[maxn*maxn],v[maxn];
double jiecheng(int n)
{
    double ans=1.0;
    for(int i=1; i<=n; i++)
        ans*=i;
    return ans;
}
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0; i<n; ++i)
            scanf("%lf",&v[i]);
        memset(c1,0,sizeof(c1));
        memset(c2,0,sizeof(c2));
        c1[0]=1.0;
        double ans=1.0;
        for(int i=1; i<=v[0]; ++i)
        {
            ans*=(double)i;
            c1[i]=1.0/ans;
        }
        for(int i=1; i<n; ++i)
        {
            for(int j=0; j<=m; ++j)
            {
                ans=1.0;
                for(int k=0; k<=v[i] && j+k<=m; ++k)
                {
                    if(k==0)
                        c2[j+k]+=c1[j];
                    else ans*=(double)k,c2[j+k]+=c1[j]/ans;
                }
            }
            for(int j=0; j<=m; ++j)
                c1[j]=c2[j],c2[j]=0;
        }
        printf("%.0lf\n",c1[m]*jiecheng(m));
    }
    return 0;
}

 

指数型母函数变形-------->POJ3734

题意：

一段长度为nn nn的序列，你有红黄蓝绿四种颜色的砖块，一块砖长度为11 11，问你铺砖的方案数，其中红黄颜色之和必须为偶数。

 

题解：

泰勒展开式：
chx = (e^x+e^(-x))/2 = 1 + x^2/2! + x^4/4! + x^6/6! + ... ...
shx = (e^x-e^(-x))/2 = x + x^3/3! + x^5/5! + x^7/7! + ... ...

 

 

 因为我们最后求的是对n个方块的填充方式，那么肯定答案就是x的n次方的系数，即4^n-1+2^n-1

 

代码：

/*
指数型生成函数：

泰勒展开式：
chx = (e^x+e^(-x))/2 = 1 + x^2/2! + x^4/4! + x^6/6! + ... ...
shx = (e^x-e^(-x))/2 = x + x^3/3! + x^5/5! + x^7/7! + ... ...

参看链接：https://blog.csdn.net/qq_43464645/article/details/95488472
矩阵快速幂做法：https://www.cnblogs.com/bhlsheji/p/4049394.html

*/
#include<iostream>
#include<queue>
#include<vector>
#include<string.h>
#include<stdio.h>
#include<queue>
#include<math.h>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=105;
const ll  mod   = 10000 + 7;//19260817
const double pi = acos(-1.0);
ll n, res;
ll pow(ll a, ll n)
{
    ll ans = 1;
    while(n)
    {
        if(n & 1) ans = ans * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return ans;
}
int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        scanf("%lld", &n);
        printf("%lld\n", (1ll * pow(4, n - 1) % mod + pow(2, n - 1) % mod) % mod);
    }
    return 0;
}