模拟手算，计算组合数C(m,n)

最新推荐文章于 2023-01-30 12:58:12 发布
最新推荐文章于 2023-01-30 12:58:12 发布
阅读量272 收藏
点赞数
原文链接：http://www.cnblogs.com/h46incon/archive/2011/01/30/1948098.html
版权

在笔算组合数的时候，有个很重要的步骤是将分子分母约分。而这讨论的也就是这个约分的过程。

C(m,n) = m*(m-1)*(m-2)*…*(m-n+1) / n!

下文中的分子的因子为m-n+1~m的所有整数。

首先是要储存分子的因子，在这没考虑效率的问题，直接用vector<unsigned>做容器，将分子储存在容器变量arry中，储存顺序为由大到小。

void aryMake(unsigned m,unsigned n,vector<unsigned> &arry)
//使arry成为一个以m为最大值,有n项的连续自然数数组
{
    for(size_type i=0;i!=n;++i){
        arry.push_back(m-i);
    }
}

然后进行第一轮约分操作：从2至n中，观察每一个整数是否能整除分子的某个因子。能，则约去;不能，则储存起来。 
for(size_type i=n;i!=1;--i){   
    a=m/i*i;                                  //a为不大于m中i的倍数
    while(arry[m-a]%i){
        a-=i; 
        if((m-a)>(n-1)){
            arySmall.push_back(i);            //不能完全整除的,先记录下来,后面处理
            goto Break;                       //结束内层循环及结束外层循环的当前循环
        }
    
    }
    arry[m-a]/=i;
Break:
    ;
}

其中，a为不大于m中i的倍数。在这，主动寻找符合条件的因子。如在计算C(100,10)中，了解有无3的倍数时，先检验第2项，即初始值为99的项，若该值因之前的运算而不能整除3（99因能被9整除，而约成11），则检验第5（2+3）项，以此类推。若寻找不到符合条件的因子，则储存在arrySmall中。

接下来，则是用找最大公约数的方法，进行再次约分。 

unsigned gcdx;
for(size_type i=0,j=arySmall.size();i!=j;++i){
    for(size_type ix=arry.size()-1;ix!=-1;--ix){
        gcdx=gcd(arry[ix],arySmall[i]);
        arry[ix]/=gcdx;
        arySmall[i]/=gcdx;
        if(arySmall[i]==1){
            break;
        }
        
    }
}

其中，gcd为寻找两形参最大公约数的函数。

最后，对arry中的元素逐个相乘。

在这，我给出一个完整代码。其中的大数乘法也仅仅是能运行而已，毫无效率可言（知识有限，现在连类都还没有学习，算法也是一窍不通。等学习了傅立叶转换，会重新编写该部分）。

#include<iostream>
#include<vector>
#include<bitset>
using namespace std;
 
typedef vector<unsigned>::size_type size_type;
 
 
void aryMake(unsigned ,unsigned ,vector<unsigned> &);
void aryReduce(unsigned ,unsigned ,vector<unsigned> &);
void aryReduce(vector<unsigned> &,vector<unsigned> &);
void aryReduce(vector<unsigned> &);
void intCalc(vector<unsigned> &);
void tempMake(unsigned ,vector<vector<bitset<8>>> &,vector<bitset<8>> &);
inline void carry(size_type ,vector<vector<bitset<8>>> & );
inline void carry(size_type i,vector<bitset<8>> &);
void bitCalc(vector<vector<bitset<8>>> & ,vector<bitset<8>> &);
inline unsigned gcd(unsigned ,unsigned );
 
int main()
{
    vector<unsigned> arry;
    unsigned m,n;
    cout<<"Calculate C(m,n)"<<endl;
    cout<<"m=";
    cin>>m;
    cin.get();                    //刷新输入缓冲流
    cout<<"n=";
    cin>>n;
 
    if(m<0||n<0||m<n){
        cout<<"Input Error!"<<endl;
        return -1;
    }
    cout<<"C("<<m<<","<<n<<") = "<<endl;
    if(n==0||m==n){
        cout<<"1"<<endl;
        return 0;
    }
 
    n=2*n<m?n:m-n;                 // C(n,m)==C(m-n,m)
    aryMake(m,n,arry);
    aryReduce(m,n,arry);
    intCalc(arry);
 
    return 0;
 
}
 
