阶乘算法全集,阶乘末尾非零位，阶末尾零的个数(转)

// 阶乘各算法的 C++ 类实现
#include  < iostream >
#include  < cstring >
#include  < iomanip >  
#include  < cmath >  
using   namespace  std;
 
class  Factorial {
     static   const   int  MAXN  =   5001 ;                           //  最大阶乘数，实际用不到这么大 
     int   * data[MAXN];                                             //  存放各个数的阶乘
     int   * nonzero;                                                  //  从低位数起第一个非0数字 
     int  maxn;                                                        //  存放最大已经计算好的n的阶乘 
     int  SmallFact( int  n);                                          //  n <= 12的递归程序 
     void  TransToStr( int  n,  int   * s);                            //  将数n倒序存入数组中 
     void  Multply ( int *  A,  int *  B,  int *  C,  int  totallen);    //  执行两个高精度数的乘法
public :
    Factorial();
     ~ Factorial();
     void  Calculate( int  n);                                        //  调用计算阶乘 
     int  FirstNonZero( int  n);                                     //  返回阶乘末尾第一个非0数字 
     int  CountZeros( int  n);                                      //  返回阶乘末尾有多少个0 
     int  SecondNum( int  n);                                     //  返回阶乘左边的第二个数字 
     bool  CanDivide( int  m,  int  n);                             //  判断数值 m 是否可以整除 n! 
     void  Output( int  n)  const ;
}; 
   
int  Factorial::SmallFact( int  n) {
     if  (n  ==   1   ||  n  ==   0 )  return   1 ;
     return  SmallFact(n - 1 ) * n;
}    
 
void  Factorial::TransToStr( int  n,  int   * tmp) {
     int  i  =   1 ;
     while  (n) {
        tmp[i ++ ]  =  n % 10 ;
        n  /=   10 ;
    }    
    tmp[ 0 ]  =  i - 1 ;
}   
 
void  Factorial::Multply ( int *  A,  int *  B,  int *  C,  int  totallen) 
{
     int  i, j, len;    
    memset(C,  0 , totallen * sizeof ( int ));    
     for  (i  =   1 ; i  <=  A[ 0 ]; i ++ )
     for  (j  =   1 ; j  <=  B[ 0 ]; j ++ ) {
        C[i + j - 1 ]  +=  A[i] * B[j];                                  //  当前i+j-1位对应项 + A[i] * B[j]
        C[i + j]  +=  C[i + j - 1 ] / 10 ;                                 //  它的后一位 + 它的商（进位） 
        C[i + j - 1 ]  %=   10 ;                                         //  它再取余即可 
    }
    len  =  A[ 0 ]  +  B[ 0 ];    
     while  (len  >   1   &&  C[len]  ==   0  ) len -- ;              //  获得它的实际长度 
    C[ 0 ]  =  len;   
}  
 
Factorial::Factorial() {                                        //  构造函数，先把<=12的阶乘计算好 
    maxn  =   12 ; data[ 0 ]  =   new   int  [ 2 ];
    data[ 0 ][ 0 ]  =   1 ; data[ 0 ][ 1 ]  =   1 ;
     int  i, j  =   1 ;
     for  (i  =   1 ; i  <=   12 ; i ++ ) {
        data[i]  =   new   int  [ 12 ];
        j  =  j * i;
        TransToStr(j, data[i]);
    }    
    nonzero  =   new   int  [ 10 * MAXN];
    nonzero[ 0 ]  =   1 ; nonzero[ 1 ]  =   1 ;                   //  nonzero[0]存储已经计算到的n!末尾非0数 
}
 
Factorial:: ~ Factorial() {
     for  ( int  i  =   0 ; i  <=  maxn; i ++ )
        delete [] data[i];
    delete [] nonzero; 
}    
 
void  Factorial::Calculate( int  n) {
     if  (n  >  MAXN)   return ;     
     if  (n  <=  maxn)  return ;                                //  <= maxn的，已经在计算好的数组中了 
     int  i, j, len;
     int  tmp[ 12 ];
     for  (i  =  maxn + 1 ; i  <=  n; i ++ ) {
        TransToStr(i, tmp);
        len  =  data[i - 1 ][ 0 ]  +  tmp[ 0 ]  +   1 ;
        data[i]  =   new   int  [len + 1 ];
        Multply(data[i - 1 ], tmp, data[i], len + 1 );
    }
    maxn  =  n;
}
 
