用一道有趣的小题谈谈性能优化--求阶乘和的末6位

此题来源：算法竞赛入门经典(第2版) P21

/** 
 * 输入n, 计算 S = 1! + 2! + ... n! 的末六位（不含前导0）。
 * n < 10^6
 * n! 表示阶乘， 是前n个正整数之积
 * 样例输入：10
 * 样例输出：37913
 **/ 

乍一看，这道题目并不难，无非是一个循环求和，里面套一个求阶乘。
给出最基础版本的示例代码如下：

f1 基础版本

/** with bug 
 * @param int $n
 * @return int
 */
 
function f1 (int $n):int
{
    for($fnum = 1,$sum = 0;$fnum<=$n;$fnum++){
        for($multi_num = 1,$fa_res = 1;$multi_num<=$fnum;$multi_num++){
            $fa_res *= $multi_num;// 计算 fnum!
        }

        $sum += $fa_res; // 求和 重复到n
    }
    return $sum%1000000;
}

这个代码看似并没有什么问题，逻辑上也没看到什么异常。那么我们来运行一下试试！

为了方便进行后续的优化对比，我们再外部的主程序里调用这个函数，测试一下当n从 10到10000的运行结果，每次n的规模扩大两倍 ，并且输出它的运行时间。调用的函数如下：

//time
for($num = 10;$num<10000;$num*=2) {
    echo PHP_EOL."num: $num:".PHP_EOL;

    $start_time = microtime(true);
    echo f1($num);
    $end_time = microtime(true);

    $time = 1000 * ($end_time - $start_time);
    echo PHP_EOL . "time:$time ms" . PHP_EOL;


}

运行的结果却发现，n=40 的时候的出来的结果居然变成0了！！

f1的debug过程

我们把内部 f1 的函数里面，输出求和结果$sum，把再细调一下外部的调用程序，把for循环的 num 步长调成 $num++ ，从10到40运行一下试试。

//time
for($num = 10;$num<40;$num++) { .... }

运行的结果如下：

当num=21的时候, 居然输出了一个负数。原因是什么呢？ 可以看到sum出来的值已经不再是直接一个整数输出了，而是用了 E形式 的浮点数表示法。这是因为sum值已经很大，超出了int表示范围，php是弱类型语言，因此将其自动转为了其他的数据类型。

为了更好的看清楚具体的数据变化，我们可以增加一些内容来看清楚他的变化过程

function f1 (int $n):int
{
    for($fnum = 1,$sum = 0;$fnum<=$n;$fnum++){
        for($multi_num = 1,$fa_res = 1;$multi_num<=$fnum;$multi_num++){
            $fa_res *= $multi_num;// 计算 fnum!
        }

        $sum += $fa_res; // 求和 重复到n
    }
    
    //输出sum值以及类型
    echo 'sum-type:'.gettype($sum).PHP_EOL;
	echo 'sum:'.$sum.PHP_EOL;
	
	//输出data值以及类型
    $data = $sum%1000000;
	echo 'data-type:'.gettype($data).PHP_EOL;
	echo 'data:'.$data.PHP_EOL;
	return  $data;
}

执行结果如下：

当num=21的时候，求出来的sum值已经很大了，于是执行这一条语句
$sum%1000000 的时候，实际上是一个 double值 % int值，在这个取余%的运算过程中，double 被强转成存储更小的 int 型，导致溢出数据的异常运算，得到一个错误的 int 结果。

那么我们应该如何解决这个bug呢 ？

显然，问题出在 int值 % int值 这个运算流程上。简单来说无非两种解决思路。

0. 修改流程，使其运算的值不溢出，能以 int 值正常运算
1. 修改 % 运算，用别的方法获取末六位的值（比如字符处理）

不溢出的修改 — f2()

首先试下第一种解决思路，让数字不要那么大。

我们的目的是计算 S = 1! + 2! + … n! 的末六位，那么其实我们只关心末六位的变化。而这末六位的变化，其实都是一个个阶乘结果的和，那也就是说，我们只关心阶乘结果的末六位。

因此，在每次求出 n! 的结果的时候，就可以进行一次取余运算，获取其末六位，再做相加的操作。

/** 提前取mod
 * @param int $n
 * @return int
 */
 
define('MOD',1000000);

function f2 (int $n):int
{
    for($fnum = 1,$sum = 0;$fnum<=$n;$fnum++) {
        for ($multi_num = 1, $fa_res = 1; $multi_num <= $fnum; $multi_num++) {
            $fa_res = ($fa_res * $multi_num)%MOD ;// 计算 fnum!
        }
        $sum = ($sum + $fa_res) % MOD; // 求和 重复到n 这里提前取mod
//        echo $fnum . '! mod = ' . $fa_res . PHP_EOL;
//        echo 'sum-mod:'.$sum . PHP_EOL;
    }
    return $sum;
}

运行结果如下：