inline unsigned gcd(unsigned m,unsigned n)
//求a,b的最大公约数
{
    while(n){
        unsigned temp = m%n;
        m=n;
        n=temp;
    }
    return m;
}
 
void aryMake(unsigned m,unsigned n,vector<unsigned> &arry)
//使arry成为一个以m为最大值,有n项的连续自然数数组
{
    for(size_type i=0;i!=n;++i){
        arry.push_back(m-i);
    }
}
 
void aryReduce(unsigned m,unsigned n,vector<unsigned> &arry)
//对arry/n!进行第一次约分操作
{
    unsigned a;
    vector<unsigned> arySmall;
 
    //寻找n!中的arry的约数,并约分
    for(size_type i=n;i!=1;--i){   //n仍为arry.size
        a=m/i*i;                                  //a为不大于m中i的倍数
        while(arry[m-a]%i){
            a-=i; 
            if((m-a)>(n-1)){
                arySmall.push_back(i);            //不能完全整除的,先记录下来,后面处理
                goto Break;                       //结束内层循环及结束外层循环的当前循环
            }
        
        }
        arry[m-a]/=i;
    Break:
        ;
    }
 
    aryReduce(arry);                             //删除值为1的元素
    
 
    if(!arySmall.empty()){                                //当n!中有未被除尽的数时,进行二次约分
        aryReduce(arySmall,arry);
    }
 
}
 
void aryReduce(vector<unsigned> &arySmall,vector<unsigned> &arry)
//对arry/n!的第一次约分结果进行二次约分
{
    unsigned gcdx;
    for(size_type i=0,j=arySmall.size();i!=j;++i){
        for(size_type ix=arry.size()-1;ix!=-1;--ix){
            gcdx=gcd(arry[ix],arySmall[i]);
            arry[ix]/=gcdx;
            arySmall[i]/=gcdx;
            if(arySmall[i]==1){
                break;
            }
            
        }
    }
    aryReduce(arry);
}
void aryReduce(vector<unsigned> &arry)
//删除arry中值为1的元素
{
    for(vector<unsigned>::iterator iter=arry.begin();iter!=arry.end();){
        if(*iter==1){
            iter=arry.erase(iter);
        }
        else{               //容易出错的地方
            ++iter;
        }
    }
}
void intCalc(vector<unsigned> &arry)
{
    vector<bitset<8>> result;            //8字节和6字节有没不同?
    vector<vector<bitset<8>>> temp;
    result.push_back(1);
    
 
    for(size_type i=0,size=arry.size();i!=size;i++){
        tempMake(arry[i],temp,result);
        bitCalc(temp,result);
        temp.clear();
    }
    
    for(int i=result.size()-1;i!=-1;i--){
        cout<<result[i].to_ulong();
    }
    cout<<endl;
    if(result.size() == 1){
        cout<<"≈"<<result[result.size()-1].to_ulong() <<"e+"<<result.size()-1<<endl;
    }
    else{
        cout<<"≈"<<(result[result.size()-1].to_ulong()*10 
            + result[result.size()-2].to_ulong() + 5) / 10 
            <<"e+"<<result.size()-1<<endl;                      //四舍五入
    }
}
void tempMake(unsigned v,vector<vector<bitset<8>>> &temp,vector<bitset<8>> &result)
//让temp存放计算的中间变量
{
    
    for(size_type i=0,j=1;v/j!=0;j*=10){
        temp.push_back(vector<bitset<8>>(0));          //向temp新建元素     
        int x=v/j%10;                                  //计算每一位数字
            
        //补0
        for(int n=0;n!=i;n++){
            temp[i].push_back(0);
        }
 
        //计算有效数字
        for(size_type k=0,size=result.size();k!=size;k++){
            temp[i].push_back ( result[k].to_ulong() * x );
        }
        temp[i].push_back(0);
        carry(i,temp);
        i++;
    }
}
inline void carry(size_type i,vector<vector<bitset<8>>> & temp)
//进位
{
    for(size_type k=0,size=temp[i].size();k!=size;k++){
        while(temp[i][k].to_ulong()>9){
            temp[i][k+1]=temp[i][k+1].to_ulong()+1;
            temp[i][k]=temp[i][k].to_ulong()-10;
        }
    }
}
 
 
 
