P1009 [NOIP1998 普及组] 阶乘之和

题目描述

用高精度计算出 S=1!+2!+3!+⋯+n!(n≤50)。

其中 ! 表示阶乘,定义为 n!=n×(n−1)×(n−2)×⋯×1。例如,5!=5×4×3×2×1=120。

输入格式

一个正整数 n。

输出格式

一个正整数 S,表示计算结果。

输入输出样例

输入 #1

3

输出 #1

9

说明/提示

【数据范围】

对于 100% 的数据,1≤n≤50。

【其他说明】

注,《深入浅出基础篇》中使用本题作为例题,但是其数据范围只有 n≤20,使用书中的代码无法通过本题。

如果希望通过本题,请继续学习第八章高精度的知识。

NOIP1998 普及组 第二题

题目难度

普及-

参考思路

首先我们发现,求的是1到n所有阶乘的和,而阶乘又有递归写法(n!=(!n*n))

那么直接用递推一直推到!n,然后再把所有的都相加就可以了(当然是倒序存储)

关于进位:单个数组位置只存一个(其实可以多个)数位,乘了之后做操作的时候只需要判断当前位置是否是该行最后一位,如果是就++,那么它会一直循环到刚好合适为止。

参考代码

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int i,A[1005]={0},B[1005]={0},n,j;
    cin>>n;
    A[0]=B[0]=1;
    for (i=2;i<=n;i++){
        for (j=0;j<100;j++)
            B[j]*=i;
        for (j=0;j<100;j++)
            if (B[j]>9){
                B[j+1] += B[j]/10;
                B[j]%=10;
            }
        for (j=0;j<100;j++){
            A[j]+=B[j];
            if (A[j]>9) {
                A[j+1] += A[j]/10;
                A[j]%=10;
            }
        }
    }
    for (i=100;i>=0&&A[i]==0;i--);
    for (j=i;j>=0;j--) cout<<A[j];
    return 0;
}

