普通型母函数

最新推荐文章于 2021-09-12 16:15:42 发布
最新推荐文章于 2021-09-12 16:15:42 发布
阅读量1.3k 收藏 5
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40507857/article/details/82824047
版权

生成函数（母函数）有普通生成函数和指数生成函数：

1.普通生成函数用于解决多重集的组合问题

2.指数型母函数用于解决多重集的排列问题

母函数可以解决递归数列的通项问题：斐波那契数列、卡特兰数列等

普通母函数：

    构造母函数G(x), G(x) = a0 + a1*x + a2*clip_image002 + a3*clip_image002[4] +....+ an*clip_image002[6]，  则称G(x)是数列a0,a1…an的母函数。

    通常普通母函数用来解多重集的组合问题，其思想就是构造一个函数来解决问题，一般过程如下：

    1.建立模型：

物品n种,每种数量分别为k1,k2,..kn个，每种物品又有一个属性值p1,p2,…pn,(如本题的字母价值)，求属性值和为m的物品组合方法数。（若数量ki无穷 也成立，即对应下面式子中第ki项的指数一直到无穷）

    2.构造母函数：

G(x)=(1+clip_image002[18]+clip_image002[20]…clip_image002[22])(1+clip_image002[26]+clip_image002[28]+…clip_image002[30])…(1+clip_image002[32]+clip_image002[34]+…clip_image002[38])         （一）

          =a0 + a1*x + a2*clip_image002 + a3*clip_image002[4] +....+ akk*clip_image002[16]     (设kk=k1·p1+k2·p2+…kn·pn)         （二）

                  G(x)含义： ak 为属性值和为k的组合方法数。

母函数利用的思想：

    1.把组合问题的加法法则和幂级数的乘幂对应起来。

    2.把离散数列和幂级数对应起来，把离散数列间的相互结合关系对应成为幂级数间的运算关系，最后由幂级数形式来

       确定离散数列的构造。

代码实现：

    求G(x)时一项一项累乘。先令G=1=(1+0*x+0*clip_image002[56]+…0*clip_image002[58]),再令G=G*(1+clip_image002[18]+clip_image002[20]…clip_image002[22])得到形式(二)的式子…最后令G=G*(1+clip_image002[32]+clip_image002[34]+…clip_image002[38])。

普通母函数通常解决类似如下的问题：

给5张1元，4张2元，3张5元，要得到15元，有多少种组合？

某些时候会规定至少使用3张1元、1张2元、0张5元。

某些时候会规定有无数张1元、2元、5元。

……

解题过程：

首先要写出表达式，通常是多项式的乘积，每项由多个 x^{y} 组成。

通用表达式为：

(x^(v[0]*n1[0])+x^(v[0]*(n1[0]+1))+x^(v[0]*(n1[0]+2))+...+x^(v[0]*n2[0]))

(x^(v[1]*n1[1])+x^(v[1]*(n1[1]+1))+x^(v[1]*(n1[1]+2))+...+x^(v[1]*n2[1]))

                                        ...............

(x^(v[K]*n1[K])+x^(v[K]*(n1[K]+1))+x^(v[K]*(n1[K]+2))+...+x^(v[K]*n2[K]))

K对应具体问题中物品的种类数。

V[i]表示该乘积表达式第 i 个因子的权重，对应具体问题的每个物品的价值或者权重

n1[i]表示该乘积表达式第 i 个因子的起始系数，对应于具体问题中的每个物品的最少个数，即最少要取多少个

n2[i]表示该乘积表达式第i个因子的终止系数，对应具体问题中的每个物品的最多个数，即最多要取多少个

解题的关键是要确定V，N1，N2数组的值

模板

//a为计算结果，b为中间结果
int a[MAX],b[MAX];
memset(a,0,sizeof a);
a[0]=1;
for(int i=1;i<=k;i++)//循环每个因子
{
    memset(b,0,sizeof(b));
    for(int j=n1[i];j<=n2[i]&&j*v[i]<=p;j++)//循环每个因子的每一项
        for(int k=0;k+j*v[i]<=p;k++)//循环a的每一项
         b[k+j*v[i]]+=a[k];//把结果加到对应位
    memccpy(a,b,sizeof b);//b赋值给a        
}

p是可能的最大指数，拿钞票组合的题来说，如果求15元有多少种组合，那么p就是15；如果问最小的不能拼出的数值，那么p就是所有钱加起来的和。

用一个last变量记录目前最大的指数，这样只需要在0--last上计算

