【动态规划专题】1：斐波拉契数列问题的递归和动态规划

《程序员代码面试指南--IT名企算法与数据结构题目最优解》 左程云 著

斐波拉契数列问题的递归和动态规划

【题目】：
给定整数N,返回斐波拉契数列的第N项。
补充问题1：给定整数N，代表台阶数，一次可以跨2个或者1个台阶，返回有多少种走法。
补充问题2：假设农场中成熟的母牛每年只会生产1头小母牛，并且永远不会死。第一年农场只有1只成熟的母牛，
从第2年开始，母牛开始生产小母牛。每只小母牛3年后成熟又可以生产小母牛。给定整数N，求出N年后牛的数量。

【举例】
斐波拉契数列
f(0)=0, f(1)=1,f(2)=f(1)+f(0),f(3)=f(2)+f(1),
f(N)=f(N-1)+f(N-2) ///后一项是前两项之和

【举例】
青蛙跳台阶：
N=1，1种跳法
N=2，2种跳法
如果台阶N级，最后跳上第N级的情况，要么是从N-2台阶直接跨2级台阶，要么是从N-1级台阶跨1级台阶。
所以台阶有N级的方法为 f(N-2) + f(N-1)

【举例】
母牛问题：
第1年，a
第2年，a,b //b出生了
第3年，a,b,c
第4年，a,b,c,d
第5年，a,b,c,d, e,[b‘] //b成熟了
第6年，a,b,c,d,e,[b‘] f, b‘‘, c‘ //c,b成熟了
第N年，S(N) = S(N-1)+S(N-3)

问题进阶：可以用更快的时间复杂度解决问题。
最快可达到O(log(N))，需要用到矩阵乘法、状态矩阵、加速矩阵乘法等等数学知识。
限于本人数学功底薄弱，无法达到这个境界，看不懂。这里只是提出来。

#include <iostream>
#include <stack>
#include <exception>
using namespace std;
////时间复杂度是O(2^N)，指数级的，不推荐
int fibnac(int n)
{
if (n < 0)
{
throw new std::exception("Invalid para");
return -1;
}
if (n == 0)
{
return 0;
}
if (n <= 2)
{
return 1;
}

return fibnac(n - 1) + fibnac(n - 2);
}
//改进后的算法。时间复杂度为O(N)。减少重复的计算。
//自下而上分析，自上而下解决。递归的思路分析，循环的思路写代码。
unsigned long long fibnac2(int n)
{
if (n < 0)
{
throw new std::exception("Invalid para");
}
unsigned long long *fibNums = new unsigned long long[n + 1];
fibNums[0] = 0;
fibNums[1] = 1;
fibNums[2] = 1;
fibNums[3] = 2;
for (unsigned long long i = 2; i <= n; i++)
{
fibNums[i] = fibNums[i - 1] + fibNums[i - 2];
}
return fibNums[n];
}
////时间复杂度O(N)
////如果想节约内存空间，可以只声明3个变量来存储计算结果，进行累加计算
unsigned long long fibnac3(int n)
{
if (n < 0)
{
throw new std::exception("Invalid para");
}
unsigned long long pre = 0;
unsigned long long now = 1;
if (n == 0)
{
return 0;
}
else if (n == 1 || n == 2)
{
return 1;
}

unsigned long long preTemp = 0;
for (int i = 2; i <= n; i++)
{
preTemp = now;
now += pre ;
pre = preTemp;
}
return now;
}
////时间复杂度O(N)
////青蛙跳台阶，利用临时变量累加
unsigned long long jump(int n)
{
if (n < 0)
{
throw new std::exception("Invalid para");
}
if (n == 0)
{
return 0;
}
if (n <= 2)
{
return n;
}

unsigned long long llPre1 = 1;//n==1
unsigned long long llNow = 2;//n==2

unsigned long long llTemp = 0;
for (int i = 3; i <= n; i++)//n>=3
{
llTemp = llNow;

llNow += llPre1;//n>=3

llPre1 = llTemp;
}
return llNow;
}
////时间复杂度O(N)
////青蛙跳台阶，利用数组实现累加（理解更方便，但是需要一定的额外内存空间）
unsigned long long jump2(int n)
{
if (n < 0)
{
throw new std::exception("Invalid para");
}
if (n == 0)
{
return 0;
}
if (n <= 2)
{
return n;
}

unsigned long long *jumpArr = new unsigned long long[n + 1];
jumpArr[0] = 0;
jumpArr[1] = 1;
jumpArr[2] = 2;

for (int i = 3; i <= n; i++)//n>=3
{
jumpArr[i] = jumpArr[i-1] + jumpArr[i-2];
}

return jumpArr[n];
}
////时间复杂度O(N)
///母牛产子问题
unsigned long long cowBron(int n)
{
if (n < 0)
{
throw new std::exception("Invalid para");
}
if (n == 0)
{
return 0;
}
else if (n == 1 || n == 2 || n==3)
{
return n;
}
unsigned long long llprepre = 1;
unsigned long long llpre = 2;
unsigned long long llRes = 3;

unsigned long long lltemp1 = 0;
unsigned long long lltemp2 = 0;
for (int i = 4; i <= n; i++)
{
lltemp1 = llpre;
lltemp2 = llRes;

llRes = llRes + llprepre;

llprepre = lltemp1;
llpre = lltemp2;
}
return llRes;
}
////时间复杂度O(N)
///母牛产子问题
unsigned long long cowBron2(int n)
{
if (n < 0)
{
throw new std::exception("Invalid para");
}
if (n == 0)
{
return 0;
}
else if (n == 1 || n == 2 || n == 3)
{
return n;
}

unsigned long long *llcowCounts = new unsigned long long[n + 1];
llcowCounts[0] = 0;
llcowCounts[1] = 1;
llcowCounts[2] = 2;
llcowCounts[3] = 3;

for (int i = 4; i <= n; i++)
{
llcowCounts[i] = llcowCounts[i - 1] + llcowCounts[i - 3];
}

return llcowCounts[n];
}
//==========================测试用例====================================
void test1()
{
cout << fibnac(0) << endl;;
cout << fibnac(1) << endl;;
cout << fibnac(2) << endl;;
cout << fibnac(10) << endl;;
cout << fibnac(100) << endl;;

//cout << fibnac(-5) << endl;;
}