int  Factorial::FirstNonZero( int  n) {
     if  (n  >=   10 * MAXN) {
        cout  <<   " Super Pig, your input is so large, cannot Calculate. Sorry! " ;
         return   - 1 ;
    }     
     if  (n  <=  nonzero[ 0 ])  return  nonzero[n];       // 已经计算好了，直接返回

     int  res[ 5 ][ 4 ]  =  {{ 0 , 0 , 0 , 0 }, { 2 , 6 , 8 , 4 }, { 4 , 2 , 6 , 8 }, { 6 , 8 , 4 , 2 }, { 8 , 4 , 2 , 6 }};
     int  i, five, t;
     for  (i  =  nonzero[ 0 ] + 1 ; i  <=  n; i ++ ) {
        t  =  i;
         while  (t % 10   ==   0 ) t  /=   10 ;                   //  先去掉 i 末尾的 0，这是不影响的 
         if  (t % 2   ==   0 ) {                                    //  t是偶数直接乘再取模10即可 
            nonzero[i]  =  (nonzero[i - 1 ] * t) % 10 ; 
        }     
         else  {                                                 //  否则转换成 res 数组来求 
            five  =   0 ;
             while  (t % 5   ==   0 ) {
                 if  (five  ==   3 ) five  =   0 ;
                 else  five ++ ;
                t  /=   5 ; 
            }     
            nonzero[i]  =  res[((nonzero[i - 1 ] * t) % 10 ) / 2 ][five];
                             //  (nonzero[i-1]*t)%10/2 正好序号为：1, 2, 3, 4 中的一个 
        }     
    } 
    nonzero[ 0 ]  =  n; 
     return  nonzero[n]; 
}  
 
/*  阶乘末尾有多少个0，实际上只与5的因子数量有关，即求 n/5+n/25+n/625+......  */
int  Factorial::CountZeros( int  n) {
     if  (n  >=   2000000000 ) {
        cout  <<   " Super Pig, your input is so large, cannot Calculate. Sorry! " ;
         return   - 1 ;
    }   
     int  cnt  =   0 ;
     while  (n) {
        n  /=   5 ;
        cnt  +=  n;
    }
     return  cnt; 
} 
 
/*   输出N!左边第二位的数字：用实数乘，超过100就除以10，最后取个位即可   */
int  Factorial::SecondNum( int  n) {
     if  (n  <=   3 )  return   0 ; 
     int  i; 
     double  x  =   6 ;
     for  (i  =   4 ; i  <=  n; i ++ ) {
        x  *=  i;
         while  (x  >=   100 ) x  /=   10 ; 
    }
     return  ( int (x)) % 10 ; 
}     
 
bool  Factorial::CanDivide( int  m,  int  n) {
     if  (m  ==   0 )  return   false ;
     if  (n  >=  m)  return   true ; 
     int  nn, i, j, nums1, nums2;
     bool  ok  =   true ; 
    j  =  ( int )sqrt( 1.0 * m);
     for  (i  =   2 ; i  <=  j; i ++ ) {
         if  (m % i  ==   0 ) {
            nums1  =   0 ;                                        //  除数m的素因子i的数量 
             while  (m % i  ==   0 ) {
                nums1 ++ ;
                m  /=  i;
            } 
            nums2  =   0 ; nn  =  n; 
             while  (nn) {                                       //  求 n 含有 i 因子的数量 
                nn  /=  i;
                nums2  +=  nn; 
            }  
             if  (nums2  <  nums1) {                         //  少于m中所含i的数量，则m肯定无法整除n! 
                ok  =   false ;
                 break ; 
            }   
            j  =  ( int )sqrt( 1.0 * m);                          //  调整新的素因子前进范围 
        }    
    } 
     if  ( ! ok  ||  m  >  n  ||  m  ==   0 )  return   false ; 
     else   return   true ; 
}      
 
void  Factorial::Output( int  n)  const  {
     if  (n  >  MAXN) {
        cout  <<   " Super Pig, your input is so large, cannot Calculate. Sorry! " ;
         return ;
    }     
     int  i, len  =   8 ;
    cout  <<  setw( 4 )  <<  n  <<   " ! =  " ;               //  格式控制输出 
     for  (i  =  data[n][ 0 ]; i  >=   1 ; i -- ) {
        cout  <<  data[n][i];
         if  ( ++ len  ==   58 ) {                                //  实际每输出50个字符就换行 
            len  =   8 ;
            cout  <<   "          " ;
        }    
    }    
     if  (len  !=   8 ) cout  <<  endl;
}    
 
int  main() {
     int  n, m, i;
    Factorial f;
     while  (cin  >>  n) {
        f.Calculate(n);
        f.Output(n);
        cout  <<   " 该阶乘末尾第一个非0数字是:  "   <<  f.FirstNonZero(n)  <<  endl; 
        cout  <<   " 该阶乘总共拥有数字0的个数： "   <<  f.CountZeros(n)  <<  endl;
        cout  <<   " 该阶乘的左边的第2位数字是： "   <<  f.SecondNum(n)  <<  endl; 
        cin  >>  m;
         if  (f.CanDivide(m, n)) cout  <<  m  <<   "  可以整除  "   <<  n  <<   " ! " ;
         else  cout  <<  m  <<   "  不能整除  "   <<  n  <<   " ! " ;  
    }
     return   0 ;    
}
 
