HDOJ 1042 N! 自我总结

题目如下：

对于oj上的这道题，一开始第一个想到的就是简单的循环来算阶乘 但后来发现这道题是一个超大的数据 远远大于long long等可以存的字符数 因此需要用到数组的方法来对其数值进行存储
下面是我先后几次提交的oj代码

1.Time Limit Exceed

#include <iostream>
#include <stdio.h>
using namespace std;

long long a[1000000];

void calucate(int n)
{
    memset(a,-1,sizeof(a));
    a[1]=1;
    int weishu=1;
    int save=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=weishu;j++)
        {
            a[j]=a[j]*i+save;
            save =0;
            if(a[j]>=10)
            {
                if(a[j+1]==-1)
                {
                
                    weishu++;
                    a[j+1]=a[j]/10;
                    a[j]=a[j]%10;
                    //attention
                    while(a[j+1]>10)
                    {
                        a[j+2]=a[j+1]/10;
                        a[j+1]=a[j+1]%10;
                        j++;
                        weishu++;
                    }
                    break;
    
//attention        
                /*   else
                   {
                    save=a[j]/10;
                    a[j]=a[j]%10;
                   }*/
                }
                else if(a[j+1]!=-1)
                {
                    save=a[j]/10;
                    a[j]=a[j]%10;
                }

            }
        }
    }
    for(int i=weishu;i>=1;i--)
    {
        cout<<a[i];
    }
}
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
    calucate(n);
    cout<<endl;
    }
}

这段代码提交上去之后，oj给的是超出时间限制了，经过大佬们的办法之后，将每个数组为储存一个数字改为储藏四位（当然这里我认为五位六位 应该也是可以的）
修改后的代码如下

2.Ac

#include <iostream>
#include <stdio.h>
using namespace std;

long long a[10000];

void calucate(int n)
{
    memset(a,-1,sizeof(a)); 
    a[1]=1;
    int weishu=1;
    int save=0;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=weishu;j++)
        {
            a[j]=a[j]*i+save;
            save =0;
            if(a[j]>=10000)
            {
                if(a[j+1]==-1)  //如果a[j+1] 是负数 则表示当前为最高为 产生进位 并结束当前循环从第一位开始重新阶乘
                {
                
                    weishu++;
                    a[j+1]=a[j]/10000;
                    a[j]=a[j]%10000;
                    //attention
                    while(a[j+1]>10000) //针对最高位仍大于四位数的情况，重复取余进位
                    {
                        a[j+2]=a[j+1]/10000;
                        a[j+1]=a[j+1]%10000;
                        j++;
                        weishu++;
                    }
                    break;
    
//attention        
                /*   else
                   {
                    save=a[j]/10;
                    a[j]=a[j]%10;
                   }*/
                }
                else if(a[j+1]!=-1)
                {
                    save=a[j]/10000;
                    a[j]=a[j]%10000;
                }

            }
        }
    }
    printf("%d",a[weishu]);
    for(int i=weishu-1;i>=1;i--)
    {
        printf("%04d",a[i]);
    }
}
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
    calucate(n);
    cout<<endl;
    }
}

更改后的代码如上，通过了oj的测试 但是参考了别人贴的AC代码 发现这种打法还是有些繁琐和复杂的

大佬们的AC代码如下

#include<stdio.h>
void main()
{
	int i,j,m,n;
	while(scanf("%d",&n)!=EOF)
	{
		if(n<0)
			continue;
		int a[10000]={0};
		m=0;
		a[0]=1;
		for(i=1;i<=n;i++)
			for(j=0;j<=m;j++)
			{
				a[j]=a[j]*i;
				if(j>0&&a[j-1]>=10000)
				{
					a[j]=a[j]+a[j-1]/10000;
					a[j-1]=a[j-1]%10000;
				}
				if(a[m]>=10000)
					m++;
			}
		printf("%d",a[m]);
		for(i=m-1;i>=0;i--)
			printf("%04d",a[i]);
		printf("\n");
	}			
}

主要存在思想上的差异，我所采取的方法是每次遍历就产生相应的结果以及进位，并在下一次从计算后的结果继续阶乘，而他们的方法则是通过循环直接求得数值存在数组每一位中 最后来进行一次遍历来进行进位 产生最终的结果。相比起来我的方法确实代码繁琐了很多，足以看出我和大佬们的思想差异。。。orz
这个博客用于记录自己在做这道题的心得体会，大家不喜勿喷哈~谢谢