void test2()
{
cout << fibnac2(0) << endl;
cout << fibnac2(1) << endl;
cout << fibnac2(2) << endl;
cout << fibnac2(10) << endl;
cout << fibnac2(11) << endl;
cout << fibnac2(12) << endl;
cout << fibnac2(50) << endl;///数字太大越界了

//    cout << fibnac2(-5) << endl;
}

void test3()
{
cout << "----------------test3-------------------" << endl;
cout << 0<<": "<<jump(0) << endl;
cout << 1 << ": " << jump(1) << endl;
cout << 2 << ": " << jump(2) << endl;
cout << 3 << ": " << jump(3) << endl;
cout << 4 << ": " << jump(4) << endl;
cout << 5 << ": " << jump(5) << endl;
cout << 14 << ": " << jump(14) << endl;
cout << 15 << ": " << jump(15) << endl;
cout << 16 << ": " << jump(16) << endl;

cout << "-----------jump2-----------" << endl;

cout << 0 << ": " << jump2(0) << endl;
cout << 1 << ": " << jump2(1) << endl;
cout << 2 << ": " << jump2(2) << endl;
cout << 3 << ": " << jump2(3) << endl;
cout << 4 << ": " << jump2(4) << endl;
cout << 5 << ": " << jump2(5) << endl;
cout << 14 << ": " << jump2(14) << endl;
cout << 15 << ": " << jump2(15) << endl;
cout << 16 << ": " << jump2(16) << endl;
}

void test4()
{

cout << "----------------test4-------------------" << endl;
cout << 0 << ": " << cowBron(0) << endl;
cout << 1 << ": " << cowBron(1) << endl;
cout << 2 << ": " << cowBron(2) << endl;
cout << 3 << ": " << cowBron(3) << endl;
cout << 4 << ": " << cowBron(4) << endl;
cout << 5 << ": " << cowBron(5) << endl;
cout << 6 << ": " << cowBron(6) << endl;
cout << 7 << ": " << cowBron(7) << endl;
cout << 8 << ": " << cowBron(8) << endl;
cout << 9 << ": " << cowBron(9) << endl;
cout << 14 << ": " << cowBron(14) << endl;
cout << 15 << ": " << cowBron(15) << endl;
cout << 16 << ": " << cowBron(16) << endl;

cout << "-----------cowBron2-----------" << endl;
cout << 0 << ": " << cowBron2(0) << endl;
cout << 1 << ": " << cowBron2(1) << endl;
cout << 2 << ": " << cowBron2(2) << endl;
cout << 3 << ": " << cowBron2(3) << endl;
cout << 4 << ": " << cowBron2(4) << endl;
cout << 5 << ": " << cowBron2(5) << endl;
cout << 6 << ": " << cowBron2(6) << endl;
cout << 7 << ": " << cowBron2(7) << endl;
cout << 8 << ": " << cowBron2(8) << endl;
cout << 9 << ": " << cowBron2(9) << endl;
cout << 14 << ": " << cowBron2(14) << endl;
cout << 15 << ": " << cowBron2(15) << endl;
cout << 16 << ": " << cowBron2(16) << endl;

}

int main()
{
//test1();
test2();
test3();
test4();

system("pause");
return 0;
}

原文地址：https://www.cnblogs.com/music-liang/p/12053847.html

时间： 2024-12-15 01:42:48

【动态规划专题】1：斐波拉契数列问题的递归和动态规划的相关文章