// 第2部分第(5)个算法的单独实现
#include < stdio.h >
 
int  A[ 10 ]  =  { 1 , 1 , 2 , 6 , 24 , 120 , 720 , 5040 , 40320 , 362880 };
int  ans[ 1024 ];
int  sum;
 
void  insert( int *  a,  int  x) {                               //  插入排序，插成有序表
     int  i, j;
     for  (i  =   1 ; i  <=  a[ 0 ]; i ++ )
         if  (a[i]  >=  x)  break ;
     if  (i  <=  a[ 0 ]  &&  a[i]  ==  x)  return ;               //  如果相等，则不用插入 
     if  (i  >  a[ 0 ]) {
        a[ ++ a[ 0 ]]  =  x;
    }     
     else  {
         for  (j  =  a[ 0 ] ++ ; j  >=  i; j -- )
            ans[j + 1 ]  =  ans[j]; 
        ans[i]  =  x; 
    }     
     if  (a[ 0 ]  ==   1023 ) printf( "  Array Overflow! " ); 
} 
    
void  search( int  n){
     for  ( int  i  =  n; i  <=   9 ; i ++ ){
        sum  +=  A[i];  if  (sum  >   1 ) insert(ans, sum); 
         if  (i  <   9 ) search(i + 1 );
        sum  -=  A[i]; 
    }     
}  
 
int  main(){
     int  n,i;
    ans[ 0 ]  =   1 ; ans[ 1 ]  =   1 ;                                      // 初始化ans数组，ans[0]表示表长
    search( 0 ); 
     // printf("len = %d ", ans[0]); 
     while ( 1 ){
        scanf( " %d " , & n);
         if (n  <   0 ) break ;
         if (n  >   409114 ){ printf( " NO " ); continue ;}
        
         for  (i  =   1 ; i  <=  ans[ 0 ]; i ++ )
             if  (ans[i]  ==  n) {printf( " YES " );  break ;}
             else   if  (ans[i]  >  n) {printf( " NO " );  break ;} 
    }  
     return   0 ;   
}
//
 阶乘相关算法及程序
  有关阶乘的算法，不外乎两个方面：一是高精度计算；二是与数论相关。
一. 高精度计算阶乘

    这实际上是最没有技术含量的问题，但是又会经常用到，所以还是得编写，优化它的计算。

    首先看小于等于12的阶乘计算(计算结果不会超出32位范围):

         int  factorial( int  n) {

            if  (n  ==   1   ||  n  ==   0 )  return   1 ;

            return  factorial(n - 1 ) * n;

       }

    这个递归程序简单明了，非常直观，然而一旦n  >   12 ，则超过32位int型的范围出现错误结果，所以上面这个递归程序仅适合n  <=  12的阶乘计算，为了计算较大n的阶乘，需要将高精度乘法算法纳入到阶乘计算中来，高精度乘法过程可以如下简单的描述：（其中A  *  B  =  C，A[ 0 ], B[ 0 ], C[ 0 ]分别存储长度）

     for  (i  =   1 ; i  <=  A[ 0 ]; i ++ )

     for  (j  =   1 ; j  <=  B[ 0 ]; j ++ ) {

        C[i + j - 1 ]  +=  A[i] * B[j];           //  当前i+j-1位对应项 + A[i] * B[j]

        C[i + j]  +=  C[i + j - 1 ] / 10 ;          //  它的后一位 + 它的商（进位） 

        C[i + j - 1 ]  %=   10 ;                   //  它再取余即可 

    }

    C[ 0 ]  =  A[ 0 ]  +  B[ 0 ];

     while  (C[ 0 ]  >   1   &&  C[C[ 0 ]]  ==   0 ) C[ 0 ] -- ;    //  去头0，获得实际C的长度

有了这个高精度乘法之后，计算阶乘就可以简单的迭代进行：
     for  (i  =   2 ; i  <=  n; i ++ ) {

          将i转换成字符数组;

          执行高精度乘法：将上一次结果乘上i

    }

二. 与数论有关

    由于阶乘到后面越来越大，巧妙的利用数论求得一些有趣的数字（数值）等成为阶乘算法的设计点，下面给出几道相关的问题与分析：

( 1 )   计算阶乘末尾第一个非0数字：

这是一个比较经典的问题，比较复杂的算法是利用一个艰难的数学公式，可惜我不会，从网上的资料学习中，整理出下面这个简单易懂的算法：