改进模板

//初始化a，因为有last，所以这里无需初始化其他位
int last=0;
a[0]=1;
for(int i=1;i<=n;i++) {//循环每个因子
	int next=min(last+n2[i]*v[i],p);//计算下一次的last
	for(int j=n1[i];j<=n2[i]&&j*v[i]<=next;j++)//循环每个因子的每一项
		for(int k=0;k<=last&&k+j*v[i]<=next;k++)//循环a的每一项
			b[k+j*v[i]]+=a[k];//把结果加到对应位
	for(int k=0;k<maxn;k++) {//赋值
		a[k]=b[k]%mod;
		b[k]=0;
	}
	last=next;//更新last
}

例题

一、hdu 1085和hdu 1171两题套用了第二个模板，省略了代码中二三层循环里关于last2的条件（其实也可以加上）。

详见：

hdu1085 ：http://blog.csdn.net/xiaofei_it/article/details/17041467

import java.util.*;
import java.math.*;

public class Main {
	public static int maxn=8010;
	public static void main(String[] args) {
		int[] a=new int[maxn];//保存结果，a[i]表示组成i种水果的方案数为a[i]
		int[] b=new int[maxn];//中间结果
		int[] n1=new int[maxn];//第i种水果最少的个数
		int[] n2=new int[maxn];//第i种水果最多的个数
		int[] v=new int[maxn];//第i种水果的价值
		Scanner cin=new Scanner(System.in);
		
		//int T=cin.nextInt();      
		while(cin.hasNext()) {
			
			for(int i=0;i<maxn;i++) {
				a[i]=0;
				b[i]=0;
				n1[i]=0;
				n2[i]=0;
			}
			v[1]=1;v[2]=2;v[3]=5;
			
			int sum=0;
			for(int i=1;i<=3;i++) {
				n2[i]=cin.nextInt();
				sum+=n2[i];
			}
			
			if(sum==0)	break;
			
			a[0]=1;
			int p=0;
		//要求最小不能拼出的钱，p就是所有钱加起来的和
		for(int i=1;i<=3;i++)
			p=p+v[i]*n2[i];
		
			for(int i=1;i<=3;i++) {
				
				for(int k=0;k<maxn;k++)
					b[k]=0;
				
				for(int j=n1[i];j<=n2[i]&&j*v[i]<=p;j++)
					for(int k=0;k+j*v[i]<=p;k++)
						b[k+j*v[i]]+=a[k];
				
				for(int k=0;k<maxn;k++)
					a[k]=b[k];
			}
			int ans=0;
			//遍历找出方案数为0的钱币组合
			for(int i=1;i<maxn;i++)
				if(a[i]==0) {
					ans=i;
					break;
				}
				
			System.out.println(ans);
		}
		cin.close();
	}
}

hdu 1171：http://blog.csdn.net/xiaofei_it/article/details/17041709

import java.util.*;
import java.math.*;

public class Main {
	public static int maxn=250000,maxm=60;
	public static void main(String[] args) {
		int[] a=new int[maxn];//保存结果，a[i]表示组成i种水果的方案数为a[i]
		int[] b=new int[maxn];//中间结果
		
		int[] n1=new int[maxm];//第i种水果最少的个数
		int[] n2=new int[maxm];//第i种水果最多的个数
		int[] v=new int[maxm];//第i种水果的价值
		Scanner cin=new Scanner(System.in);
		
		//int T=cin.nextInt();      
		while(cin.hasNext()) {
			
			for(int i=0;i<maxn;i++) {
				a[i]=0;
				b[i]=0;
				
			}
			
			for(int i=0;i<maxm;i++) {
				n1[i]=0;
				n2[i]=0;
				v[i]=0;
			}
			
			int n=cin.nextInt();
			if(n<0)	break;
			
			int sum=0;
			for(int i=1;i<=n;i++) {
				v[i]=cin.nextInt();
				n2[i]=cin.nextInt();
				sum+=v[i]*n2[i];
			}
	
			int p=sum;
			//if(sum%2==1)	p++;
			
			a[0]=1;
			for(int i=1;i<=n;i++) {
				for(int k=0;k<maxn;k++)
					b[k]=0;
				
				for(int j=n1[i];j<=n2[i]&&j*v[i]<=p;j++)
					for(int k=0;k+j*v[i]<=p;k++)
						b[k+j*v[i]]+=a[k];
				
				for(int k=0;k<maxn;k++)
					a[k]=b[k];
			}
			int ans=0;
			for(int i=p/2;i>=0;i--) {
				if(a[i]!=0) {
					ans=i;
					break;
				}
			}
			System.out.println(p-ans+" "+ans);
		}
		cin.close();
	}
}

