电子科技大学_组合数学特别培养计划_重集程序设计

重集的组合计数问题
1需求分析
分析、设计并实现一个解决重集的组合计数程序，要求用容斥原理的方法，用VC 开发工具
2概要设计
2.1重集的组合数定义
从重集B={K1∙b1,k2∙b2,⋯,kn ∙bn}中选取r 个元素不考虑次序组合起来，称为从B 中取r 个元素的重复集合，简称B 的r-组合，其组合数记为F(n,r)
2.2定理1
重集B={∞∙b1,∞∙b2,⋯,∞∙bn}的r-组合数为
1(,)n r F n r r +-⎛⎫= ⎪⎝⎭
2.3定理2
重集B={K1∙b1,k2∙b2,⋯,kn ∙bn}在重复数ki=∞(i=1,2,···,n)时与在重复数ki ≥r(i=1,2,⋯,n)时的r-组合数是相同的。

3详细设计
3.1算法设计：
第1步，计算
1(,)r n r F n r r C +-⎛⎫== ⎪⎝⎭ 第2步，对i 从1到
12n -循环。

第2.1步，对i 进行二进制表达式1210n n x x x x -- ，j x =0或1
第2.2步，计算111
n i i i S x k -==∑
第2.3步，计算211n i i S x -==∑
第2.4步，计算12,()F n r S S ⎡⎤--⎣⎦ 第2.5步，计算12,()r r F n r C C S S ⎡⎤=±--⎣⎦（2S 为偶数时取+，否则取-）
第3步，r C 即为最终的r-组合数。

3.2代码实现
3.2.1开发环境
编程语言： 3.2.2编程实现
// chongji.cpp : 定义控制台应用程序的入口点。

/*
介绍：利用容斥原理实现重集的组合计数
作者：dimy
更新时间：2015-10-31
*/
#include "stdafx.h"
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <stdlib.h>
usingnamespace std;
vector <string > my_split(string str, string pattern);
int *Binarycout(int dec,int num);
int my_F(int n,int r);
longlong Jiecheng(longlong a);//构造函数求阶乘
longlong zuheshu(longlong n,longlong m);
int _tmain (int argc , _TCHAR * argv [])
{
int r = 0;
int len = 0;
int len_loop = 0;
string str_chongji = "";//保存输入数据 string pattern = " ";
vector<string> coefficient;//保存分割后的输入数据
longlong Cr = 0;
//输出提示
//printf("%s", "请输入要从重集B={K1∙b1,k2∙b2,⋯ ,kn∙bn}中选出的个数r:\n");
cout <<"请输入要从重集B={k1*b1,k2*b2,...,kn*bn}中选出的个数r:"<< endl; //输入r
cin >> r;
//cout << r << endl;
//消除上一次输入对下一次输入的影响
cin.ignore();
//输入重集
cout <<"请输入重集B，只需要要输入重集的系数即可，以空格隔开:"<< endl; getline(cin,str_chongji);
//cout << str_chongji<<endl;
//将字符串分割成数组，然后计算长度
coefficient = my_split(str_chongji, pattern);
//cout << "输入长度为：" << coefficient.size() << endl;
len = coefficient.size();
len_loop = int(pow(2, len))-1;
//将每个i用二进制表示
//int *binary_i = new int(coefficient.size());
//binary_i = dtob(10);
Cr = zuheshu((len+r-1),r);
for (int i = 1; i <= len_loop; i++){
int *binary_i = Binarycout(i, len);
longlong S1 = 0;
longlong S2 = 0;
/*for (int j = 1; j <= len; j++)
{
cout << binary_i[j-1];
}*/
//cout << endl;
for (int j = 1; j <= len; j++)
{
S1 += binary_i[j-1] * atoi(coefficient[j-1].c_str());
S2 += binary_i[j-1];
}
longlong F = zuheshu(len,(r-S1-S2));
if (S2 % 2 == 0){
Cr += F;
}
else{
Cr -= F;
}
//cout << S1 << endl;
//cout << S2 << endl;
}
cout <<"重集B的r-组合数为："<<Cr << endl;
while(1);
return 0;
}
//字符串分割函数
vector<string> my_split(string str, string pattern)
{
vector<string> ret;
if (pattern.empty()) return ret;
size_t start = 0, index = str.find_first_of(pattern, 0);
while (index != str.npos)
{
if (start != index)
ret.push_back(str.substr(start, index - start));
start = index + 1;
index = str.find_first_of(pattern, start);
}
if (!str.substr(start).empty())
ret.push_back(str.substr(start));
return ret;
}
/*
一般方法，32位，逐步与1做与运算。

功能：十进制转二进制
参数：dec 需要转换的十进制,num要转换成多少位
*/
int *Binarycout(int dec,int num)
{
int *p = newint(num);
for (int i = num-1; i>=0; i--)
{
//cout<<((dec>>i)& 1);
p[i] = (dec>> i) & 1;
}
return p;
}
/*
功能：计算组合数
*/
int my_F(int n, int r){
return 0;
}
//阶乘计算
longlong Jiecheng(longlong a)//构造函数求阶乘
{
if (a> 1)
return a*Jiecheng(a - 1);
else
return 1;
}
/*
计算组合数C(m,n)
注意：4 294 967 296最大数，因此需要注意越界问题
*/
longlong zuheshu(longlong n,longlong m){
if (m< 0){
return 0;
}
else{
return Jiecheng(n) / (Jiecheng(m)*Jiecheng(n - m));
}
}
4测试
4.1测试最简单的重集
每一个元素只出现一次，r取3
{ a1,a2,a3,a4,a5}
运行程序：
运行结果为10，正确
4.2测试复杂一点的重集
{3*a1,4*a2,5*a3,6*a4,2*a5}，r取4 运行程序：
5总结
通过实践，对容斥原理有了更加深入的认识，同时对组合数学与计算机技术的结合表示魅力很大，通过编程，可以把复杂的计算很快解决，节省了大量的时间，由于时间仓促，设计文档不是很规范，希望以后在此方面有所改进。