观察n ! ，可以发现在乘的过程中，对于任意 n  >   1 ，n ! 的末尾第一个非0数字都是偶数。我们只需保留最后一位非零数。当要乘的数中含有因数5时，我们可以把所有的因数5都当作8来乘。这是因为:

...x2 * 5 = ... 10 （舍）或... 60 ，最后一位非零数为6。而恰好2 * 8 = 16 ，末位为6。

...x4 * 5 = ... 70 （舍）或... 20 ，最后一位非零数为2。而恰好4 * 8 = 32 ，末位为2。

...x6 * 5 = ... 30 （舍）或... 80 ，最后一位非零数为8。而恰好6 * 8 = 48 ，末位为8。

...x8 * 5 = ... 90 （舍）或... 40 ，最后一位非零数为4。而恰好8 * 8 = 64 ，末位为4。

(对于n  >  1时，最后一位不会出现  1 ,  7 ,  3 ,  9 ，而永远是2,  4 ,  6 , 8的循环出现)

    因此，在迭代作乘法时，主要就是计算因子5的数量，同时可见因子5的个数以4为循环节（即只需要取它的数量对4取模）。那么对于不同情况下的因子5的数量，可以通过res[ 5 ][ 4 ]  =  {{ 0 , 0 , 0 , 0 }, { 2 , 6 , 8 , 4 }, { 4 , 2 , 6 , 8 }, { 6 , 8 , 4 , 2 }, { 8 , 4 , 2 , 6 }}来得到，使用nonzero[i]表示i的阶乘的最后一位，那么：

    如果t是偶数，则直接乘：nonzero[i]  =  (nonzero[i - 1 ] * t) % 10 。

    否则nonzero[i]  =  res[((nonzero[i - 1 ] * t) % 10 ) / 2 ][five]; 

其中t是除掉所有因子5的结果，five为因子5数量对4的模。相关题目：

http: // acm.zju.edu.cn的第1222题。不过这一道题注意的是，它的输入n并非只在32位int数值范围内，而是有很大的长度，所以计算这道变态题目时，需要利用到高精度除法(n/=5)和高精度加法(cnt+=n)。

( 2 ). 阶乘末尾有多少个0

    分析发现，实际上形成末尾0，就是因子5的数量，而计算1 ~ n之间包含一个因子i的个数的简单算法就是：

cnt  =   0 ;  while  (n) { n  /=  i; cnt  +=  n; }

因此，直接将i换成5，就可以得到因子5的数量，也即n ! 末尾0的数量。相关题目：http: // acm.zju.edu.cn的第2022题。

( 3 ). 返回阶乘左边的第二个数字

    简单算法：用实数乘，超过100就除以10，最后取个位即可。因为整数部分的个位就是阶乘结果左边的第二个数字。相关题目：

http: // acm.tongji.edu.cn的1016题。

( 4 ). 判断数值 m 是否可以整除 n !

算法：使用素因子判断法

A. 首先直接输出两种特殊情况：

m  ==   0  则0肯定不会整除n ! ；

n  >=  m 则m肯定可以整除n ! ;

B. 那么就只剩最后一种情况：m  >  n，我们从m的最小素因子取起，设素因子为i那么可以求得m的素因子i的个数 nums1；再检查闭区间 i  ~  n 之间的数，一共包含多少个素因子i，就可以简单的利用上面( 2 )中所介绍的数学公式进行计算得到nums2。如果nums2  <  nums1，就表示1  ~  n中包含素因子的数量  <  除数m包含素因子i的数量，那么m必然不能整除n ! ，置ok  =   false 。

C. 最后：如果  ! ok or m  >  n or m  ==   0  则不能整除；否则可以整除

相关题目：http: // acm.zju.edu.cn的第1850题。

( 5 ).数字N能否表示成若干个不相同的阶乘的和：

    这里可以选择的阶乘为： 0 !   ~   9 ! ，实际上这一题与数论无关，与搜索有关。相关题目：http: // acm.zju.edu.cn 的2358题。

    分析，由于可供选择的阶乘数量较少，直接可以利用DFS搜索来做：

A. 首先将0  ~  9的阶乘作一个表A[ 10 ]；再设置一个可以组成“和”的数组ans[N]。

B.  深度优先搜索方法：

     search(n) {

          for (i  =  n; i  <=   9 ; i ++ ) {

             sum  +=  A[i];         // 求和

             如果sum在ans数组中不存在，则将sum插入到ans[]数组中

             search(n + 1 );

             sum  -=  A[i];          // 回溯

         }

}

C. 最后对于输入n，就在ans数组中查找是否存在n，如果存在，则表示n可以表示成不同的阶乘和，否则不行。