二、hdu 1398套用了第一个模板，因为n2中每一项为无穷大，所以n2数组就省略了。

详见：

hdu 1398：http://blog.csdn.net/xiaofei_it/article/details/17041815

import java.math.*;
import java.util.*;
public class Main {
	public static int maxn=300*300+10;
	static int[] a=new int[maxn];
	static int[] b=new int[maxn];
	static int[] v=new int[30];
	static void init() {
		for(int i=0;i<maxn;i++) {
			a[i]=0;b[i]=0;
		}
		for(int i=1;i<=17;i++)
			v[i]=i*i;
		
		a[0]=1;
		for(int i=1;i<=17;i++) {
			for(int j=0;j*v[i]<=300;j++)
				for(int k=0;k+j*v[i]<=300;k++)
					b[k+j*v[i]]+=a[k];
			for(int k=0;k<maxn;k++) {
				a[k]=b[k];
				b[k]=0;
			}
		}
	}
	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);
		init();
		while(cin.hasNext()) {
			int n=cin.nextInt();
			if(n==0) break;
			System.out.println(a[n]);
		}
		cin.close();
	}
}

三、hdu 2079、hdu 2082和hdu 2110三题直接套用了第二个模板。

详见：

hdu2079

http://blog.csdn.net/xiaofei_it/article/details/17042045

import java.math.*;
import java.util.*;
public class Main {
	public static int maxn=400;
	static int[] a=new int[maxn];
	static int[] b=new int[maxn];
	static int[] v=new int[maxn];
	static int[] n1=new int[maxn];
	static int[] n2=new int[maxn];
	
	static void init() {
		for(int i=0;i<maxn;i++) {
			a[i]=0;b[i]=0;
			v[i]=0;
			n1[i]=0;n2[i]=0;
		}
	}
	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);
		int T=cin.nextInt();
		while(T!=0) {
			T--;
			init();
			int p=cin.nextInt();
			int n=cin.nextInt();
			
			for(int i=1;i<=n;i++) {
				v[i]=cin.nextInt();
				n2[i]=cin.nextInt();
			}
			a[0]=1;
			for(int i=1;i<=n;i++) {
				for(int j=n1[i];j<=n2[i]&&j*v[i]<=p;j++)
					for(int k=0;k+j*v[i]<=p;k++)
						b[k+j*v[i]]+=a[k];
				for(int k=0;k<maxn;k++) {
					a[k]=b[k];
					b[k]=0;
				}
			}
			System.out.println(a[p]);
		}
		cin.close();
	}
}

hdu2082:

http://blog.csdn.net/xiaofei_it/article/details/17042253

import java.util.*;
import java.math.*;

public class Main {
	public static int maxn=110;
	public static void main(String[] args) {
		int[] a=new int[maxn];//保存结果，a[i]表示组成i种水果的方案数为a[i]
		int[] b=new int[maxn];//中间结果
		int[] n1=new int[maxn];//第i种水果最少的个数
		int[] n2=new int[maxn];//第i种水果最多的个数
		int[] v=new int[maxn];//第i种水果的价值
		Scanner cin=new Scanner(System.in);
		
		int T=cin.nextInt();      
		while(T!=0) {
			T--;
			for(int i=0;i<maxn;i++) {
				a[i]=0;
				b[i]=0;
				n1[i]=0;
				n2[i]=0;
				v[i]=i;
			}
			
			for(int i=1;i<=26;i++)
				n2[i]=cin.nextInt();
			
			a[0]=1;
			int p=50;
			for(int i=1;i<=26;i++) {
				for(int k=0;k<maxn;k++)
					b[k]=0;
				
				for(int j=n1[i];j<=n2[i]&&j*v[i]<=p;j++)
					for(int k=0;k+j*v[i]<=p;k++)
						b[k+v[i]*j]+=a[k];
				
				for(int k=0;k<maxn;k++)
					a[k]=b[k];
			}
			long ans=0;
			for(int i=1;i<=p;i++)
				ans+=a[i];
			System.out.println(ans);
		}
		cin.close();
	}
}

hdu 2110：

http://blog.csdn.net/xiaofei_it/article/details/17042421

