一道杭电的ACM 题 求助

[fx397993401]

这是一道ACM 的题目http://acm.hdu.edu.cn/showproblem.php?pid=2018 可以进取查看原题 名为母牛的故事
有一头母牛，它每年年初生一头小母牛。每头小母牛从第四个年头开始，每年年初也生一头小母牛。请编程实现在第n年的时候，共有多少头母牛？

#include <stdio.h>
#include <stdlib.h>
#include<math.h>
#include<conio.h>
int main()
{
	int n,i = 0,count = 0,t = 0;
	int *num;//每年出生的牛数
	int *sum;//每年末的总数
	int year[100] = {2,4,5,6,7};
	/* do
	{
		scanf("%d",&year[i]);
		if(year[i] ==0)
			break;
		if(i < year[i])
			n = year[i];
	}while(1); */
	n = 5;//用来测试 的
	num = (int*)calloc(n,sizeof(int));
	sum = (int*)calloc(n,sizeof(int));

	//num[0] = 0;
	num[0] = 1;//0 此时即为母牛 
	//count += n;//母牛所生的牛 再加上自己
	for(i = 1; i < n; i ++)
	{
		if(i > 3)
		{
			t = i -3;
			while(t>=0)
			{
				num[i] += num[t--] ;
			}
		}
		else 
			num[i] = 1;
	}
	//计算每年年末的奶牛数 从题意好像第N 年 算出的是第 N-1年末的数目 第n年 中 n-3(包含） 年之前出生的牛 都可以在这一年生出小牛 
	for(i = 1; i < n ; i ++)
	{
		t = i ;
		if(t-3>0)
			sum[i] = sum[t-3]*4 + num[i] +num[i-1] + num[i-2] ;
		else 
			while(t >=0)
				sum[i] += num[t --]; 
	}
	for(i = 0; year[i]; i ++)
		printf("%d\n",sum[year[i]-1]);
	
	

	getch();
	return 0;
}

[ForestDB]

n阶的F数列
1, 1, 2, 3, 5, ...这个的一般情况。

[cy2005abc]

int fin(int n)
{
if n<=0 then return 0;
if n==1 then return 1;
n=n-1;
return fin(n-1)+fin(n-4);
}

void main()
{
int n,m;
scanf("%d",&n);
m=0;
m=fin(n);
printf("%d",m);
}

[cy2005abc]

上面有错
int fin(int n)
{
if n <=0 then return 0;
if n==1 then return 1;

return fin(n-1)+fin(n-4);
}

void main()
{
int n,m;
scanf("%d",&n);
m=0;
m=fin(n);
printf("%d",m);
}

[DespairingShaver]

12楼的程序中for循环 i<nYear 如果我输入的年是2那么只循环1次，只计算了第一年是牛数。
我觉得改成 i <= nYear比较好吧

[扛一肩记忆]

[Quote=引用 15 楼 DespairingShaver 的回复:]
12楼的程序中for循环 i <nYear 如果我输入的年是2那么只循环1次，只计算了第一年是牛数。
我觉得改成 i <= nYear比较好吧
[/Quote]
又没关系的，那个母牛要到第四年才生呢，

[扛一肩记忆]

噢，不好意思，不对，一旦是母牛了，就要连续每年都生了，恩，是要<=的

[fireseed]

不知道你们为什么都要写那么长的代码。算法很简单，但不知道这样的代码是否附合要求？
用纯C写的，在C++环境下编译C比较麻烦……

// 算法：母牛的故事
// 刚生下的奶牛计为0岁，2岁过完，到3岁开始生小牛。
// 用4个元素的数组存放母牛的数量。第0，1，2三个元素存放0-2岁的奶牛数量，
// 第3个元素存放4岁及以上的奶牛（可生育）数量。循环指定的年数，
// 每年处理增加奶牛的年龄及刚出生奶牛的数量。
#include <stdio.h>
int main()
{
	int nCow[4], i, nBorn, nYears = 1;
	while ( nYears != 0 )
	{	// 输入年数
		scanf( "%d", &nYears );
		for ( nCow[0] = nCow[1] = nCow[2] = 0, nCow[3] = 1,
			i = 1; i < nYears; ++i )
		{	// 循环指定的年数
			nCow[3] += nCow[2];	// 将2岁过完的奶牛加入生育组
			nBorn = nCow[3];	// 计算这一年生育的奶牛数
			nCow[2] = nCow[1];	// 1岁组数量存入2岁组
			nCow[1] = nCow[0];	// 0岁组数量存入1岁组
			nCow[0] = nBorn;	// 新出生的小牛
		}
		if ( nYears )	// 打印输出
			printf( "%d\n", nCow[0] + nCow[1] + nCow[2] + nCow[3] );
	}
	return 0;
}