void bitCalc(vector<vector<bitset<8>>> & temp,vector<bitset<8>> & result)
{
    vector<bitset<8>> addTemp( temp[temp.size()-1].size()+1,0);    //创建数组用于储存
    size_type sizeAdd=temp[0].size();                 //每次只加sizeAdd个,剩下的已为0
    size_type sizeTmp=temp.size();
    size_type sizeAdT=addTemp.size();
    
    //相加
    size_type i=0;
    if(sizeTmp>=sizeAdd){
        //先计算前sizeAdd列
        for(;i!=sizeAdd;i++){
            for(size_type j=0;j!=sizeAdd;j++){
                addTemp[i]=addTemp[i].to_ulong() + temp[j][i].to_ulong();
                carry(i,addTemp);
            }
        }
        //此时i=sizeAdd
        //计算除后sizeAdd列的部分
        for(;i!=sizeAdT-sizeAdd;i++){
            for(size_type j=i-sizeAdd+1,n=0;n!=sizeAdd;n++){
                addTemp[i]=addTemp[i].to_ulong() + temp[j][i].to_ulong();
                carry(i,addTemp);
                j++;
            }
        }
        //此时i=sizeAdT-sizeAdd=sizeTmp
        //计算剩下的sizeAdd列
        for(;i!=sizeAdT-1;i++){
            for(size_type j=i-sizeAdd+1;j!=sizeTmp;j++){
                    addTemp[i]=addTemp[i].to_ulong() + temp[j][i].to_ulong();
                carry(i,addTemp);
            }
        }
    }
    else{
        //先计算前sizeAdd列
        for(;i!=sizeAdd;i++){
            for(size_type j=0;j!=sizeTmp;j++){
                addTemp[i]=addTemp[i].to_ulong() + temp[j][i].to_ulong();
                carry(i,addTemp);
            }
        }
        //此时i=sizeAdd
        if(sizeTmp!=1){
            //计算剩下部分
            for(;i!=sizeAdT-1;i++){
                for(size_type j=i-sizeAdd+1;j!=sizeTmp;j++){
                    addTemp[i]=addTemp[i].to_ulong() + temp[j][i].to_ulong();
                    carry(i,addTemp);
                }
            }
        }
    }
 
    result.clear();
    //去头位0
    while(addTemp[addTemp.size()-1].none()){
        addTemp.pop_back();
    }
    result=addTemp;
}
 
 
inline void carry(size_type i,vector<bitset<8>> & addTemp)
//进位
{
    while(addTemp[i].to_ulong()>9){
        addTemp[i+1]=addTemp[i+1].to_ulong()+1;
        addTemp[i]=addTemp[i].to_ulong()-10;
    }
}
 
 
 

转载于:https://www.cnblogs.com/h46incon/archive/2011/01/30/1948098.html

