有一100阶层的楼梯，有三种走楼梯方式，一次走一阶，一次走两阶，一次走三阶。用算法实现，走完100阶总共有多少种走法

[WellerV]

不要告诉我直接用递归
#include<stdio.h>
long int fun(int n)
{
if(n==1) return 1;
if(n==2) return 2;
if(n==3) return 4;
else return fun(n-1)+fun(n-2)+fun(n-3);
}
void main()
{
printf("%d",fun(100));
}
这样是算不出来的 数字太大了

[ybjx111]

[Quote=引用 1 楼 的回复:]
C/C++ code

#include <iostream>
using namespace std;

int CountMethod(int n)
{
int i, j, k;
int count = 0;
for (i = 0; i <= n/3; i++)
for (j = 0; j <= n/2; j++)
……
[/Quote]
在你的基础上还要计算排列组合。

[ybjx111]

#include <iostream>
using namespace std;

int CountMethod(int n)
{
    int i, j, k;
    int count = 0;
    for (i = 0; i <= n/3; i++)
        for (j = 0; j <= n/2; j++)
            for (k = 0; k <= n; k++)
                if (3*i + 2*j + k == n)                
                    count++;//这里不是++；应该是(100!)/(j!)*((100-j)!)/(k!);
                
                return count;
                
}

int main()
{
    int count = CountMethod(100);
    cout << count << endl;
    return 0;
}

100比较大应该需要用到大数

[A_Zhao]

楼主，你的算法，之所以没有结果，并不是因为“数字太大”，而是因为递归太深。

随着台阶数量的增大，所耗费的计算时间，呈恐怖的超级爆炸形态增长（越来越慢，直等到世界末日）。

但若改用如下这种线性赋值的方法的话，速度会极快。

	for (int x = 3; x < 100; x++) {
		a[x] = a[x - 1] + a[x - 2] + a[x - 3];
	}

还有，用“long”恐怕不合适，还是用“double”吧。

两种算法的比较性代码，如下：

#include<stdio.h>

double fun(int n) {
	if (n == 1)
		return 1;
	if (n == 2)
		return 2;
	if (n == 3)
		return 4;
	else
		return fun(n - 1) + fun(n - 2) + fun(n - 3);
}
int main() {

	double a[100];

	a[0] = 1;
	a[1] = 2;
	a[2] = 4;

	for (int x = 3; x < 100; x++) {
		a[x] = a[x - 1] + a[x - 2] + a[x - 3];
	}

	for (int i = 0; i < 100; i++) {
		printf("Level Amount--->%d\t", (i + 1));
		printf("Sol:1--->%e\t", fun(i + 1));
		printf("Sol:2--->%e\n", a[i]);

	}

	return 0;
}

编译后，运行结果如下：

Level Amount--->1	Sol:1--->1.000000e+00	Sol:2--->1.000000e+00
Level Amount--->2	Sol:1--->2.000000e+00	Sol:2--->2.000000e+00
Level Amount--->3	Sol:1--->4.000000e+00	Sol:2--->4.000000e+00
Level Amount--->4	Sol:1--->7.000000e+00	Sol:2--->7.000000e+00
Level Amount--->5	Sol:1--->1.300000e+01	Sol:2--->1.300000e+01
Level Amount--->6	Sol:1--->2.400000e+01	Sol:2--->2.400000e+01
Level Amount--->7	Sol:1--->4.400000e+01	Sol:2--->4.400000e+01
Level Amount--->8	Sol:1--->8.100000e+01	Sol:2--->8.100000e+01
Level Amount--->9	Sol:1--->1.490000e+02	Sol:2--->1.490000e+02
Level Amount--->10	Sol:1--->2.740000e+02	Sol:2--->2.740000e+02
Level Amount--->11	Sol:1--->5.040000e+02	Sol:2--->5.040000e+02
Level Amount--->12	Sol:1--->9.270000e+02	Sol:2--->9.270000e+02
Level Amount--->13	Sol:1--->1.705000e+03	Sol:2--->1.705000e+03
Level Amount--->14	Sol:1--->3.136000e+03	Sol:2--->3.136000e+03
Level Amount--->15	Sol:1--->5.768000e+03	Sol:2--->5.768000e+03
Level Amount--->16	Sol:1--->1.060900e+04	Sol:2--->1.060900e+04
Level Amount--->17	Sol:1--->1.951300e+04	Sol:2--->1.951300e+04
Level Amount--->18	Sol:1--->3.589000e+04	Sol:2--->3.589000e+04
Level Amount--->19	Sol:1--->6.601200e+04	Sol:2--->6.601200e+04
Level Amount--->20	Sol:1--->1.214150e+05	Sol:2--->1.214150e+05
Level Amount--->21	Sol:1--->2.233170e+05	Sol:2--->2.233170e+05
Level Amount--->22	Sol:1--->4.107440e+05	Sol:2--->4.107440e+05
Level Amount--->23	Sol:1--->7.554760e+05	Sol:2--->7.554760e+05
Level Amount--->24	Sol:1--->1.389537e+06	Sol:2--->1.389537e+06
Level Amount--->25	Sol:1--->2.555757e+06	Sol:2--->2.555757e+06
Level Amount--->26	Sol:1--->4.700770e+06	Sol:2--->4.700770e+06
Level Amount--->27	Sol:1--->8.646064e+06	Sol:2--->8.646064e+06
Level Amount--->28	Sol:1--->1.590259e+07	Sol:2--->1.590259e+07
Level Amount--->29	Sol:1--->2.924942e+07	Sol:2--->2.924942e+07
Level Amount--->30	Sol:1--->5.379808e+07	Sol:2--->5.379808e+07
Level Amount--->31	Sol:1--->9.895010e+07	Sol:2--->9.895010e+07
Level Amount--->32	Sol:1--->1.819976e+08	Sol:2--->1.819976e+08

在我的计算机上，算到有32台阶的时候，程序就如同身上压了万钧重担，难以转身了，好像停滞了一样。

请特别注意：此时，一定要把编译出来的程序的进程强行关闭，否则，如果你反复修改代码、反复编译运行程序的话，计算机（运行正常程序的）速度，有可能会变得越来越慢，因为前者（们）可能还在后台跑着呢！

但如果把“fun(i + 1)”这一行去掉，程序改为：

#include<stdio.h>

double fun(int n) {
	if (n == 1)
		return 1;
	if (n == 2)
		return 2;
	if (n == 3)
		return 4;
	else
		return fun(n - 1) + fun(n - 2) + fun(n - 3);
}
int main() {

	double a[100];

	a[0] = 1;
	a[1] = 2;
	a[2] = 4;

	for (int x = 3; x < 100; x++) {
		a[x] = a[x - 1] + a[x - 2] + a[x - 3];
	}

	for (int i = 0; i < 100; i++) {
		printf("Level Amount--->%d\t", (i + 1));
	  	//printf("Sol:1--->%e\t", fun(i + 1));
		printf("Sol:2--->%e\n", a[i]);

	}

	return 0;
}

编译后，运行。程序完整运行到底，速度极快。输出100个答案，只要1秒钟：

Level Amount--->1	Sol:2--->1.000000e+00
Level Amount--->2	Sol:2--->2.000000e+00
Level Amount--->3	Sol:2--->4.000000e+00
Level Amount--->4	Sol:2--->7.000000e+00
Level Amount--->5	Sol:2--->1.300000e+01
Level Amount--->6	Sol:2--->2.400000e+01
Level Amount--->7	Sol:2--->4.400000e+01
Level Amount--->8	Sol:2--->8.100000e+01
Level Amount--->9	Sol:2--->1.490000e+02
Level Amount--->10	Sol:2--->2.740000e+02
Level Amount--->11	Sol:2--->5.040000e+02
Level Amount--->12	Sol:2--->9.270000e+02
Level Amount--->13	Sol:2--->1.705000e+03
Level Amount--->14	Sol:2--->3.136000e+03
Level Amount--->15	Sol:2--->5.768000e+03
Level Amount--->16	Sol:2--->1.060900e+04
Level Amount--->17	Sol:2--->1.951300e+04
Level Amount--->18	Sol:2--->3.589000e+04
Level Amount--->19	Sol:2--->6.601200e+04
Level Amount--->20	Sol:2--->1.214150e+05
Level Amount--->21	Sol:2--->2.233170e+05
Level Amount--->22	Sol:2--->4.107440e+05
Level Amount--->23	Sol:2--->7.554760e+05
Level Amount--->24	Sol:2--->1.389537e+06
Level Amount--->25	Sol:2--->2.555757e+06
Level Amount--->26	Sol:2--->4.700770e+06
Level Amount--->27	Sol:2--->8.646064e+06
Level Amount--->28	Sol:2--->1.590259e+07
Level Amount--->29	Sol:2--->2.924942e+07
Level Amount--->30	Sol:2--->5.379808e+07
Level Amount--->31	Sol:2--->9.895010e+07
Level Amount--->32	Sol:2--->1.819976e+08
Level Amount--->33	Sol:2--->3.347458e+08
Level Amount--->34	Sol:2--->6.156935e+08
Level Amount--->35	Sol:2--->1.132437e+09
Level Amount--->36	Sol:2--->2.082876e+09
Level Amount--->37	Sol:2--->3.831006e+09
Level Amount--->38	Sol:2--->7.046319e+09
Level Amount--->39	Sol:2--->1.296020e+10
Level Amount--->40	Sol:2--->2.383753e+10
Level Amount--->41	Sol:2--->4.384405e+10
Level Amount--->42	Sol:2--->8.064178e+10
Level Amount--->43	Sol:2--->1.483234e+11
Level Amount--->44	Sol:2--->2.728092e+11
Level Amount--->45	Sol:2--->5.017743e+11
Level Amount--->46	Sol:2--->9.229069e+11
Level Amount--->47	Sol:2--->1.697490e+12
Level Amount--->48	Sol:2--->3.122172e+12
Level Amount--->49	Sol:2--->5.742569e+12
Level Amount--->50	Sol:2--->1.056223e+13
Level Amount--->51	Sol:2--->1.942697e+13
Level Amount--->52	Sol:2--->3.573177e+13
Level Amount--->53	Sol:2--->6.572097e+13
Level Amount--->54	Sol:2--->1.208797e+14
Level Amount--->55	Sol:2--->2.223325e+14
Level Amount--->56	Sol:2--->4.089331e+14
Level Amount--->57	Sol:2--->7.521453e+14
Level Amount--->58	Sol:2--->1.383411e+15
Level Amount--->59	Sol:2--->2.544489e+15
Level Amount--->60	Sol:2--->4.680046e+15
Level Amount--->61	Sol:2--->8.607946e+15
Level Amount--->62	Sol:2--->1.583248e+16
Level Amount--->63	Sol:2--->2.912047e+16
Level Amount--->64	Sol:2--->5.356090e+16
Level Amount--->65	Sol:2--->9.851385e+16
Level Amount--->66	Sol:2--->1.811952e+17
Level Amount--->67	Sol:2--->3.332700e+17
Level Amount--->68	Sol:2--->6.129790e+17
Level Amount--->69	Sol:2--->1.127444e+18
Level Amount--->70	Sol:2--->2.073693e+18
Level Amount--->71	Sol:2--->3.814117e+18
Level Amount--->72	Sol:2--->7.015254e+18
Level Amount--->73	Sol:2--->1.290306e+19
Level Amount--->74	Sol:2--->2.373243e+19
Level Amount--->75	Sol:2--->4.365075e+19
Level Amount--->76	Sol:2--->8.028625e+19
Level Amount--->77	Sol:2--->1.476694e+20
Level Amount--->78	Sol:2--->2.716064e+20
Level Amount--->79	Sol:2--->4.995621e+20
Level Amount--->80	Sol:2--->9.188380e+20
Level Amount--->81	Sol:2--->1.690007e+21
Level Amount--->82	Sol:2--->3.108407e+21
Level Amount--->83	Sol:2--->5.717251e+21
Level Amount--->84	Sol:2--->1.051566e+22
Level Amount--->85	Sol:2--->1.934132e+22
Level Amount--->86	Sol:2--->3.557424e+22
Level Amount--->87	Sol:2--->6.543123e+22
Level Amount--->88	Sol:2--->1.203468e+23
Level Amount--->89	Sol:2--->2.213523e+23
Level Amount--->90	Sol:2--->4.071303e+23
Level Amount--->91	Sol:2--->7.488293e+23
Level Amount--->92	Sol:2--->1.377312e+24
Level Amount--->93	Sol:2--->2.533271e+24
Level Amount--->94	Sol:2--->4.659412e+24
Level Amount--->95	Sol:2--->8.569996e+24
Level Amount--->96	Sol:2--->1.576268e+25
Level Amount--->97	Sol:2--->2.899209e+25
Level Amount--->98	Sol:2--->5.332476e+25
Level Amount--->99	Sol:2--->9.807953e+25
Level Amount--->100	Sol:2--->1.803964e+26

答案是：这个“走法”的数量，数量级高达10的26次方，1后面有26个0！

当然，想要把这个整数，精准而完整地表达出来，靠基本算法，是远远不能实现的。

以上，仅供参考，呵呵：）

[时间坐标]

首先，遍历是很愚蠢的算法，所以千万别用。

递归算法，设阶梯数为N，一步走的最多阶数为S
你的问题就是N = 100，S = 3

数学原理我不再阐述，都是初中的东西。
设n为阶梯数，显然：
当n≤S时，答案为：2 ^ (n - 1)
对于此题：
n = 1, ans = 1
n = 2, ans = 2
n = 3, ans = 4

当n>S时，做如下分析，只有S种情况。
当第一步走s阶（s≤S）时，剩下的阶梯数是n - s。
对于此题：
当n = 4时：
当第一步走1阶，还剩下3阶，很好，这3阶有多少种走法我们已经知道了（n = 3, ans = 4）。
当第一步走2阶，还剩下2阶，同理n = 2, ans = 2。
当第一步走3阶，还剩下1阶，同理n = 1, ans = 1。
所以，综合这3种情况，n = 4时，ans = 4 + 2 + 1 = 7。

很好，我们得到归纳算法：
ans[k] = ans[k - 1] + ans[k - 2] + ... + ans[k - S] （当k>S时）
对于此题：
ans[k] = ans[k - 1] + ans[k - 2] + ans[k - 3]。

这样，只需不断迭代计算到k=N，便可得到结果。
对于此题，N = 100。

从算法本身很容易看到，时间复杂度为O(n)，这远远优于遍历，而且当S稍微大点的时候，遍历算法==没有算法。而且，每次只需用到S个数据，也就是说，只需缓存S + 1个数据即可实现算法（一个长为S + 1的数组）。

[zhengjiankang]

用特征方程来解丫。

[核动力蜗牛Killua]

这题明显是用动态规划来解决。

LS已经给了大致算法，我想补充的说，求解ans[k] = ans[k - 1] + ans[k - 2] + ans[k - 3]稍微注意下迭代的方向。

[W170532934]

动态规划哎。

[baichi4141]

我说，这题一看就是斐波那契数列的变形吧？

斐波那契数列可以直接求通项公式，既不用递归也不用数组
这个变形我不知道，有兴趣的试试看吧

[老王爱上猫]

求方程X+2Y+3Z=100

[TimeLimitExceeded]

递推吧..

[skillart]

每次记录一下就行了

[c090869]

[Quote=引用 12 楼 的回复:]

我说，这题一看就是斐波那契数列的变形吧？

斐波那契数列可以直接求通项公式，既不用递归也不用数组
这个变形我不知道，有兴趣的试试看吧
[/Quote]
fun(n)=fun(n-1)+fun(n-2)+fun(n-3); 没错，是Fibonacci数列。
main()
{
double f1=1,f2=2,f3=4;
int i;
for(i=1;i<=32;i++)
{ f1=f1+f2+f3;
f2=f1+f2+f3;
f3=f1+f2+f3;
}
printf("%e\n",f1+f2+f3);
}

[sunny_hit_08]

[code=C/C++][/#include <stdio.h>
#include <stdlib.h>
int Pa(int n)
{
long int sum=1;

for(;n>=1;n--)
{
sum=n*sum;
}
//printf("%ld\n",sum);

return sum;
}

int CountMethod(int n)
{
int i,j,k;
int count=0;
int x[100]={0};
int y[100]={0};
int z[100]={0};
long int s[100]={0};
long int sum=0;

for(k=0;k<=n/3;k++)
for(j=0;j<=n/2;j++)
for(i=0;i<=n/1;i++)
if(n==1*i+2*j+3*k)
{
x[count]=i;
y[count]=j;
z[count]=k;
s[count]=Pa(i+j+k)/(Pa(i)*Pa(j)*Pa(k));
// printf("x[%d]=%d\ty[%d]=%d\tz[%d]=%d\t\n",count,x[count],count,y[count],count,z[count]);
printf("s[%d]=%ld\n",count,s[count]);
count++;
}
for(;count>=0;count--)
{
sum=sum+s[count];
printf("s[%d]=%ld\n",count,s[count]);
}
count = 0;
return sum;
}

int main()
{
int n;
long int t;
scanf("%d",&n);
t=CountMethod(n);

printf("%ld\n",t);
return 0;
}
]数据类型选的比较小 你自己调一下

[pathuang68]

[Quote=引用 12 楼 的回复:]

我说，这题一看就是斐波那契数列的变形吧？

斐波那契数列可以直接求通项公式，既不用递归也不用数组
这个变形我不知道，有兴趣的试试看吧
[/Quote]

++
这位兄弟是个高手！

[RiqueZhang]

请参考
http://topic.csdn.net/u/20120524/17/50808003-23db-4c39-926f-aaea1061a297.html?4070

方法有四：
1.递归
2.循环
3.矩阵
4.通公

[kason2011]

[Quote=引用 7 楼 的回复:]

C/C++ code

#include <iostream>
using namespace std;

int CountMethod(int n)
{
int i, j, k;
int count = 0;
for (i = 0; i <= n/3; i++)
for (j = 0; j <= n/2; j++)
for (……
[/Quote]学习了

[RiqueZhang]

#include <stdio.h>
//---------------------------------------------------
//矩阵实现
struct Matrix3X3
{
	double M11,M12,M13;
	double M21,M22,M23;
	double M31,M32,M33;
};
Matrix3X3 Multiply(Matrix3X3 vA, Matrix3X3 vB)
{
	Matrix3X3 tC;
	tC.M11=vA.M11*vB.M11+vA.M12*vB.M21+vA.M13*vB.M31;
	tC.M12=vA.M11*vB.M12+vA.M12*vB.M22+vA.M13*vB.M32;
	tC.M13=vA.M11*vB.M13+vA.M12*vB.M23+vA.M13*vB.M33;
	tC.M21=vA.M21*vB.M11+vA.M22*vB.M21+vA.M23*vB.M31;
	tC.M22=vA.M21*vB.M12+vA.M22*vB.M22+vA.M23*vB.M32;
	tC.M23=vA.M21*vB.M13+vA.M22*vB.M23+vA.M23*vB.M33;
	tC.M31=vA.M31*vB.M11+vA.M32*vB.M21+vA.M33*vB.M31;
	tC.M32=vA.M31*vB.M12+vA.M32*vB.M22+vA.M33*vB.M32;
	tC.M33=vA.M31*vB.M13+vA.M32*vB.M23+vA.M33*vB.M33;
	return tC;
}
Matrix3X3 Power(__int64 vPower, Matrix3X3 vA)
{
	Matrix3X3 tC=Matrix3X3();
	if(0>=vPower)
		return tC;
	else if(1==vPower)
		return vA;
	else
		{
		tC=Power(vPower>>1,Multiply(vA,vA));
		if(1==(1&vPower))
			tC=Multiply(vA,tC);
		return tC;
		}
}
double CountM(__int64 vStep)
{
	if(0>vStep)	return 0;
	if(1==vStep)return 1;
	if(2==vStep)return 2;
	if(3==vStep)return 4;
	
	Matrix3X3 tA;
	tA.M11=tA.M12=tA.M13=tA.M21=tA.M32=1;
	tA.M22=tA.M23=tA.M31=tA.M33=0;
	tA=Power(vStep-3,tA);
	return 4*tA.M11+2*tA.M12+tA.M13;
}
//---------------------------------------------------
//循环实现
double CountL(__int64 vStep)
{
	if(0>vStep)	return 0;
	if(1==vStep)return 1;
	if(2==vStep)return 2;
	if(3==vStep)return 4;
	
	double tF1=1,tF2=2,tF3=4,tF4;
	for(__int64 i=3; i<vStep; i++)
		{
		tF4=tF3+tF2+tF1;
		tF1=tF2;
		tF2=tF3;
		tF3=tF4;
		}
	
	return tF4;
}
//---------------------------------------------------
int main()
{
	double tL=CountL(100);
	double tM=CountM(100);
	
	return 0;
}

[RiqueZhang]

这里写错了，应该是

if(0>=vStep)return 0;

[Quote=引用 22 楼 的回复:]

C/C++ code

#include <stdio.h>
//---------------------------------------------------
//矩阵实现
struct Matrix3X3
{
double M11,M12,M13;
double M21,M22,M23;
double M31,M32,M33;
};
Matrix3X3 Mu……
[/Quote]

[smsgreenlife]

[Quote=引用 7 楼 的回复:]
C/C++ code

#include <iostream>
using namespace std;

int CountMethod(int n)
{
int i, j, k;
int count = 0;
for (i = 0; i <= n/3; i++)
for (j = 0; j <= n/2; j++)
……
[/Quote]
应该是(100!)/(i!)/(j!)/(k!)吧

[太上绝情]

别递归，用循环做，想斐波那契数列一样