import java.math.*;
import java.util.*;
public class Main {
	static int mod=10000;
	public static int maxn=10000+7;
	static long[] a=new long[maxn];
	static long[] b=new long[maxn];
	static int[] v=new int[maxn];
	static int[] n1=new int[maxn];
	static int[] n2=new int[maxn];
	
static int min(int a,int b) {
	return a<b?a:b;
}
	static void init() {
		for(int i=0;i<maxn;i++) {
			a[i]=0;b[i]=0;
			v[i]=0;
			n1[i]=0;n2[i]=0;
		}
	}
	public static void main(String[] args) {
		Scanner cin=new Scanner(System.in);
		//int T=cin.nextInt();
		while(cin.hasNext()) {
			init();
		
			int n=cin.nextInt();
			if(n==0)	break;
			int p=0;
			for(int i=1;i<=n;i++) {
				v[i]=cin.nextInt();
				n2[i]=cin.nextInt();
				p+=v[i]*n2[i];
			}
			if(p%3!=0) {
				System.out.println("sorry");
				continue;
			}
			p/=3;
			int last=0;
			a[0]=1;
			for(int i=1;i<=n;i++) {
				int next=min(last+n2[i]*v[i],p);//计算下一次的last
				for(int j=n1[i];j<=n2[i]&&j*v[i]<=next;j++)
					for(int k=0;k<=last&&k+j*v[i]<=next;k++)
						b[k+j*v[i]]+=a[k];
				for(int k=0;k<maxn;k++) {
					a[k]=b[k]%mod;
					b[k]=0;
				}
				last=next;//更新last
			}
			if(a[p]!=0)
			System.out.println(a[p]%mod);
			else
				System.out.println("sorry");
		}
		cin.close();
	}
}

另外，至于什么时候用第一个模板，什么时候用第二个模板，就看题目规模。 通常情况下，第一个模板就够用了，上面的那些用第二个模板的题目用第一个模板同样能AC。 但如果数据规模比较大（通常不会有这种情况），就要使用第二个模板了。 以上题目n1均为0。

四、hdu 2152是一道n1不为0的题目，我在这里分别套用第一个和第二个模板解题。

详见： hdu 2152：http://blog.csdn.net/xiaofei_it/article/details/17042497

C++

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=130;
int a[maxn],b[maxn];
int n1[maxn],n2[maxn];
int v[maxn];
void init()
{
    memset(a,0,sizeof a);
    memset(b,0,sizeof b);
    memset(n1,0,sizeof n1);
    memset(n2,0,sizeof n2);
}
int main()
{
  for(int i=0;i<maxn;i++)
    v[i]=1;
  int n,m;
  while(scanf("%d%d",&n,&m)!=EOF){
        init();
    for(int i=1;i<=n;i++)
        scanf("%d%d",&n1[i],&n2[i]);
    a[0]=1;
    for(int i=1;i<=n;i++)
    {
        memset(b,0,sizeof b);
        for(int j=n1[i];j<=n2[i]&&j*v[i]<=m;j++)
            for(int k=0;k+j*v[i]<=m;k++)
            b[k+v[i]*j]+=a[k];
        //memcpy(a,b,sizeof b);
        for(int k=0;k<maxn;k++)
            a[k]=b[k];
    }
    printf("%d\n",a[m]);
  }
}

Java

import java.util.*;
import java.math.*;

public class Main {
	public static int maxn=110;
	public static void main(String[] args) {
		int[] a=new int[maxn];//保存结果，a[i]表示组成i种水果的方案数为a[i]
		int[] b=new int[maxn];//中间结果
		int[] n1=new int[maxn];//第i种水果最少的个数
		int[] n2=new int[maxn];//第i种水果最多的个数
		int[] v=new int[maxn];//第i种水果的价值
		Scanner cin=new Scanner(System.in);
		
		//int T=cin.nextInt();      
		while(cin.hasNext()) {
			for(int i=0;i<maxn;i++) {
				a[i]=0;b[i]=0;n1[i]=0;n2[i]=0;
				v[i]=1;
			}
			int n=cin.nextInt();
			int m=cin.nextInt();
			
			for(int i=1;i<=n;i++) {
				n1[i]=cin.nextInt();
				n2[i]=cin.nextInt();
			}
			
			a[0]=1;
			for(int i=1;i<=n;i++) {//循环每一个因子
				
				for(int k=0;k<maxn;k++)
					b[k]=0;
				
				for(int j=n1[i];j<=n2[i]&&j*v[i]<=m;j++)//循环每个因子的每一项
					for(int k=0;k+j*v[i]<=m;k++)//循环a的每一项
						b[k+j*v[i]]+=a[k];//把结果加到对应的位
				
				for(int k=0;k<maxn;k++)//b赋值给a
					a[k]=b[k];
			}
			System.out.println(a[m]);
		}
		cin.close();
	}
}

 