[fireseed]

如果是要批量输入输出的话，代码如下：

// 算法：母牛的故事
// 刚生下的奶牛计为0岁，2岁过完，到3岁开始生小牛。
// 用4个元素的数组存放母牛的数量。第0，1，2三个元素存放0-2岁的奶牛数量，
// 第3个元素存放4岁及以上的奶牛（可生育）数量。循环指定的年数，
// 每年处理增加奶牛的年龄及刚出生奶牛的数量。
#include <stdio.h>
int main()
{
	int nCow[4], i, nBorn, nYears[60] = { 1, };
	for ( i = 0; i < 60 && nYears[ i - 1 ] != 0; ++i )
		scanf( "%d", &nYears[i] );	// 批量输出
	for ( i = 0; nYears[i] != 0; ++i )
	{	// 批量计算每个输入的年数
		for ( nCow[0] = nCow[1] = nCow[2] = 0, nCow[3] = 1;
			nYears[i] > 1; --nYears[i] )
		{	// 循环指定的年数
			nCow[3] += nCow[2];	// 将2岁过完的奶牛加入生育组
			nBorn = nCow[3];	// 计算这一年生育的奶牛数
			nCow[2] = nCow[1];	// 1岁组数量存入2岁组
			nCow[1] = nCow[0];	// 0岁组数量存入1岁组
			nCow[0] = nBorn;	// 新出生的小牛
		}	// 下面打印输出
		printf( "%d\n", nCow[0] + nCow[1] + nCow[2] + nCow[3] );
	}
	return 0;
}

其实还可以更短小的，但是会影响效率。不知道要求是代码最精简还是效率最高？实现是完全不一样的。

[pengzhixi]

mark

[fireseed]

[Quote=引用 15 楼 DespairingShaver 的回复:]
12楼的程序中for循环 i <nYear 如果我输入的年是2那么只循环1次，只计算了第一年是牛数。
我觉得改成 i <= nYear比较好吧
[/Quote]

我也觉得不妥，但按照程序要求，2年的牛数是2。还是按题意来吧

[fireseed]

这样就比较完美了，代码就是要不断的优化！

// 算法：母牛的故事
// 刚生下的奶牛计为0岁，2岁过完，到3岁开始生小牛。
// 用4个元素的数组存放母牛的数量。第0，1，2三个元素存放0-2岁的奶牛数量，
// 第3个元素存放4岁及以上的奶牛（可生育）数量。循环指定的年数，
// 每年处理增加奶牛的年龄及刚出生奶牛的数量。
#include <stdio.h>
int main()
{
	int nCow[4], i, nBorn, nYears[60] = { 1 };
	for ( i = 1; i < 59 && nYears[ i - 1 ] != 0; ++i )
		scanf( "%d", &nYears[i] );	// 批量输入
	for ( i = 0; nYears[++i] != 0; )
	{	// 批量计算每个输入的年数
		nCow[0] = nCow[1] = nCow[2] = 0, nCow[3] = 1;
		while ( nYears[i]-- > 1 )
		{	// 循环指定的年数
			nCow[3] += nCow[2];	// 将2岁过完的奶牛加入生育组
			nBorn = nCow[3];	// 计算这一年生育的奶牛数
			nCow[2] = nCow[1];	// 1岁组数量存入2岁组
			nCow[1] = nCow[0];	// 0岁组数量存入1岁组
			nCow[0] = nBorn;	// 新出生的小牛
		}	// 下面打印输出
		printf( "%d\n", nCow[0] + nCow[1] + nCow[2] + nCow[3] );
	}
	return 0;
}

[fireseed]

