经典的农夫养牛问题（常考的面试题）

[tpshowcom]

一个农夫养了一头牛，三年后，这头牛每年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢？（用JAVA实现）
很有名的一道题，11楼放出最经典的两种解题思路，大家先试试

[jing43]

634楼，你的计算结果为28，不是正确的55

[jing43]

634楼，不好意思，我理解错了，你的是对的。

[cs277241073]

学习了

[blues_leaf]

import java.util.ArrayList;
import java.util.List;

public class Cow {
private int age;

void grow() {//成长
age ++;
}

Cow birth() {//生小牛
return age>=2 ? new Cow() : null;
}

public static void main(String[] args) {
System.out.println(count(10));
}

private static int count(int n) {
List<Cow> cows = new ArrayList<Cow>();
Cow motherCow = new Cow();//第一头奶牛
cows.add(motherCow);
for(int j=0; j<n; j++) {
for(int i=0; i<cows.size(); i++) {
Cow c = cows.get(i);
Cow newCow = c.birth();
if(newCow != null)
cows.add(newCow);
c.grow();
}
}
return cows.size();
}

}

使用了面向对象的思想求解

[zixijack]

就是垃圾绯闻数组！

[zhouxuelong1]

学习学习先

[ma2553047]

[Quote=引用 39 楼 joewa718 的回复:]

class TestNiu
{

public static int niu(int n)
{
int num=0;
if(n<3)
{
return n=1;
}
else
{
num=niu(n-1)+niu(n-2);
return num;

}
}
public static void main(String[] args)
{
int num1=……
[/Quote]
就觉得这个事经典的递归

[昨天与今天]

package org.lkm.test;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 
 */
public class c {

	private int age = 0;

	/**
	 * 是否可以生产小牛
	 * 
	 * @return True | False
	 */
	public boolean isCreatSmallCow() {
		return (age >= 3) ? true : false;
	}

	/**
	 * 过年了，年龄又大了一岁
	 */
	public void addYear() {
		age++;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		List<c> cowList = new ArrayList<c>();
		// 第一头小牛
		cowList.add(new c());
		int yearCount = 10;
		// 就这样一年年过
		for (int i = 1; i <= yearCount; i++) {
			int rowNum = cowList.size();
			for (int j = 0; j < rowNum; j++) {
				c o = cowList.get(j);
				// 过年了
				o.addYear();
				// 能生小牛吗？
				if (o.isCreatSmallCow()) {
					cowList.add(new c());
				}
			}
		}
		System.out.println(yearCount + "年后将有【" + cowList.size() + "】头牛。");
	}
}

[BigNippleBoy]

十楼面向对象的思想最好理解,呵呵

[wangsen2235068]

其实，答案不是28，应该是19才对。11年才 是28

[wangsen2235068]

额，28是对的，10年后，相当于第11年

[灰色小狼]

哈哈不错啊，我也贴一个

import java.util.Scanner;


/**
 * 
 * @author [e-mail] 
 */
public class Cows {
	private static void forEachYear(int[] waitYears) {
		int[] cows = waitYears.clone();
		
		waitYears[cows.length-1] = cows[0];
		waitYears[0] = cows[0] + cows[1];
		
		for (int i=cows.length-2; i>0; i--)
			waitYears[i] = cows[i+1];
	}
	
	public static void main(String[] args) {
		int waitYears[] = {0, 0, 1};
		System.out.print("input years: ");
		Scanner scanner = new Scanner(System.in);
		
		try {
			int year = scanner.nextInt();
			int counts = 0;
			
			for (int i=1; i<=year; i++)
				forEachYear(waitYears);
			for (int i=0; i<waitYears.length; i++)
				counts += waitYears[i];
			System.out.println("cows: " + counts);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

[m安然]

[Quote=引用 623 楼 stillback 的回复:]

用递归.....
f(n)
{
if(n==1||n==2)
return 1
else
return f(n-2)+f(n-1)
}
[/Quote]
同学 , 答案是28

[指尖上的行者]

学习啦，面试了这么多家公司，我还真没遇到过这个问题，不过，类似的好像有一次笔试过，结果不记得啦

[maliang18]

数组做的

int[] ii = { 0, 0, 1 };
System.out.println("第1年1頭；");
for (int i = 2; i < 11; i++) {
ii[0] = ii[0] + ii[1];
ii[1] = ii[2];
ii[2] = ii[0];
int k = ii[0] + ii[1] + ii[2];
System.out.println("第" + i + "年" + k + "頭；");
}

[heartdance]

这个题我做过了

[wuyoutianxia2]

//55把我误导了 看来还是我是正确的
    /**
     * 一个农夫养了一头牛，三年后，这头牛每年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢？（用JAVA实现）
     * 首先鄙视一下牛不死现象和公牛产子现象
     * @param str
     */
    public static void main(String[] str)
    {
        
       System.out.println(process(1,10));
        
    }
    
    public static int process(int initCount,int year)
    {
        int zeroYearsOld = initCount;       //刚出生的牛 初始化为1
        int oneYearsOld = 0;                //1岁的 数量
        int towYearsOld = 0;                //2岁的数量
        int ripeCount = 0;                  //成熟的,可以无性繁殖的数量
        int max = initCount;                //总数
        
        for(int i=0;i<year;i++)
        {
            int temp = towYearsOld;         //今年牛成熟的数量
            towYearsOld = oneYearsOld;      //牛长大一岁
            oneYearsOld = zeroYearsOld;     //牛长大一岁
            ripeCount += temp;              //成熟数量加上今年成熟的
            max +=ripeCount;                //所有成熟的牛都会生一个,所以原来牛群数量加上成熟牛的数量等于现在数量
            zeroYearsOld = ripeCount;       //刚出生的牛
            
            System.out.println("第"+(i+1)+"年:牛的数量为"+max+"头，新增"+zeroYearsOld+"头");
        }
        
        return max;
    }

结果：
第1年:牛的数量为1头，新增0头
第2年:牛的数量为1头，新增0头
第3年:牛的数量为2头，新增1头
第4年:牛的数量为3头，新增1头
第5年:牛的数量为4头，新增1头
第6年:牛的数量为6头，新增2头
第7年:牛的数量为9头，新增3头
第8年:牛的数量为13头，新增4头
第9年:牛的数量为19头，新增6头
第10年:牛的数量为28头，新增9头

[bosslichuan]

学习了，很不错的。。经典。。

[xxzf426214]

[Quote=引用 37 楼 withoutme_hw 的回复:]
算法时间和空间复杂度均为O(n),n为年数，是一个动态规划算法

Java code


public class CowBreed
{
public static void main(String args[])
{
final int size = 100; //可以根据需要，设置为所需要计算的最大年限
……
[/Quote]简单实用，推荐

[Daniel2081]

1 1 1 2 3 4 6 9 13 19 28...
斐波那契数列的变种
3=1+1+1;
4=1+1+2;
6=1+2+3;
9=2+3+4;

cows[i]=cows[i-4]+cows[i-3]+cows[i-2];

java代码如下

int[] cows= new int[20];
cows[0]=cows[1]=cows[2]=1;
cows[3]=2;
for (int i = 4; i < cows.length; i++) {
	cows[i]=cows[i-4]+cows[i-3]+cows[i-2];
}
for (int i = 0; i < cows.length; i++) {
	System.out.print(cows[i]+" ");
}