给定一个参数N，返回：1! + 2! + 3! + 4! +...+ N!的结果

题目：给定一个参数N，返回：1! + 2! + 3! + 4! +…+ N!的结果

话不多说我们直接上代码

package com.lbmb.chapter01_bitOperation;

/**
 * @author 林文塨
 * @date 2022-07-02 23:33
 * description 给定一个参数N，返回：1! + 2! + 3! + 4! +...+ N!的结果
 */
public class Code02 {

    public static long factorial01(int n) {
        /*
         * 暴力解决，用两个循环
         * 外层循环N次
         * 内层循环1~N的阶层
         * @author 林文塨
         * @date 2022/7/2 23:35
         * @param []
         * @return long
         */
        long result = 0;
        for (int i = 1; i <= n; i++) {
            long temp = 1;
            for (int j = 1; j <= i; j++) {
                temp *= j;
            }
            result += temp;
        }
        return result;
    }

    public static long factorial02(int n) {
        /*
         * 用一个变量记住上一次计算的值，不用每次都重复计算已计算过的值
         * @author 林文塨
         * @date 2022/7/2 23:42
         * @param [n]
         * @return long
         */
        long result = 0;
        long temp = 1;
        for (int i = 1; i <= n; i++) {
            temp *= i;
            result += temp;
        }
        return result;
    }

    public static void main(String[] args) {
        int n = 5;
        System.out.println(factorial01(5));
        System.out.println(factorial02(5));
    }
}

解决方法一：
暴力穷举，分两步走，用两个循环，求1! + 2! + 3! + 4! +…+ N!的结果，外层循环N次，内层则循环每个阶乘1！，2！，3！，4！，…，N！

//外层循环，这里选择从i=1 ~ i<=n而不是i=0 ~ i<n，是为了后面阶乘从1开始而不是从0开始
for (int i = 1; i <= n; i++) {

}

//内层循环，每次循环完临时变量的值都为1 * 2 * 3 * ... * i，这里的i是上边外层循环的变量
long temp = 1;
for (int j = 1; j <= i; j++) {
    temp *= j;
}

实质上就是直接算：

1! = 1
2! = 1*2
3! = 1*2*3
...
N! = 1*2*3*4...*N

最后全部相加 1! + 2! + 3! + 4! +…+ N!

解决方法二：
从方法一中我们可以发现，在计算

1! = 1
2! = 1*2
3! = 1*2*3
...
N! = 1*2*3*4...*N

的时候，我们重复计算了许多值，我们在算 2! 的时候算了1×2，在算3!的时候又算了1×2，然后再×3。由此可以得出结论，如果我们每次计算阶乘的时候，都用一个变量记住，再次直接从前面的基础上乘上新的值，就能大大减少计算量

long result = 0;
long temp = 1;
//循环n次，也是一样i=1 ~ i<=n
for (int i = 1; i <= n; i++) {
	//计算每个阶乘，不再初始化成1
    temp *= i;
    //将每个阶乘结果累加
    result += temp;
}