为什么低效的阶乘计算…高效(快速）

Why inefficient factorial computation is...efficient (and fast)?

本文关键字：高效 快速 计算 阶乘 为什么      更新时间：2023-10-16

我写了这个简单的程序来测试记忆技术：

int main() {
    function<double(double)> f = [&f](double i) -> double {
        if (i == 1)
            return 1;
        else
            return i * f(i - 1);
    };
    cout << f(100) << endl;
}

我本来希望在几秒钟内执行这段代码（因为它的递归效率很低），但实际上只花了几毫秒…为什么？我认为有一些编译器优化，但我不知道会发生什么。

奖金问题：你能给我一个简单的程序吗？它的执行效率很低（编译器优化与否），所以我可以测试记忆的好处？

记忆化技术旨在优化昂贵的函数调用。阶乘函数并非如此。C++速度极快，因此阶乘函数调用的计算时间永远不会超过几毫秒。（至少如果不使用多精度）。factorial（100）是"仅"100次乘法运算，因此对于C++没有任何运算。

如果这只是为了测试或演示的目的，我会简单地在函数调用中引入一个延迟（睡眠、长伪循环或其他什么）。随着记忆的实现，这种延迟不应该发生，所以它"几乎"很快就会运行。

这是我要做的一个例子。factory是一个昂贵的函数memory_factoral是它与所实现的存储技术的结合。在对函数的第一次调用中，输入和输出的字典会被更新，在接下来的具有相同输入的调用中，先前存储的值会被返回，因此"真实"函数不会再次执行。

#define ELAPSE(cmd) { clock_t s = clock();
    long ret = cmd;
    cout << "t" << #cmd
         << " = " << ret 
         << "t(" << (clock()-s)/double(CLOCKS_PER_SEC) << " secs)" 
         << endl; }
long factorial(long i) {
    for(clock_t s = clock(); (clock()-s)<CLOCKS_PER_SEC; );
    return i<=1 ? 1 : i*factorial(i-1);
}
long memo_factorial(long i) {
    static map<long,long> saved;
    map<long,long>::const_iterator it = saved.find(i);
    return ( it==saved.end() ) ? (saved[i] = memo_factorial(i)) : it->second;
}
int main() {
    cout << "first execution WITHOUT memoization" << endl;
    for(int i=1; i<5; ++i) {
        ELAPSE( memo_factorial(i) )
    }
    cout << "second execution WITH memoization" << endl;
    for(int i=1; i<5; ++i) {
        ELAPSE( memo_factorial(i) )
    }
    return 0;
}

输出应为：

first execution WITHOUT memoization
    memo_factorial(i) = 1   (1 secs)
    memo_factorial(i) = 2   (1 secs)
    memo_factorial(i) = 6   (1 secs)
    memo_factorial(i) = 24  (1 secs)
second execution WITH memoization
    memo_factorial(i) = 1   (0 secs)
    memo_factorial(i) = 2   (0 secs)
    memo_factorial(i) = 6   (0 secs)
    memo_factorial(i) = 24  (0 secs)

希望你觉得它有用。

谨致问候，Alex

注意：阶乘通常定义在整数值上。当然，它只是一个乘法序列，因此它可以应用于其他类型。

记忆化主要是一种提高计算算法复杂性的技术，而不是避免递归。这就是为什么斐波那契数是一个比阶乘函数更好的例子（尽管WikiPedia页面使用了阶乘函数）。

看看维基上关于动态编程的数字。第二张图中划掉的所有通话都是你从备忘录中节省的费用。有了阶乘函数，什么都不会被划掉。

相关文章：