<think>好的,我现在需要解决用户关于如何用C++实现P1009 NOIP 1998普及组阶乘之和问题。首先,我得仔细理解题目要求。题目是计算S=1!+2!+3!+…+n!,其中n的范围可能很大,导致结果超出普通整数类型的范围,所以必须使用高精度计算。 根据用户提供的引用,特别是引用[2]引用[5],提到n的数据范围较大,普通的unsigned long long都不够,所以必须用高精度。而且引用[5]还提到,原书中的方法只能处理n≤20的情况,而实际题目可能需要更大的处理能力。这说明直接使用普通数据类型是不行的,必须模拟手工计算的大数处理方式。 接下来,我需要回忆高精度计算的实现方法。通常,高精度计算会用数组来存储每一位数字。比如,每个数组元素代表一位数字,然后进行逐位的乘法加法,同时处理进位。例如,计算阶乘时,每个阶乘i!可以通过前一个阶乘(i-1)!乘以i得到,这涉及到高精度乘法。然后将每个阶乘的结果累加到总中,这又涉及到高精度加法。 现在,如何具体实现呢?根据引用[1]中的代码片段,他们使用了两个数组sumlast_sum,分别存储当前的阶乘。sum数组初始化为1,因为1! =1,然后逐步乘以i得到后面的阶乘。每次计算完i!后,将其加到last_sum中,也就是总S中。 不过引用[1]中的代码似乎是伪代码或存在错误,比如变量名可能不一致,循环变量的使用也可能有问题。例如,第一个循环里用了n作为乘数,但实际应该是循环变量i从1到n。这说明需要更仔细地设计循环结构。 正确的步骤应该是这样的:首先初始化总数组为0,然后对于每个i从1到n,计算i的阶乘,然后将这个阶乘加到总中。计算阶乘时,初始为1! =1,然后每次乘以i得到下一个阶乘,直到i=n。 例如,当i=1时,阶乘是1,总变为1。i=2时,阶乘是2,总变成1+2=3。i=3时,阶乘是6,总是3+6=9,依此类推。每次阶乘都是前一个阶乘乘以当前的i,而每次加法需要将阶乘的每一位加到总的对应位上,并处理进位。 需要注意的是,高精度乘法加法的实现细节。例如,在乘法时,每个数字位乘以当前的i,然后处理进位到高位。而在加法时,每个位相加,同样处理进位。数组通常是从低位到高位存储,比如数组的第0位是个位,第1位是十位,以此类推。 另外,关于数组的大小,引用中提到使用2000位的数组,因为n的值虽然输入可能不大,但阶乘增长非常快,比如20!已经是19位,50!就有65位,所以需要足够大的数组来容纳结果。比如,题目中n可能到某个较大的值,导致阶乘之和的位数较多,所以设定一个足够大的数组长度是必要的,比如2000位。 现在,具体到代码结构。首先,需要初始化两个数组:一个用于存储当前的阶乘(比如factorial),初始为1;另一个用于存储总(sum_result),初始为0。然后循环从1到n,每次将当前阶乘乘以i,然后将阶乘加到总里。 例如,初始化factorial数组为1,sum_result为0。当i=1时,factorial是1,加到sum_result中,sum_result变为1。然后i=2时,factorial乘以2变为2,加到sum_result中,得到3。i=3时,factorial乘以3得到6,sum_result变为9,依此类推。 在乘法过程中,每一位都要乘以i,然后处理进位。例如,当前factorial数组中的每一位数字乘以i,加上进位,然后取模10得到当前位的值,进位则是除以10的结果。这个过程需要遍历整个数组,直到所有位数处理完毕,包括可能的最高位进位。 同样地,加法过程需要将factorial的每一位加到sum_result的对应位上,同样处理进位。进位可能来自当前位的超过10的情况,需要将多余的进位加到高位。 此外,输出结果时需要从最高位开始找到第一个非零数字,然后逆序输出,因为数组存储的是低位在前,高位在后。例如,数组第0位是个位,第1位是十位,所以输出时应该从最高非零位开始,倒序输出每一位数字。 现在,结合引用中的例子,比如引用[1]中的代码,虽然可能有错误,但可以借鉴其结构。例如,初始化sum数组为1(可能代表阶乘的初始值),然后循环处理。但可能需要调整变量名循环逻辑。 另外,要注意代码中的循环变量是否正确,比如在引用[1]中,第一个循环可能是在计算当前阶乘乘以i,但变量名可能写成了n,这可能是错误,应改为循环变量i。因此,代码需要调整。 总结实现步骤: 1. 初始化阶乘数组factorial为1,总数组sum_result为0。 2. 对于i从1到n: a. 计算当前阶乘factorial = factorial * i(高精度乘法) b. 将factorial加到sum_result中(高精度加法) 3. 输出sum_result的值,注意去除前导零并按正确顺序输出。 现在,如何具体编写高精度乘法加法的函数? 对于高精度乘法,假设当前阶乘存储在数组factorial中,乘以i: - 遍历factorial的每一位,乘以i,并处理进位。 - 例如,初始进位carry为0。对于每一位j: temp = factorial[j] * i + carry factorial[j] = temp % 10 carry = temp / 10 - 处理完所有位后,如果carry不为0,需要将carry添加到更高位,直到carry为0。例如,若factorial数组长度为2000,可能需要循环直到j < 2000且carry不为零。 对于高精度加法,将factorial数组加到sum_result数组: - 遍历每一位,sum_result[j] += factorial[j] - 处理进位: carry = sum_result[j] / 10 sum_result[j] %= 10 sum_result[j+1] += carry 这样,每一位都处理进位。 在代码中,需要注意数组的初始化。例如,factorial数组初始时只有factorial[0] =1,其余为0。sum_result数组初始全为0。 此外,在处理阶乘时,每次i的循环,factorial数组需要乘以i,然后将结果加到sum_result中。例如,对于i=1到n: 当i=1时,factorial为1,sum_result加1,变为1。 i=2时,factorial乘以2变为2,sum_result加2,变为3。 i=3时,factorial乘以3变为6,sum_result加6,变为9,依此类推。 在代码实现中,可能需要用两个数组:一个保存当前阶乘,另一个保存总。或者,可以每次计算阶乘后立即加到总中。 现在,考虑C++的具体代码结构。使用数组来存储数字,每个元素代表一位,低位在前,高位在后。例如: const int MAX_LEN = 2000; // 足够大的位数 int factorial[MAX_LEN] = {0}; // 初始化阶乘数组,初始为1,所以factorial[0] =1 int sum_result[MAX_LEN] = {0}; // 初始总为0 初始化factorial[0] =1,其余为0。sum_result全为0。 然后循环i从1到n: // 计算当前阶乘 = factorial * i int carry =0; for(int j=0; j < MAX_LEN; j++){ int temp = factorial[j] * i + carry; factorial[j] = temp %10; carry = temp /10; } // 注意这里可能carry不为0,但原代码中可能未处理,因为数组长度足够大,可能假设carry会被处理到后续位?或者需要继续处理到carry为0? 然后,将factorial数组加到sum_result中: carry =0; for(int j=0; j < MAX_LEN; j++){ sum_result[j] += factorial[j] + carry; carry = sum_result[j] /10; sum_result[j] %=10; } // 这里可能有错误,应该先加factorial[j],然后处理进位。或者应该分开处理加法进位? 或者正确的加法步骤应该是: 对于每一位j,sum_result[j] += factorial[j],然后处理进位: int carry_add =0; for(int j=0; j < MAX_LEN; j++){ int temp = sum_result[j] + factorial[j] + carry_add; sum_result[j] = temp %10; carry_add = temp /10; } 这样,每次加法都处理进位,直到所有位处理完毕。 现在,结合这些步骤,编写C++代码的大纲: #include <iostream> using namespace std; const int MAX_LEN = 2000; int main() { int n; cin >> n; int factorial[MAX_LEN] = {0}; factorial[0] = 1; // 初始为1! =1 int sum_result[MAX_LEN] = {0}; for(int i=1; i<=n; i++) { // 计算阶乘 *=i int carry_mul =0; for(int j=0; j<MAX_LEN; j++) { int temp = factorial[j] * i + carry_mul; factorial[j] = temp %10; carry_mul = temp /10; } // 将阶乘加到sum_result中 int carry_add =0; for(int j=0; j<MAX_LEN; j++) { int temp = sum_result[j] + factorial[j] + carry_add; sum_result[j] = temp %10; carry_add = temp /10; } } // 输出结果,找到最高位非零的位置 int high_pos = MAX_LEN -1; while(high_pos >0 && sum_result[high_pos] ==0) high_pos--; for(int j=high_pos; j>=0; j--) { cout << sum_result[j]; } cout << endl; return 0; } 不过,这里可能存在几个问题: 1. 阶乘的计算是否正确?例如,当i=1时,初始的factorial是1,乘以i=1,得到1,正确。然后i=2,乘以2得到2,正确。但是在循环中,每次都是将当前的factorial乘以i,而i在循环中是递增的。例如,当i=1时,计算的是1!,当i=2时,乘以2得到2!,对吗? 是的,因为初始的factorial是1!(i=1时),然后i从1到n,每次循环处理i+1?或者可能循环变量的逻辑有问题? 比如,当i=1的时候,计算的是1!吗? 初始时,factorial数组是1,对应1!。在循环中,i从1到n: 第一次循环i=1,将factorial乘以1,得到1!,然后加到总中。这样总是1!。然后i=2,乘以2得到2!,加到总,总是1!+2!。这样对吗? 不对,因为循环变量i应该从1到n,计算i的阶乘,然后加到总。但当前的做法是,在循环中,每次乘以i,这样得到的是i!,对吗? 比如,初始factorial是1(对应1!)。当i=1时,乘以1,得到1!,加到总中。然后i=2,乘以2,得到2!,加到总中。然后i=3,乘以3,得到3!,依此类推。是的,所以这样循环是正确的,i的取值从1到n,每次计算i!,并加到总中。因此,代码的逻辑是对的。 另一个问题:当计算阶乘时,如果数组长度足够大,比如MAX_LEN=2000,是否能够处理大数?例如,当i很大时,阶乘的位数是否超过2000位?题目中的n的范围可能很大,例如n=100,此时100!有158位,所以2000位足够处理较大的n。引用[5]提到原题数据可能n较大,所以需要足够大的数组。 接下来,测试代码是否正确。例如,当n=3时,总应该是1!+2!+3! =1+2+6=9。代码中sum_result最后应该是9,即数组的第0位是9,其他为0。输出应该是9。 另一个测试,n=1时,输出1;n=2时,输出3;n=3时,输出9;n=4时,1+2+6+24=33。检查代码是否能够正确得到这些结果。 可能存在的问题:在加法步骤中,是否每次都将当前的阶乘加到总里?例如,当i=1时,阶乘是1!,总加上1!,正确。当i=2时,阶乘是2!,总加上2!,正确。是的。 现在,另一个问题,当计算阶乘时,如何处理进位?例如,当阶乘乘以i时,是否处理了所有可能的进位?当前的代码中,循环到MAX_LEN次,所以如果数组足够大,应该可以处理所有进位。 例如,假设当前阶乘数组的每一位都被处理,乘以i后,进位被传递到下一位。例如,当计算5!时,当前数组是24(即数组为[4,2,0,...]),乘以5时: 4*5=20,进位是2,数组[0, 2+2*5=12?或者,原数组的每一位都要乘以i加上进位。 哦,原代码中的乘法步骤是: carry_mul初始为0。 对于每个j,temp = factorial[j] * i + carry_mul factorial[j] = temp%10 carry_mul = temp/10 例如,初始factorial数组是[4,2,0,...],即24。 i=5时: j=0: temp =4*5 +0=20 → factorial[0]=0, carry_mul=2 j=1: temp =2*5 +2=12 → factorial[1]=2, carry_mul=1 j=2: temp=0*5 +1=1 → factorial[2]=1, carry_mul=0 后面的j>=3时,temp=0,carry_mul=0,所以数组变成[0,2,1,0,...],即120,正确,即5! =120。 所以乘法处理正确。 加法步骤是否正确? 假设当前sum_result是前一次的总,比如3(即数组[3,0,...])。现在需要加6(数组[6,0,...]): 加法循环中,j=0时,sum_result[0] =3+6=9,carry_add=0 → 9%10=9,carry=0。 后面的位都是0,所以总数组变成[9,0,...],正确。 另一个例子,当阶乘是24(数组[4,2,0,...]),加到总数组中原来的3(数组[3,0,...]): 加法后sum_result[0] =3+4=7,sum_result[1]=0+2=2 → 数组是[7,2,0,...],即27,正确。 所以加法处理正确。 综上所述,代码逻辑是正确的。但需要测试是否处理进位完全正确,尤其是在乘法后的进位是否处理到位。例如,在乘法循环中,当j循环到MAX_LEN-1时,如果还有进位,是否会溢出?例如,如果carry_mul在循环结束后仍有值,则数组后面的位置会被覆盖吗? 例如,假设MAX_LEN=3,计算阶乘到4!,即24,然后乘以i=5,得到120。数组长度为3,此时j循环到0,1,2: j=0: 4*5=20 → 余数0,进位2 → factorial[0]=0 j=1: 2*5=10 +2=12 →余数2,进位1 → factorial[1]=2 j=2: 0*5 +1=1 →余数1,进位0 → factorial[2]=1 此时carry_mul=0,循环结束。数组为[0,2,1],即120,正确。 如果MAX_LEN不够大,比如阶乘的位数超过数组长度,则会导致错误。因此,必须保证数组足够大。 综上,用户的问题需要实现高精度的阶乘之和,而上述代码可以正确实现。同时,需要注意数组的大小是否足够,比如题目中的n可能到多大的值。根据引用中的信息,例如引用[5]提到原书中的n=20无法通过,可能原题的n更大,所以需要足够大的数组。设置MAX_LEN为2000应该足够。 现在,用户可能还需要输出格式的问题,比如前导零是否需要去除。例如,在输出时,从最高位开始寻找第一个非零数字,然后输出之后的所有数字。代码中的处理是正确的,即从高位向低位找第一个非零位,然后逆序输出。 因此,最终的代码应该如上述结构,并处理这些情况。</think>### C++实现阶乘之和问题(P1009 NOIP 1998普及组) #### 问题分析 题目要求计算 $S = 1! + 2! + 3! + \dots + n!$,其中 $n$ 的范围较大(例如 $n \leq 50$ 时,$50! \approx 3.04 \times 10^{64}$),直接使用普通整型会溢出,因此需通过**高精度计算**模拟手工运算[^2][^5]。 #### 实现思路 1. **高精度乘法**:用数组存储阶乘的每一位,逐位计算并处理进位。 2. **高精度加法**:将每个阶乘的结果累加到总中,同样处理进位。 3. **数组设计**:数组低位存储数字低位(例如 `factorial[0]` 存储个位),便于扩展位数。 #### 代码实现 ```cpp #include <iostream> using namespace std; const int MAX_LEN = 2000; // 足够存储大数结果 int main() { int n; cin >> n; int factorial[MAX_LEN] = {0}; // 存储当前阶乘 factorial[0] = 1; // 初始化为1! = 1 int sum_result[MAX_LEN] = {0}; // 存储总 for (int i = 1; i <= n; i++) { // 计算当前阶乘: factorial *= i int carry_mul = 0; for (int j = 0; j < MAX_LEN; j++) { int temp = factorial[j] * i + carry_mul; factorial[j] = temp % 10; carry_mul = temp / 10; } // 将当前阶乘加到总中 int carry_add = 0; for (int j = 0; j < MAX_LEN; j++) { int temp = sum_result[j] + factorial[j] + carry_add; sum_result[j] = temp % 10; carry_add = temp / 10; } } // 输出结果(去除前导零) int high_pos = MAX_LEN - 1; while (high_pos > 0 && sum_result[high_pos] == 0) { high_pos--; } for (int j = high_pos; j >= 0; j--) { cout << sum_result[j]; } return 0; } ``` #### 代码说明 1. **初始化**:`factorial` 数组初始化为 $1$(对应 $1!$),`sum_result` 初始化为 $0$。 2. **阶乘计算**:通过逐位乘法更新 `factorial`,处理进位。 3. **累加操作**:将当前阶乘逐位加到 `sum_result`,处理进位。 4. **输出优化**:从最高非零位开始逆序输出,避免前导零。 #### 示例测试 - 输入 `n=3`,输出 `9`($1! + 2! + 3! = 1 + 2 + 6 = 9$)。 - 输入 `n=4`,输出 `33`($1 + 2 + 6 + 24 = 33$)。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值