P1009 [NOIP1998 普及组] 阶乘之和

题目描述

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

其中“!”表示阶乘,例如:5! = 5 *4 * 3 * 2 * 1.

输入格式

一个正整数 n。

输出格式

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

输入输出样例

输入
3
输出
9

说明/提示

【数据范围】

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

解析:

高精度阶乘问题,用数组来存储数值。

代码:

#include<bits/stdc++.h>
using namespace std;

int n;
int a[121];//存阶乘结果
int b[121];//存求和结果 
//求阶乘
void cheng(int* a,int x){
	int jw=0;//进位 
	for(int i=1;i<=120;i++){
		a[i]=a[i]*x+jw;
		jw=a[i]/10;
		a[i]%=10;
	}
} 
//求和
void add(int* b,int* a){
	int jw=0;//进位 
	for(int i=1;i<=120;i++){
		b[i]+=(a[i]+jw);
		jw=b[i]/10;
		b[i]%=10;
	}
}
int main()
{
	cin>>n;
	a[1]=1;//初始值为1
	b[1]=0;
	for(int i=1;i<=n;i++){//由小到大求阶乘 
		cheng(a,i);//阶乘结果保存在a[]中 
		add(b,a);//求和结果保存在b[]中 
	}
	
	int flag=0;
	for(int i=120;i>=1;i--){
		if(b[i]!=0)//由第一个非零数值开始输出 
			flag=1;
		if(flag==1)
			cout<<b[i];
	}
	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]中的代码片段,他们使用了两个数组sum和last_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、付费专栏及课程。

余额充值