紫芝
关注
快乐地打牢基础（13）——普通型母函数和指数型母函数的应用
Miserable_ccf的博客
10-11 1435
普通型母函数 1.定义 对于任意数列a0,a1,a2...ana_0,a_1,a_2...a_na0​,a1​,a2​...an​，用如下方法与一个函数联系起来： G(x)=a0+a1x+a2x2+...+anxn G(x) = a_0+a_1x+a_2x^2+...+a_nx^n G(x)=a0​+a1​x+a2​x2+...+an​xn 则称G(x)G(x)G(x)是数列的母函数(gener...
组合数学6--母函数与递推关系
weixin_39491014的博客
07-10 2321
递推关系（recurrence relation） 1.定义 递推关系即差分方程，是一种递推的定义一个序列的方程式，序列的每一项定义为前若干项的函数。 2.HANOI问题 大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。 大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。 在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。 可以通过两个盘子的挪动方法递推出nnn个盘子的挪动方法。 假设挪动nnn个盘子的复杂度为h(n)h(n)h(n..
普通母函数
weixin_30483697的博客
05-19 63
struct node//用于存储每个元素的大小与数量 { int value;//大小 int num;//数量 }lottery[100];void Generating(int n, int sum)//母函数过程，n表示元素的个数，sum表示和的最大值 { int c1[1000] = {1}; int c2[1000] = {0}; int i, j, k; for...
普通母函数的原理及实现
bjrxyz的专栏
10-29 1986
在用到母函数之前啊，恐怕很少有人听过母函数，我也一样，我当时是做杭电acm的2082题要用母函数做才去了解母函数的。当然母函数分为很多种，包括普通母函数、指数母函数、L级数、贝尔级数和狄利克雷级数，我这里说的都是普通母函数。 什么是普通母函数呢，——把组合问题的加法法则和幂级数的的乘幂的相加对应起来，这句话可能一开始难以理解，不过其实学完了之后很容易理解，母函数的思想很简单—就是把离散数列和幂级
HDU 2082 普通型母函数
weixin_34402090的博客
05-28 76
分析： 组成单词好说，价值如何体现？ 改变指数就行，例如： 这样，组成的单词，指数就是权值，多项式相乘，指数小于50的就OK； 1 #include <bits/stdc++.h> 2 3 using namespace std; 4 5 int ch[30]; 6 int a[100]; 7 int b[100]; ...
【组合数学】 普通型母函数（整数拆分问题，多重集的组合问题）
Qiuker_jl的博客
11-01 1406
文章目录1.母函数概念2. 整数拆分问题3.母函数是如何应用于整数拆分问题的？4.模板（数N的划分方案数）5.练手题目 1.母函数概念 母函数是数学中的一个概念。其在acm中主要应用于整数拆分问题。简单的来说： 对于一个序列a0,a1,a2,⋅⋅⋅⋅⋅⋅ana_0,a_1,a_2,\cdot\cdot\cdot\cdot\cdot\cdot a_na0​,a1​,a2​,⋅⋅⋅⋅⋅⋅an​，我们称a0a_0a0​+a1xa_1xa1​x+a2x2a_2x^2a2​x2⋅⋅⋅⋅⋅⋅+anxn\cdot\cd
【母函数|生成函数】学习母函数
Z_sea的博客
01-19 1134
参考文献（尊重原创）： 二项式定理 递归和母函数 母函数（对于初学者的最容易理解的） 例题： 普通母函数： 找单词                   题解 摆花                       题解 指数性母函数： "红色病毒"问题     题解（暂无）    母函数是什么？       母函数是求解组合数学中计数问题的重要方法，其效率高，编程规范，容易实现。...
组合数学之母函数介绍 acm 相关
05-08
普通型母函数源于二项式定理，它表示的是多项式 `(1+x)^n` 展开后的形式。这个公式告诉我们，当你从n个不同元素中选择0到n个元素时，所有可能的选择方案的总数。例如，`(1+x)^3` 展开为 `1 + 3x + 3x^2 + x^3`，这...
普通型母函数模板理解
ACM_hades的梦想之路
08-09 1315
今天学习了一下母函数的知识，感觉它像是专门做一类题用的。 推荐一个比较好的入门的母函数博客：http://www.wutianqi.com/?p=596 我写这篇文章的目的，就是为了再次总结一下他写的那个模板，毕竟看了很久才懂的。 这里我以 hdu 1028 这道题为例 这道题目的大致意思是：给你一个正整数N，然后要你求有多少种可以加到N的方式。 #include #include #i
普通型母函数模板
asd1170586462的博客
12-09 235
题面是hdu1085普通型母函数说白了就是一个模拟多项式相乘的代码#include<cstdio> #include<cstring> #include<string> #include<cmath> #include<algorithm> #include<iostream> #define ll long long using namespace std; #define _max 12345
母函数（普通型、指数型）
Shanhj的博客
09-12 827
先从几个简单的问题开始（普通型）： 问题1：有面值为1元、2元、3元的纸币各一张，要凑出3元，有几种取法？ 很容易就能得出是2种取法。 如果用x的系数表示面值，可以得到母函数G(x)=(1+x)(1+x2)(1+x3) 将其展开得：G(x)=1+x+x2+2x3+x4+x5+x6 x3前面的系数代表了凑出面值为3的方案数。 解释： 因为多项式展开时的运算类似于排列组合，并且两个项相乘其实就是x指数的相加，所以最终可以用系数来表示方案数。这就是普通型母函数。 关于括号里为什么是1+xn的形式：1表示某种面值的
普通生成函数（母函数）
qq_2992427261
09-18 540
生成函数 在数学中，某个序列（an）的母函数（又称生成函数，英语：Generating function）是一种形式幂级数，其每一项的系数可以提供关于这个序列的信息。使用母函数解决问题的方法称为母函数方法。 母函数可分为很多种，包括普通母函数、指数母函数、L级数、贝尔级数和狄利克雷级数。对每个序列都可以写出以上每个类型的一个母函数。构造母函数的目的一般是为了解决某个特定的问题，因此选用何种母函数视...
普通型母函数和指数型母函数
Sean
08-04 5739
母函数：摘自百度百科 生成函数即母函数，是组合数学中尤其是计数方面的一个重要理论和工具。生成函数有普通型生成函数和指数型生成函数两种，其中普通型用的比较多。形式上说，普通型生成函数用于解决多重集的组合问题，而指数型母函数用于解决多重集的排列问题。母函数还可以解决递归数列的通项问题（例如使用母函数解决斐波那契数列的通项公式） 理解： 什么是普通母函数呢，——把组合问题的加法法则和幂级数的的乘幂...
母函数（对于初学者的最容易理解的）
热门推荐
yu121380的博客
04-12 4万+
普通母函数： 在用到母函数之前啊，恐怕很少有人听过母函数，我也一样，我当时是做杭电acm的2082题要用母函数做才去了解母函数的。当然母函数分为很多种，包括普通母函数、指数母函数、L级数、贝尔级数和狄利克雷级数，我这里说的都是普通母函数。 什么是普通母函数呢，——把组合问题的加法法则和幂级数的的乘幂的相加对应起来，这句话可能一开始难以理解，不过其实学完了之后很容易理解，母函数的思想很简单—就是...
普通型母函数原理及模板代码详解
zuzhiang的博客
09-12 1231
母函数有很多种，最常用的有普通型母函数和指数型母函数。两者区别是：普通型母函数主要是来求组合的方案数，而指数型母函数是求多重排列数。下面只讲解普通型母函数的相关知识。定义：若函数G(x)=a0+a1*x+a2*x^2+……+an*x^n，则称函数G(x)为序列a0、a1、a2、……an的母函数。例如：(1+x)^n=1+C(n,1)*x+C(n,2)*x^2+……+C(n,n)*x^n 就是序列 ...
普通母函数理解篇（PPT）
ludan_xia的博客
02-19 369
前辈的优秀博客母函数入门+模板http://blog.csdn.net/vsooda/article/details/7975485#replyhttp://blog.csdn.net/winter2121/article/details/55535894例一：解决砝码问题：若有1克、2克、3克、4克的砝码各一 枚，能称出哪几种重量？各有几种可能方案？考虑构造母函数，如果用x的指数表示称出来的重量...
C++：成员函数详解 - 普通、虚、纯虚函数的区别与应用
"C++语言中的成员函数类型包括普通成员函数、虚函数和纯虚函数，它们在类的设计和多态性方面扮演着不同角色。普通成员函数不具备运行时多态性，虚函数则用于实现多态，而纯虚函数则是抽象类的标志，强制要求派生类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值