Fibonacci斐波拉契数列----------动态规划DP

n==10 20 30 40 50 46 体验一下,感受一下,运行时间 #include <stdio.h>int fib(int n){ if (n<=1)     return 1; else            return fib(n-1)+fib(n-2); }int main( ){ int n; scanf("%d",&n); printf("%d\n" ,fib(n) );} 先 n==10 20 30 40 50 46

斐波拉契数列加强版——时间复杂度O(1)，空间复杂度O(1)

对于斐波拉契经典问题,我们都非常熟悉,通过递推公式F(n) = F(n - 1) + F(n - 2),我们可以在线性时间内求出第n项F(n),现在考虑斐波拉契的加强版,我们要求的项数n的范围为int范围内的非负整数,请设计一个高效算法,计算第n项F(n).第一个斐波拉契数为F(0) = 1. 给定一个非负整数,请返回斐波拉契数列的第n项,为了防止溢出,请将结果Mod 1000000007. 斐波拉契数列的计算是一个非常经典的问题,对于小规模的n,很容易用递归的方式来获取,对于稍微大一点的n,为

青蛙跳台阶问题-斐波拉契数列

题目1:一个台阶总共有n级,如果一次可以跳1级,也可以跳2级.求总共有多少种跳法 首先我们考虑最简单的情况,加入只有1级台阶,那显然只有一种跳法,如果有2级台阶,那就有两种跳的方法了:一种是分两次跳,每次跳1级:另外一种就是一次跳2级 现在我们来讨论一般情况.我们把n级台阶时的跳法看成是n的函数,记为f(n).当n>2时,第一次跳的时候就有两种不同的选择:一是第一次只跳1级,此时跳法数目等于后面剩下的n-1级台阶的跳法数目,即为f(n-1):另外一种选择是第一次跳2级,此时跳法数目等于后面剩下的

浅谈C#中的斐波拉契数列

突然对那些有趣的数学类知识感兴趣了,然后就简单研究了一下斐波拉契数列,看看它的有趣之处! 斐波拉契数列(Fibonacci Sequence),又称黄金分割数列,该数列由意大利的数学家列奥纳多·斐波那契发现的.这种数列指的是这样一个数列:0.1.1.2.3.5.8.13.21. 34.--在数学上,斐波纳契数列以如下被以递归的方法定义:F(0)=0,F(1)=1,F(n)=F(n-1)+F(n-2)(n≥2,n∈N*). 用C#实现斐波拉契数列的代码: Console.Write("请输入一个长

在c#中编写斐波拉契数列程序

思路:首先因为输出的是一个数列,又因为不定长,所以要见一个集合来装数列,其次确定第一个数和第二个数都为1,然后根据斐波拉契数列的特点,确定是一个循环语句,再根据从第三位开始,每个数字都是前两个数的和的特点写出代码.代码如下: while(true){Console.Write("请输入斐波拉契数列的长度:");int len = int.Parse(Console.ReadLine());int[] array = new int[len];if (len < 3){Consol

斐波拉契数列的计算方法

面试题9.斐波拉契数列 题目: 输入整数n,求斐波拉契数列第n个数. 思路: 一.递归式算法: 利用f(n) = f(n-1) + f(n-2)的特性来进行递归,代码如下: 代码: long long Fib(unsigned int n) { if(n<=0) return 0; if(n==1) return 1; return Fib(n-1) + Fib(n-2); } 缺陷: 当n比较大时递归非常慢,因为递归过程中存在很多重复计算. 二.改进思路: 应该采用非递归算法,保存之前的计算结

斐波拉契数列问题

古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少? package Test; /** * 斐波拉契数列问题(兔子问题) * 可推导递推公式 * f(n+1)=f(n)+f(n-1) * */ public class FibonacciNumeral { public static void main(String[] args) { System.out.println("第一个月的兔子为1"

c语言：写一个函数，输入n，求斐波拉契数列的第n项（5种方法，层层优化）

写一个函数,输入n,求斐波拉契数列的第n项. 斐波拉契数列:1,1,2,3,5,8...,当n大于等于3时,后一项为前面两项之和. 解:方法1:从斐波拉契数列的函数定义角度编程 #include<stdio.h> int fibonacci(int n) { int num1=1, num2=1, num3=0,i; if (n <= 2) { printf("斐波拉契数列的第%d项为:%d\n",n,num1); } else { for (i = 2; i <

c语言：编辑程序实现斐波拉契数列：1,1,2,3,5,8...;后一项为前面两项之和

程序: //斐波拉契数列:1,1,2,3,5,8... //f(n)={[(1+5^0.5)/2]^n - [(1-5^0.5)/2]^n}/(5^0.5) #include<stdio.h> int main() { int i=0, n = 0; int num1 = 1; int num2 = 1; int num3 = 0; scanf("%d", &n); if (n <= 2) { printf("%d\n", num1); }