ACM--阶乘运行时间超时

2020-01-17 09:51:42 821 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

算法竞赛——组合数实战技巧全解析本文全面解析算法竞赛中组合数的实战技巧，涵盖递推法、阶乘逆元法、卢卡斯定理及高精度计算等核心方法。通过详细代码示例和典型例题剖析，帮助竞赛选手高效解决组合数计算问题，避免常见错误，提升算法竞赛表现。阅读详情

怎么在求一个比较大的阶乘时，比较有效率，，比如下面这段程序
,题目在提交的时候可能在验证的时候给了一个比较大的数，显示运行时间超时了，这个程序要怎么改呢

#include<iostream>

using namespace std;

long int fun(long int);

int main()

{

    int number;

    int n[1000];

    int i;

    long int S;

    cin>>number;

    for(i=0;i<number;i++)

    {

        cin>>n[i];

    }

    

    for(i=0;i<number;i++)

    {

        S=0;

        long int j;

        for(j=1;j<n[i];j++)

        {

            S+=j*fun(j);

        }

        cout<<S%n[i]<<endl;

    }

    return 0;

}

long int fun(long int k)

{

    long int f;

    if(k==0||k==1)

    {

        f=1;

    }

    else

        f=fun(k-1)*k;

    return f;

}

...全文

在算法竞赛中怎样正确的分析一个程序的时间复杂度基础：掌握循环分析和主定理。记忆：牢记常见数据结构和算法的复杂度。技巧：学会通过数据范围反推算法复杂度。实践多做题：看完题后，先自己分析预期复杂度，再写代码。对拍测试：用大数据测试你的程序，感受不同复杂度算法的实际运行时间差异。阅读他人代码：学习别人是如何优化常数和设计高效算法的。通过以上系统和实践的结合，你就能在算法竞赛中游刃有余地分析时间复杂度，做出正确的算法选择。祝你竞赛顺利！阅读详情

Never妥协

C++ 语言 65,214 成员 250,514 内容

+ 关注 + 加入社区

切换为时间正序

一星伴月 2020-01-20

打赏
举报

答案就是输入的数减一，给你解决了哈，不能直接算

智者知已应修善业 2020-01-18

打赏
举报

你一时想不通慢慢想，还是那句话，只要你的变量容得下即可。

引用 12 楼 Never妥协的回复:

[quote=引用 11 楼智者知已应修善业的回复:]
有何疑问？只要能接受得下当然可以，那你用虾米类型整数变量接受几百位甚至千位的数？
[quote=引用 10 楼 Never妥协的回复:]
[quote=引用 8 楼智者知已应修善业的回复:]
不过我觉得这个程序有优化的地方，否则的话嵌套循环都要进行5000次有点影响速度，得闲优化一下。
分析阶层24*5就知道进阶是如何放到数组后面的了：4*5=20%=0，20/10=2，2*5+2=12%10=2，12/10=1，0*5+1=1%=1，1/10=0因此数组存放了120这个值。

这个最后可以把数组里存的值赋给一个整数吗？
[/quote][/quote]那个最后如果要用到这个算出来的阶乘数计算别的，那不就得把他赋给一个整型数吗[/quote]

Never妥协 2020-01-18

打赏
举报

引用 11 楼智者知已应修善业的回复:

有何疑问？只要能接受得下当然可以，那你用虾米类型整数变量接受几百位甚至千位的数？ [quote=引用 10 楼 Never妥协的回复:] [quote=引用 8 楼智者知已应修善业的回复:] 不过我觉得这个程序有优化的地方，否则的话嵌套循环都要进行5000次有点影响速度，得闲优化一下。分析阶层24*5就知道进阶是如何放到数组后面的了：4*5=20%=0，20/10=2，2*5+2=12%10=2，12/10=1，0*5+1=1%=1，1/10=0因此数组存放了120这个值。

这个最后可以把数组里存的值赋给一个整数吗？ [/quote][/quote]那个最后如果要用到这个算出来的阶乘数计算别的，那不就得把他赋给一个整型数吗

智者知已应修善业 2020-01-18

打赏
举报

有何疑问？只要能接受得下当然可以，那你用虾米类型整数变量接受几百位甚至千位的数？

引用 10 楼 Never妥协的回复:

[quote=引用 8 楼智者知已应修善业的回复:]
不过我觉得这个程序有优化的地方，否则的话嵌套循环都要进行5000次有点影响速度，得闲优化一下。
分析阶层24*5就知道进阶是如何放到数组后面的了：4*5=20%=0，20/10=2，2*5+2=12%10=2，12/10=1，0*5+1=1%=1，1/10=0因此数组存放了120这个值。

这个最后可以把数组里存的值赋给一个整数吗？
[/quote]

Never妥协 2020-01-18

打赏
举报

引用 8 楼智者知已应修善业的回复:

不过我觉得这个程序有优化的地方，否则的话嵌套循环都要进行5000次有点影响速度，得闲优化一下。分析阶层24*5就知道进阶是如何放到数组后面的了：4*5=20%=0，20/10=2，2*5+2=12%10=2，12/10=1，0*5+1=1%=1，1/10=0因此数组存放了120这个值。

这个最后可以把数组里存的值赋给一个整数吗？

寻开心 2020-01-18