第二种解决思路，修改 % 运算，用别的方法来实现，这种方法也是可以的。但是要做到效率不输于 % 才是一种好的方法。此处先暂放，后续想到好方法再继续补上~

我们还发现，这个运行结果里，当 num 为 24，25，26的时候，输出的结果是一样的, 都是940313 ，那么会不会存在着什么规律呢?

我们来用计算器算一下 25！, 结果发现是下面这个数

也就是说，计算S的过程中，当计算到 25! 以及之后更大的数，末六位都是0的，不会有更多的项用于求和，所以之后的num都是可以不用算的！直接输出结果就可以。因此，我们可以改进成如下的代码。

大数改进版本 — f3()

/** 改进大数情况
 * @param int $n
 * @return int
 */

define('MOD',1000000);

function f3 (int $n):int
{
    if($n>24) $n = 24;//发现的规律 大数不处理
    
    for($fnum = 1,$sum = 0;$fnum<=$n;$fnum++) {
        for ($multi_num = 1, $fa_res = 1; $multi_num <= $fnum; $multi_num++) {
            $fa_res = ($fa_res * $multi_num) % MOD;// 计算 fnum!
        }

        $sum = ($sum + $fa_res) % MOD; // 求和 重复到n
    }
    return $sum;
}

再来继续审题，我们要计算 S = 1! + 2! + … n! 的末六位，无非是三个操作，求阶乘，求和，求末六位。求和和末六位已经做了相关的优化了，那么求阶乘是不是也能做一些优化呢？

我们目前的求阶乘计算方法是，用一个for循环，每次从1开始乘，实现 n! = 1*2*3*... *n 的计算，但是这里面是有重复的部分的。

既然第一次已经计算出了 1! 的值，那么第二次算 2! 的时候，其实是可以把前面的运算结果用上的。我们在再把数字放大一些，这个性能优势就会非常明显了。

假设我已经求15！，前面已经算出了 1! 的值，后面下一个相加的项，就是这个结果值*2 即可，得到2!。 同理3! , 就是 2! * 3。这样逐步运算下去，就把之前的for循环累乘的过程，变成了每次只进行一次乘法运算即可，因此就可以更快完成运算。

当然，时间性能提升与之对应的就是空间占用的开销，需要用一个额外的数组来保存中间的临时结果。当然，后面也会有除了数组保存之外的方法。

用数组保存中间结果避免循环 — f4()

具体代码如下：

/** 改进大数 保存中途结果减少循环
 * @param int $n
 * @return int
 */
function f4 (int $n):int
{
    if($n>25) $n =25;//发现的规律
    
    $fa_res = [];
    $fa_res[] = 1;

    for($fnum = 1,$sum = 0;$fnum<=$n;$fnum++) {
        if (empty($fa_res[$fnum])){
            $fa_res[$fnum] = ($fnum * $fa_res[$fnum-1])%MOD; // 利用上一次的保存结果
        }
        $sum = ($sum + $fa_res[$fnum]) % MOD; // 求和 重复到n
    }
   return $sum;
}

再来回头看我们的f4() 函数，我们用了一个数组来保存求和结果，但是实际上，我们每次只是用了上一次的结果，我只需要1个内容而已，因此这里完全可以用1个变量来保存，之前已经用过的临时值就可以扔掉了。

另外也再看看提前取mod操作，做这个操作，是为了避免值太大超出int的范围，那么其实只需要在它快要超出int值，快要爆掉的时候取一下就可以了。不需要每次都去做这个运算。

我们之前测试的时候已经知道，当n=20还是能正常运算的，当n=21才会出现double的情况，因此我们只需要对这几个大数的情况处理就可以了。如果到达了大数临界的情况，并且sum是超过6位了，才有必要进行取余获取其末六位

因此我们还可以在进一步优化，得到下面这个版本。

用变量保存中间结果 + 取mod优化 — f5()

/** 用变量保存中间结果 + 取mod优化
 * @param int $n
 * @return int
 */
function f5(int $n): int
{
    if ($n > 24) $n = 24;//发现的规律
    $fa_res = 1;
    for ($fnum = 1, $sum = 0; $fnum <= $n; $fnum++) {
        if ($n > 20 && $sum > 999999) { //如果大数临界 并且sum是超过6位了 才有必要进行取余
            $fa_res = ($fnum * $fa_res)%MOD;
            $sum = ($sum + $fa_res)%MOD;
        } else {
            $fa_res = $fnum * $fa_res; // 利用上一次的保存结果
            $sum = $sum + $fa_res; // 求和 重复到n
        }
    }
    return $sum > 999999 ? $sum%MOD : $sum;
}

不过呢，其实做到这个地步，已经开始有一些投机取巧的味道在里面了，实际上这里的运算求末六位运算结果，只可能有24种情况，也就是对应 n=1 到 n=24。如果还要进一步追求性能，这种情况数目比较小的东西，完全可以写死。

也就是说，先做一个简单的程序，把这24种情况全部求出来，然后把结果写死，实际求值就直接读取数据即可。

