C++编程,小白鼠问题

[kingtoucher]

有一家生化所，一月份引入一对新生的小白鼠。这对小白鼠生长两个月后，在第三、第四、第五个月各繁殖一对新小白鼠，在第六个月停止繁殖，在第七个月则死亡。新生的小白鼠也如此繁殖。问在第N个月时，活的小白鼠有多少对？

谁帮我说说思路,把问题具体化一些,我想不出思路,很乱感觉.....能给我代码就更好了,谢谢

[lyj2009]

#include <stdio.h>

int main(int argc, char *argv[])
{
	
	unsigned int New[10] = {0,0,0,0,0,0,0,0,0,0};
	unsigned int Sum[2] = {0,0};
	int i;
	New[0] = 1;
	Sum[0] = 1;
	printf("%d \n\r",1);
	for(i = 1;i <20;i++)
	{
		New[(i&7)] = New[((i-2)&7)] + New[(i-3)&7] + New[((i-4)&7)];
	    Sum[(i&1)] = Sum[(i-1)&1] + New[(i&7)] - New[((i-6)&7)];
		printf("%d \n\r",Sum[(i&1)]);	
	}

	return 0;
}

[WZZZ123]

用递归解决

[lyj2009]

如果新生一对的话，
New[(i&7)] = （New[((i-2)&7)] + New[(i-3)&7] + New[((i-4)&7)]）* 2;

[lyj2009]

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

用递归解决
[/Quote]
为什么要用递归。我这个方法效率也不错，也不占内存。

[muyi66]

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

C/C++ code
#include <stdio.h>