打赏
举报

j*fun（j）这个结果预先存到数组里面，一次完成
后面主函数里面 S+= 这个数组元素就好了

楼主直接把大家都领坑里去了，找阶乘快速算法

寻开心 2020-01-18

打赏
举报

看楼主的代码，似乎循环读入一个大数组，对数组每一个元素求阶乘后求和
这样的话，完全可以把这些阶乘数值一次算完，保存到一个数组当中，直接查表使用结果就好了，无需每次重新计算阶乘

提交结果是超时不是溢出，所以改变算法是必然的选择。

寻开心 2020-01-18

打赏
举报

又看一下楼主的描述，问题在超时上，而不是溢出上
long int在windows下也是32位， long long int 是64位
linux下long int 是64位或者32位，看cpu类型了
但是，即便是64位的int，算阶乘21！就溢出了
21次的迭代和递推或者递归，有差异吗？！！

问题超时归结在这个上面总觉得不太合理。原始问题是什么，楼主最好也贴出来看看

真相重于对错 2020-01-17

打赏
举报

引用 4 楼 Never妥协的回复:

引用 1 楼真相重于对错的回复:
用迭代，不要用递归
迭代试了，也一样的

百度阶乘高效算法

Never妥协 2020-01-17

打赏
举报

引用 1 楼真相重于对错的回复:

用迭代，不要用递归

迭代试了，也一样的

智者知已应修善业 2020-01-17

打赏
举报

引用


#include<stdio.h>
#define N 5000//modify it to hold larger number
//to avoid stack overflow, define it as global varible
int f[N];//do not need to be assigned as 0 because it has already been assigned 0 by the system
int main()
{
    int n,i,j,s,up;
    scanf("%d",&n);
    for(i=2,f[0]=1;i<=n;i++)
    {
        for(j=up=0;j<N;j++)
        {
            s=f[j]*i+up;
            f[j]=s%10;
            up=s/10;
        }
    }
    for(i=N-1;f[i]==0;i--);
    for(;i>=0;i--)
    printf("%d",f[i]);
    printf("\n");
    return 0;
}

yshuise 2020-01-17

打赏
举报

调用函数，把默认栈值扩大

真相重于对错 2020-01-17

打赏
举报

用迭代，不要用递归

寻开心 2020-01-17

打赏
举报

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <time.h>

#define MAX 5000
int facts[MAX];
int factd(int n) {
if ( 0==n || 1==n ) {
facts[0] = 1;
return 1;
}
memset(facts, 0, MAX*sizeof(int));
facts[0] = 1; int len = 1;
for (int i=2; i<=n; i++) {
int extend = 0;
long long int d;
for ( int j=0; j<len; j++) {
long long int a = facts[j];
d = a * i + extend;
if ( d > 1000000000) {
facts[j] = d % 1000000000;
extend = d / 1000000000;
} else
facts[j] = d, extend=0;
}
if ( extend>0) {
facts[len] = extend;
len ++;
extend = 0;
}
}
return len;
}

#include <time.h>
int main() {
clock_t start,end;
int len = 0;
start = clock();
len = factd(10000);
end = clock();
printf("len:%d\n", len);
if (len>1) {
printf("%d ", facts[len-1]);
for ( int i=len-2; i>=0; i--)
printf("%09d ", facts[i]);
} else
printf("%d", facts[0]);
double endtime=(double)(end-start)/CLOCKS_PER_SEC;
printf("time:%lf(s)", endtime);
return 0;
}
10000! 0.1s也算出来了。输出函数用的时间长

智者知已应修善业 2020-01-17

打赏
举报

不过我觉得这个程序有优化的地方，否则的话嵌套循环都要进行5000次有点影响速度，得闲优化一下。
分析阶层24*5就知道进阶是如何放到数组后面的了：4*5=20%=0，20/10=2，2*5+2=12%10=2，12/10=1，0*5+1=1%=1，1/10=0因此数组存放了120这个值。

智者知已应修善业 2020-01-17

打赏
举报

我略分析了一下这个程序的原理，大概算到4和5，他没虾米算法，与普通乘法一样，就是位数进阶到数组的后面了，因此，最后的结果要倒序输出，不过其思路是值得借鉴的。
倒着存放数据，倒着输出，不过C++数组容量不会很大，因为之前写过字符串四则运算，因此，对于C++数组运算没虾米兴趣再去写，这里备录只是为了看看别人的思路而已。

Never妥协 2020-01-17

打赏
举报

引用 3 楼智者知已应修善业的回复:

引用


#include<stdio.h>
#define N 5000//modify it to hold larger number
//to avoid stack overflow, define it as global varible
int f[N];//do not need to be assigned as 0 because it has already been assigned 0 by the system
int main()
{
    int n,i,j,s,up;
    scanf("%d",&n);
    for(i=2,f[0]=1;i<=n;i++)
    {
        for(j=up=0;j<N;j++)
        {
            s=f[j]*i+up;
            f[j]=s%10;
            up=s/10;
        }
    }
    for(i=N-1;f[i]==0;i--);
    for(;i>=0;i--)
    printf("%d",f[i]);
    printf("\n");
    return 0;
}

大佬，能说下原理不

ACM--阶乘运行时间超时

相关推荐