运行结果也就无非是上面的情况，于是直接定义一个常量保存起来。（PHP7支持数组常量，如果是PHP5可以把数组用json_encode() 转成字符串存起来）

/** 直接读取结果
 * @param int $n
 * @return int
 */
define('RES', [1, 3, 9, 33, 153, 873, 5913, 46299, 409113, 37913, 954713, 956313, 977113,
    268313, 636313, 524313, 620313, 348313, 180313, 820313, 260313, 940313, 580313, 940313]);

function f6(int $n): int
{
     if ($n > 24) $n = 24;
     return RES[$n-1];
}

综合测试

那么我们直接取 num = 1000000 进行一次测试，看下不同的版本性能速度会差多少。PHP默认是单线程的，因此用i5-8250U 运行至多只会吃满1个核，占25%的CPU。

然后结果是f2 运行时间太长了…

我们再来换个测试，取 num 从1到10000，看下不同的版本性能速度会差多少。

//测试调用
for ($num = 1; $num <= 10000; $num *= 10) {
    echo PHP_EOL . "num: $num:" . PHP_EOL;  
    for ($fname = 2; $fname <= 6; $fname++) {
        $func_str = 'f' . $fname;
        $start_time = microtime(true);
        $func_str($num);
        $end_time = microtime(true);
        $time = 1000 * ($end_time - $start_time);
        echo "$func_str -- time:$time ms" . PHP_EOL;
    }
}

f2 函数是提前取mod,
f3 函数是改进了大数情况，
f4 函数是改进大数+数组保存中途结果，
f5 函数是改进大数+变量保存中途结果+改进取MOD ，
f6 函数是直接取结果。
分别得到执行时间如下。

当n特别小的时候，比如 n=1 ,这时候发现其实优化过的算法反而更慢。原因是因为本来的运算量就非常小，我们去操作数组，以及操作数据，执行判断，这些操作所需的时间，是比普通运算慢得多的。特别是CPU要去调用内存数据的时候，这里的IO开销是非常大的（查缓存，调内存，更新缓存）。

因此在考虑性能的时候，要尽量减少不必要的递归，以及大量的值传递。每次开辟对应的内存空间，寻址调用，回收内存空间都是一笔性能开销。当然，php自己本身会去做这些事情，php7也有了较好的性能提升，但在程序设计的角度，这些性能优化都应该是编程的潜意识。

另外，编程语言以及环境平台本身也是一个瓶颈之处。上面同样的测试代码，同样的系统配置，在linux下运行结果如下：

可以看到，ubuntu 里的 php 比 win10是要更快接近1.5到2倍的，而 php 本身呢，底层都是C语言实现的，所以要是用C语言写一下我们 f5() 函数的话。

C语言版本的f5

代码如下：

#include <stdio.h>
#include <sys/time.h>
#define MOD 1000000

int f5(int);

int main() {
	struct timeval tv1;
	struct timeval tv2;
	int t=10000;
	gettimeofday(&tv1,NULL);
	while(t--) {
		f5(10000);
	}
	gettimeofday(&tv2,NULL);
	printf("1 start, now, sec=%ld m_sec=%d \n", tv1.tv_sec, tv1.tv_usec);
	printf("2 start, now, sec=%ld m_sec=%d \n", tv2.tv_sec, tv2.tv_usec);

	return 0;
}

int f5(int n) {
	int fa_res,fnum,sum;
	if (n > 24) n = 24;//发现的规律
	fa_res = 1;
	for (fnum = 1, sum = 0; fnum <= n; fnum++) {
		if (n > 20 && sum > 999999) { //如果大数临界 并且sum是超过6位了 才有必要进行取余
			fa_res = (fnum * fa_res)%MOD;
			sum = (sum + fa_res)%MOD;
		} else {
			fa_res = fnum * fa_res; // 利用上一次的保存结果
			sum = sum + fa_res; // 求和 重复到n
		}
	}
	return sum > 999999 ? sum%MOD : sum;
}

因为在C语言下，这个函数运行的实在是太快，我们使用一个循环，来统计执行10000次的时间，用来估算每次执行的时间。

在 win10平台 和 ubuntu平台 下，运行结果如下：

1微秒 = 0.001毫秒，换个C语言直接完爆PHP。

最后我们拿个表格汇总一下

num = 10000 的测试结果表

后话

其实，这种基本的简单操作并不需要花这么多心思去做性能优化，目前的计算设备性能也越来越好，程序中需要性能的核心部分（比如游戏引擎），一般都是用优化的算法，搭配合适的硬件，用C++或者Go语言编写的。有时候为了追求性能甚至可以牺牲可读性和维护性。

做这个小题的性能优化，只是希望用一个小的引子，告诉大家做程序开发不仅仅只是实现功能就完事了。稍微多花一点点心思去多想多做，就会收获很不一样的性能结果，而这些优化和提升，正是软件工程师的价值所在。