[Quote=引用 24 楼 baoxiaopan 的回复:]
这个东西有必要搞那么复杂吗，不就是个递归嘛，很简单的么
[/Quote]

递归是可以，但是效率……

[扛一肩记忆]

这个东西有必要搞那么复杂吗，不就是个递归嘛，很简单的么

/*
有一头小母牛，在他长大的第4年后每一年都生一头小母牛，
它生的小母牛在长大的第4年后每年生一头小母牛，依次类推，
在N年时，母牛的总数是多少？
*/

#include<stdio.h>

int sum_cow(int );

int main()
{
    int year;
    int num;
    printf("please input year : \n");
    scanf("%d", &year);
    num = sum_cow(year);
    printf("num is %d \n", num);
    return 0;
}

int sum_cow(int nyear)
{
    int sum = 0;
    //前四年牛的数量都与年数相等
    if(nyear < 5)
    {
        return nyear;
    }
    else
    {
        //第N年的数量等于前一年原有的数量再加上今年生的小牛的数量
        //今年生的小牛的数量等于今年能生的小牛的数量
        //今年能生小牛的母牛的数量就是四年前母牛的数量
        return sum_cow(nyear - 1) + sum_cow(nyear - 4);
    }
}

[whuyotc]

MARK

[fx397993401]

[Quote=引用 26 楼 fireseed 的回复:]
引用 24 楼 baoxiaopan 的回复:
这个东西有必要搞那么复杂吗，不就是个递归嘛，很简单的么


递归是可以，但是效率……
[/Quote]

敬佩 程序是在不断实践和归纳的情况下 得到提升的 要好好的向你学习啊

[cutrain2009]

好像fubilie数列

[shuizhiyun]

支持高德纳

[jay00]

//Test8


import java.util.Scanner;


public class Test8 {

public static void main(String[] args) {

int cow=1;
int xcow=0;
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
for(int i=1;i<=n;i++){
if(i%4==0){
xcow--;
cow++;
}
xcow+=cow;

}
System.out.println(xcow);
}

}

[ArWen]

这个问题用STL来做,很简单,不需要递归,用两个循环就OK了.
没有检验,随便写了一下.
class cow
{
int FBirthYear; // 出生年份
public:
cow(int year) { FBirthYear = year; }

cow * Product(int year)
{
if( (year - FBirthYear) < 4 ) // 年龄小于4岁，不能生育
return NULL;
cow * daughter = new cow(year); // 在year年生个小母牛
return daughter;
}
}

int main()
{
int totalYear;
printf("please input year : \n"); // 提示输入总年数
scanf("%d", &totalYear);

std::vector<cow *> allCows;
cow * firstCow = new cow(-3); // 第一头母牛出生于4年前，即今年可生产
allCows.push_back(firstCow);
for(int year = 1; year <= totalYear; ++year)
{
for(std::vector<cow *>::iterator * it = allCows.begin(); it != allCows.end(); ++it)
{
cow * newCow = it->Product(year); // 看在第year
if(newCow)
allCows.push_back(newCow);
}
}
int totalCowNumber = allCows.size();
printf("result is %d", totalCowNumber);
return 0;
}

[ArWen]

class cow
{
	int FBirthYear;		// 出生年份
public:
	cow(int year)	{ FBirthYear = year; }
	
	cow * Product(int year)
	{
		if( (year - FBirthYear) < 4 )		// 年龄小于4岁，不能生育
			return NULL;
		cow * daughter = new cow(year);		// 在year年生个小母牛
		return daughter;
	}
}

int main()
{
    int totalYear;
    printf("please input year : \n");			// 提示输入总年数
    scanf("%d", &totalYear);

	std::vector<cow *> allCows;
	cow * firstCow = new cow(-3);		  	// 第一头母牛出生于4年前，即今年可生产
	allCows.push_back(firstCow);
	for(int year = 1; year <= totalYear; ++year)
	{
		for(std::vector<cow *>::iterator * it = allCows.begin(); it != allCows.end(); ++it)
		{
			cow * newCow = it->Product(year);	// 看在第year
			if(newCow)
				allCows.push_back(newCow);
		}
		printf("Year: %d, Cow Number: %d", year, allCows.size());
	}
	return 0;
}