继续优化！
最后是一个斐波那切公式。

空间换时间～

数学令我很迷茫

用 Dictionary(Of TKey, TValue)，节省装/拆箱性能。

 

@随风流月
用List<int>性能比Hashtable稍微好一点

不错，学习了

@jillzhang
不会的... 是 HashSet 快.

用Dictionary<T,T>
Hashtable有装箱

算法，Nice


另外：楼主可真够搞笑　How money cows.

@置身珠海，学习与奋斗
:)

1.从数学的角度来说，一看就知道是递推，而不是递归，因为这个数列和Fibonacci数列一差不多。当让你说递归也没错，因为任何递归都能转化为递推。

2.优化递归的第一个思路应该是改为递推。

3.计算Fibnacci数列根本就不需要这么复杂的数据结构，前人都是用数组递推的。

4.最后，最好找到数学公式算，连递推都不要了。

@Cat Chen
受教

原来不是生兔子问题嘛，现在咋成生小牛了

算法都快忘光了

当小兔子进化为小牛...

只有生牛没有死牛吗，要不要考虑牛的寿命？

@小陆
可以加上一句呀，一头牛的生命为30年，这样就更有意思了

for (int j = 4;j <= years;j++)
{
table1.Add(j, (long)table1[j - 3] + (long)table1[j - 1]);
}
count = (long)table1[(int)years];
基本时间就一次循环的时间

//初始化为1头牛
long count = 1;
if (years <= 3)
{
return count;
}
table1.Add(1, (long)1);
table1.Add(2, (long)1);
table1.Add(3, (long)1);

从结果分析: 小牛是每年年初出生的

第四年的时候第一头小牛已经发育了一年

两个与技术无关的问题。。。。

小牛都是雌性的吗？
牛能存活20年么？

碰到数学题就头疼

只剩一头老牛。
没得交配的，生个屁啊。嘿嘿。

呵呵.没有考虑生出公牛的可能性.所以题目本身也不够严谨啊.

比如可改为:

假设生下的小牛全是母牛,且忽略母牛怀胎的问题,问20年后共有牛多少只？

我做的这个应该是最优的了吧。C++

#include <iostream.h>
#define YEAR 50
void main()
{
int a,b,c,sum;

a = 1;
b = 0;
c = 0;

sum = 1;

int i = 4;
while(i <= YEAR)
{
a = a + c;
sum += a;
i++;
if(i>YEAR)
{
break;
}

b = b + a;
sum += b;
i++;
if(i>YEAR)
{
break;
}

c = c + b;
sum += c;
i++;
}

cout<<sum<<endl;
}
20年，50年，100年都是不到1s就出来了。

内容(请不要发表任何与政治相关的内容) 看到这句话，有点想到三四十年代在饭馆里面贴的“莫谈国事”了

樓上的寫得不錯 不過我不懂C++語法 ：cout<<sum<<endl; 這句是什麼意思。。

输入sum值并换行.

递归不是好方法

public static long getCount(int year)
{
long y1 = 0;
long y2 = 0;
long y3 = 1;
long y4 = 0;
for (int i = 4; i <= year; i++)
{
y4 = y4 + y3;
y3 = y2;
y2 = y1;
y1 = y4;
}
return y1 + y2 + y3 + y4;
}

long Compute(int years)
{
if(years <= 0)
{
return 0;
}

long a,b,c;

a = 1;
b = 0;
c = 0;


int i = 6;
years += 3;
while(i <= years)
{
a += c;
b += a;
c += b;
i += 3;
}

if(years%3 == 0)
{
a = c;
}
else
{
a += c;
if(years%3 == 2)
{
b += a;
a = b ;
}
}
return a;

}

总共用了years次加法.0次乘法.

long Compute(int YEARS)
{
long a[128];
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
a[4] = 5;
int i = 5;
while( i < YEARS)
{
a[i] = a[i-1] + a[i-4];
i++;
}
return a[i-1];
}
这个还不是最简单的，因为我相信应该可以通过数学直接把答案推出来．

public static long GetCowAmout(int year)
{
long[] result = new long[year];

for (int i = 0; i < year; i++)
{
result[i] = i < 3 ? 1 : result[i - 1] + result[i - 3];
}

return result[year - 1];
}
hehe,我也来凑凑热闹

第01年（共01头牛）：1
第02年（共01头牛）：0
第03年（共01头牛）：0
第04年（共02头牛）：1
第05年（共03头牛）：1 0
第06年（共04头牛）：1 0 0
第07年（共06头牛）：1 1 0 0
第08年（共09头牛）：1 1 1 0 0 0
第09年（共13头牛）：1 1 1 1 0 0 0 0 0
第10年（共19头牛）：1 1 1 1 1 1 0 0 0 0 0 0 0
第11年（共28头牛）：1 1 1 1 1 1 1 1 1 0 0 0 0
第12年（共41头牛）：1 1 1 1 1 1 1 1 1 1 1 1 1
第13年（共60头牛）：1 1 1 1 1 1 1 1 1 1 1 1 1
第14年（共88头牛）：1 1 1 1 1 1 1 1 1 1 1 1 1

public int NumNiu(int year)
{
int all = year / 4;
if (all == 0)
return 1;
return NumNiu(year - 4) + NumNiu(year - 1);
}

一是全部,二是计算总共生了多少
public int NumNiu(int year)
{
int all = (year-1) / 3;
if (all == 0)
return 1;
return NumNiu(year - 3) + NumNiu(year - 1);
}
public int NumNiu2(int year)
{
int life = 0;
int all = (year-1) / 3;
if (all > 0)
{
life = year - 3;
for (int i = 4; i < year+1; i++)
{
life += NumNiu2(i - 3);
}
}
return life;
}

算法是不是有问题?
我怎么算出来 20年过后,总共有345头牛.

@白杨
20年是872

呵呵，我和#42楼算得一样。
这是一个变形的Fibonacci数列。
首先，要分清楚第一年和1年后是不同的。第一年等于0年后，所以条件是4年后即第五年生一只小牛。
注意，这个条件理解不一样可是会得出不同的结果的。
设n年后，牛共有S(n)头则可以推出:S(n）=S(n-1)+S(n-4)。
详细的推导过程可以看看的我的blog，欢迎指教

递归和递推算法：
程序实现(递归算法)：
//y指y年后小牛个数
public static int getCount(int y)
{
if (y < 4)
{
return 1;
}
else
{
return getCount(y - 1) + getCount(y - 4);
}
}

递推算法：
//递推算法,y指y年后小牛个数
public static int getCountEasy(int y)
{
int[] a = new int[5] { 1, 1, 1, 1,0 };
if (y < 4)
{
return 1;
}
else
{
for (int i = 4; i < y+1; i++)
{
a[4] = a[3] + a[0];
a[0] = a[1];
a[1] = a[2];
a[2] = a[3];
a[3] = a[4];
}
return a[4];
}
}

本人不太应用算法，所以对算法的题都不太会用，学习了。
人老了，脑袋不好用了，偶尔用算法来练练脑子，可以防止早衰。呵呵
有同感啊。