int main(int argc, char *argv[])
{

unsigned int New[10] = {0,0,0,0,0,0,0,0,0,0};
unsigned int Sum[2] = {0,0};
int i;
New[0] = 1;
Sum[0] = 1;
……
[/Quote] Sum[0]=New[0] = 2;
从一对开始，这样就可以了。写成8楼那样会多出一倍来。
另一个方法是在输出时再加倍，也能正确表达。

[cbzjzsb123]

[lyj2009]

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

比斐波那契的兔子问题复杂了很多：

新出生的数量 New[i]=New[i-2]+New[i-3]+New[i-4]
第i月的总数 Sum[i]=Sum[i-1]+New[i]-New[i-6]

相比之下斐波那契的算法简单太多了。
[/Quote]
我主要是用了3楼的思路，写成8楼是错了。

我很好奇怎么用递归解决这个问题。

求递归代码。

[muyi66]

递归会有两种不同的方式，不过我觉得都不如迭代好。这个问题真不适合用递归。

[kingtoucher]

还有高手没?来帮忙啊

[byijie]

3个数a,b,c分别代表总数，不可进行繁殖数，死亡数
分别初始化为2，2，2
分情况1-5月
不考虑不可进行繁殖数及死亡数，对总数进行累加
从第6月开始，考虑不可繁殖数，并从总数中减去不可繁殖数后乘以二，积累到总数中，不可繁殖数自乘2
从第7月开始，考虑死亡数，并从总数中减去死亡数并赋值，从总数中减去不可繁殖数后乘以2，积累到总数中，不可繁殖数自乘2，死亡数自乘2。


我就是按时间顺序考虑的，不知道我对题目的理解正确不？

[某大一菜鸟]

这个问题果断不可能用递归做，时间复杂度不允许..

[Fergon]

还是递归舒服些吧。

template<const int N>
int mouse()
{


return mouse<N-1>() + mouse<N-2>() - mouse<N-5>();

}

template<>
int mouse<0>(){
return 1;
}

template<>
int mouse<1>(){
return 1;
}

template<>
int mouse<2>(){
return mouse<1>()+1 ;
}
template<>
int mouse<3>(){
return mouse<2>()+1;

}
template<>
int mouse<4>(){

//除了昨天新生的baby不会生子，其它的都会在今天生。
//因为 昨天的baby = mouse<3>() - mouse<2>();所以今天总数为 mouse<3>() *2 - (mouse<3>() - mouse<2>() );
//化简为
return mouse<3>() +mouse<2>();
}

template<>
int mouse<5>(){
return mouse<4>() + mouse<3>() - 1; //一个绝育了。
}

template<>
int mouse<6>(){
return mouse<5>() + mouse<4>() - 1 - 1; //死掉一个；绝育一个。
}


#include <iostream>

int main(){

const int n = 18;
std::cout <<std::endl<< n << "月份存活数："
<<mouse<n-1>() ;

}

[Fergon]

template<const int N>
int mouse()
{
	
	
	return  mouse<N-1>()  + mouse<N-2>() - mouse<N-5>();
	
}

template<>
int mouse<0>(){
	return 1;
}

template<>
int mouse<1>(){
	return 1;
}

template<>
int mouse<2>(){
	return  mouse<1>()+1 ; 
}
template<>
int mouse<3>(){
	return  mouse<2>()+1; 
	
}
template<>
int mouse<4>(){
	
	//除了昨天新生的baby不会生子，其它的都会在今天生。
	//因为  昨天的baby = mouse<3>() - mouse<2>();所以今天总数为 mouse<3>() *2 - (mouse<3>() - mouse<2>() );
        //化简为
	return  mouse<3>() +mouse<2>(); 
}

template<>
int mouse<5>(){
	return  mouse<4>() + mouse<3>() - 1; //一个绝育了。
}

template<>
int mouse<6>(){
	return  mouse<5>() + mouse<4>() -  1 - 1; //死掉一个；绝育一个。
}


#include <iostream>

int main(){
	
	const int n = 18;
	std::cout <<std::endl<< n << "月份存活数："  
                      <<mouse<n-1>()  ;	
	
}

[ken_scott]

思路：
第N个月的对数 就是 第N-1月时 1-5个月（当时的1-5）的对数 加上 下一个月就要出生的，而当时6个月的会在这个月死亡，故不用考虑
代码:

#include <cassert>
#include <vector>
#include <iostream>
using namespace std;

int get_count(int n);

class pairs_state /* sigleton */
{
private:
    pairs_state()
    {
        count_of_month[0] = 1; /* sum */
        count_of_month[1] = 1;
        count_of_month[2] = 0;
        count_of_month[3] = 0;
        count_of_month[4] = 0;
        count_of_month[5] = 0;
        count_of_month[6] = 0;
        count_of_month[7] = 0; /* alive for 7 months, always 0 */
    }
    
    pairs_state & operator ++ ()
    {
        int count_of_birth = count_of_month[2]; 
        count_of_birth += count_of_month[3];
        count_of_birth += count_of_month[4];
        
        count_of_month[0] = 0;
        for (int i = 6; i > 1; --i) {
            count_of_month[i] = count_of_month[i-1];
            count_of_month[0] += count_of_month[i];
        }
        count_of_month[1] = count_of_birth;
        count_of_month[0] += count_of_month[1];
    }
    
    int sum() const
    {
        return(count_of_month[0]);
    }
    
    friend int get_count(int);
    
private:
    pairs_state(const pairs_state &);
    pairs_state & operator = (const pairs_state &);

private:
    int count_of_month[8];
};

int get_count(int n)
{
    assert(n > 0);
    
    static pairs_state state;
    static vector<int> count;
    
    for (int i = count.size(); i < n; ++i) {
        count.push_back(state.sum());
        ++state;
    }
    
    return(count[n-1]);
}

int main(void)
{
    for (int i = 10; i > 0; --i) {
        cout << "month " << i << ", pairs: " << get_count(i) << endl;
    }
    return(0);
}

另外, 我把它写到我的博客上去了, :-)

[ken_scott]

居然为个算法写了个类, 头一次, 汗...

[Fergon]

用模板看得就眼花，这个好多了：

#include <iostream>
int mouse(int m){
	return 
		m <= 0 ? 0
	                    : m == 1 || m ==2 ? 1
	                                                : m==7 ? mouse(m-1)+mouse(m-2)- 2
							           :  mouse(m-1)+mouse(m-2) - mouse(m-5);
	
}

int main(){
	const int month = 10;
	std::cout << month <<"月份存活数： "<<mouse(month);
}

[kobemadi]

楼上的写得很清晰啊，厉害

[不住隔壁的老王]

呵呵 17L 牛人

[setidfine]

递归啦

[某大一菜鸟]

现提供一个算法，时间复杂度为O(n):

1. 首先定义一个RabbitSet结构，包含成员LifeTime（表示剩余生存月数，初始为7）,N(对数)。这个结构是同一月出生的N对兔子的抽象集合

2.
funtion Counter(TotalMonth)
新建一个链表List
新建一个RabbitSet对象FirstRabbit
List.pushback(FirstRabbit)

while(TotalMonth > 0)
新建一个RabbitSet对象ThisRabbitSet
对List内LifeTime满足生育条件的RabbitSet对象，读取其数据成员N，使ThisRabbit.N += N；遍历的同时使各RabbitSet的LifeTime自减
从List头部清出List中LifeTime为0的RabbitSet
List.pushback(ThisRabbitSet)

最后遍历List,求出各RabbitSet对象的N值的总和即可