weixin_30852419
关注
求组合数C（m,n）的多种计算方法
weixin_30245867的博客
07-04 5625
https://ac.nowcoder.com/discuss/187813?type=101&order=0&pos=1&page=0 https://blog.csdn.net/shadandeajian/article/details/82084087 1.简单法---适合n,m很小 #include<bits/stdc++.h> using ...
数模笔记_多变量最优化计算之随机搜索算法及建模案例
weixin_45358177的博客
02-22 2021
Data: 2_22 Name: Guo Yehao Theme: Calculation in Optimality with multiple variables Reference: 数学建模方法与分析(华章) 写在前面：看完本节讲到的随机搜索算法不禁让我类比一个有趣的事实：我写的博客只是读书笔记，记录了我在读书时的一些思考，而没有转述或者以更详细的方式介绍书中的理论和方法，所以浏览者不能指望通过浏览我的博客就学会什么具体的方法。但是如果读者亲自看书，那么我的博客会提供一些对应章节内容的有益见.
c++计算组合C(n，m)
dcjmessi的博客
03-01 4052
求出n个数中任取m个数的不同取法的个数 输入样例： 10 3 输出样例： 120 C(n，m)=n×(n-1)×…×(n-m+1)/m×(m-1)×…×1 int main() { int x, y, num1, num2, num; cin >> x >> y; num1 = x; num2 = y; for(int i=1;i&l...
组合c(m,n)的计算方法
幸福的小骁仔的博客
11-20 3891
组合c(m,n)的几种计算方法
求组合数C(m,n)的值(n＜=m)c++
最新发布
2203_75767071的博客
01-30 458
witer加油
计算组合数
清风笑
03-30 703
计算组合数 Time Limit: 1000MS Memory limit: 32768K 题目描述 计算组合数。C(n,m),表示从n个数中选择m个的组合数。 计算公式如下： 若：m=0，C(n,m)=1 否则， 若 n=1，C(n,m)=1              否则，若m=n，C(n,m)=1                          否则 C
计算机组成原理保姆级复习资料
流楚丶格念的博客
06-17 1万+
文章目录一、计算机系统概论二、数据的表示和运算各种进制及其转换各种进制的常见书写方式二进制优越性任意进制→十进制r 进制计数法举例二进制↔八进制、十六进制二进制 —> 八进制八进制—> 二进制二进制 —> 十六进制二进制 —> 十六进制十进制→任意进制除 x 取余倒排法(x 代表进制数)十进制→二进制（拼凑法）真值和机器数定点数与浮点数的举例无符号数概念表示范围有符号数有符号数的表示有符号数的定点表示定点整数定点小数注意：原码、反码、补码、移码原码反码补码移码用几种码表示定点整数各种
【LGR-(-11)】CSP 2020 第一轮（初赛）模拟 题解
bifanwen的博客
10-09 1841
博客园同步 前言 一开始查排名的时候不知道为啥翻遍了排名榜都没找到。 后来才找到了？949494 分竟然没找到，佩服佩服。 链接在这 →\rightarrow→ 2020 洛谷初赛模拟 如果乐意直接看答案的话，公布一手： ABCBA CABCB DBACD FTTTBA FFTTAA FFFTCC CDDAC CBDCB 题解 单项选择题 第 111 题，首先符号位是 111（负数），其次 124(10)=1110010(2)124_{(10)} = 1110010_{(2)}124(10)​=11100
计算机组成原理
qq_57065913的博客
04-30 655
计算机组成原理自用笔记
蓝桥杯总结与练习(一）模拟与高精度(包括日期相关算法)
huangshiyu123456的博客
02-23 1322
(一)模拟与高精度   想必大家都听说过“数学建模”这个东西，模拟其实也不难，相当于“计算机建模”，就是用计算机代码去模拟一些事件或规律，而这些规律题目已经直接过着间接得告诉你了，我们通常通过for循环和if判断就可以把事件或规律模拟出来了。   根据规律，我大致分类以下三类问题：（1）简单模拟问题 。(2)高精度计算问题。(3)日期模拟问题 (1)简单模拟问题   这类问题呢，也很简单，题目怎么 “说”，我们就怎么做，注意 “说”,可能题目不会直接告诉你规律，你可能需要观察输出来找到题目所 “说” 的规律
组合数C(n,m)的计算
雨羊的博客
07-18 5106
C(n,m)的计算方式： 1.公式：C(n,m) = n!/((n-m)! * m!)，在算法上较难实现，阶乘很快会爆long long 2.递推：C(n,m) = C(n-1,m-1) + C(n-1,m) 在算法上当然会采用第二种方式计算，而且因为C(n,m)本身值很大，所以大多数碰见它的情况会取模 #include&lt;iostream&gt; #define MOD 10000...
计算组合数C(n,m)
颤抖的羽翼
08-11 6722
计算组合数C(n,m) Time Limit: 1000ms   Memory limit: 65536K  有疑问？点这里^_^ 题目描述 C(n,m)=n!/(m! * (n-m)!).(0 输入 第一行是一个正整数t，下面t行每行有两个整数n和m。 输出 对于每一行输入，分别对应输出组合数C(n,m)的值 示例输入 3 1 1 2 1 3 2 示
练习，求组合公式值
行至水穷处，坐看云起时
03-19 822
求组合数公式为： 　　 　　编一程序，输入m和n的值，求组合数。要求分别定义求阶乘和求组合的函数，求组合数的函数调用求阶乘的函数来实现求解，在main()函数中，负责输入输出及调用求组合数的函数。 #include using namespace std; int fac(int); int main() { int m,n; float c; cout<<"计算C(m,n),输入m、n
【蓝桥杯每日一练：计算组合数】
weixin_63182150的博客
02-14 1022
问题描述 计算组合数C(m, n)的值（n <= m <= 10） 输入格式 输入包含两个非负整数，用空格分隔 输出格式 输出仅一行，一个数即C(m,n) 输入样例 4 1 输出样例 4 代码 m,n=map(int,input().split()) a=b=c=1 for i in range(m): a=a*(i+1) for j in range(m-n): b=b*(j+1) for z in range(n): c =c* (z + 1)
reduce函数的使用
weixin_50789445的博客
05-18 516
reduce 函数的使用 语法 arr.reduce(callback回调函数,[initialValue初始值]) callback （执行数组中每个值的函数，包含四个参数） 1、previousValue （上一次调用回调返回的值，或者是提供的初始值（initialValue）） 2、currentValue （数组中当前被处理的元素） 3、index （当前元素在数组中的索引） 4、array （调用 reduce 的数组） initialValue （作为第一次调用 callback 的第一个参数.
python计算组合数浮点数c(n、m)的精确度问题解决_(8条消息)python解决排列组合问题的4种方式...
weixin_31463457的博客
01-30 702
前言排列组合问题在是算法中很基础的一个问题，它们的区别就是，排列要考虑顺序，组合不考虑顺序。在面试的过程中可能会考到，在现实生活中也是经常可以遇到的，比如说一个3位数字的密码锁，要尝试多少次才能解开？那么用python有哪些方法可以解决此类问题呢？问题以一个具体的例子来说明在python中此类问题的可能解决方法，要求给定一个没有重复数字的序列，返回其所有可能的全排列。示例:输入: [1,2,3]输...
python3 reduce()函数使用
游客520
12-24 3924
描述： reduce()函数用于处理一个序列，然后把序列按照指定逻辑进行合并。 语法： reduce(function, sequence[, initial]) function：处理逻辑 sequence：待处理序列 initial：初始值，默认None 实例1： # 将列表中的每个值向乘 from functools import reduce num_l = [1, ...
Python reduce() 函数的使用简明教程
qq_34525916的博客
12-22 582
reduce 描述 reduce() 函数会对参数序列中元素进行累积。 Python3.x reduce() 已经被移到 functools 模块里，如果我们要使用，需要引入 functools 模块来调用 reduce() 函数： from functools import reduce reduce语法 reduce() 函数语法如下： reduce(function, iterable[, initializer]) function – 函数，有两个参数 iterable – 可迭代对象 i
计算组合公式C（n,m）的化简
热门推荐
fisher_jiang的专栏
05-27 2万+
排列、组合问题是大家再熟悉不过，通过公式可以轻而易举地求出C(n, m)、P(n, m)，本文将就组合问题介绍一些在时间复杂度和空间复杂度上去对程序进行优化的方法。地球人都知道C(n, m) = C(n – 1, m – 1)  + C(n – 1, m),根据这个递归性质，用C++程序递归实现如下： //1.cpp#include iostream>                 
有限元分析：钢架结构手算MATLAB与ANSYS模拟
"该资源是一份关于有限元分析的作业，涵盖了钢架结构的手工计算、MATLAB编程以及ANSYS模拟。学生需对手绘的平面钢架结构进行有限元法的离散化、单元分析、整体刚度矩阵的构建、边界条件处理、位移和反力计算，并绘制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值