斐波那契

3 月，跳不动了？>>> 用go 求解fib比较效率 go可以求解到45项都很快 package main import ( "fmt" "time" ) func Fib(n int) int { if n < 2 { return n } return Fib(n-1) + Fib(n-2) } func single(size int) (int64, []int) { st := time.Now().Unix() ans := make([]int, size) for i := 0; i < size; i++ { ans[i] = Fib(i) } ed := time.Now().Unix() return ed - st, ans } func FibMul(n int, c chan int) { c <- Fib(n) } func Multiple(size int) (int64, []int) { st := time.Now().Unix() ans := make([]int, size) c := make(chan int, size) for i := 0; i < size; i++ { go FibMul(i, c) } for i := 0; i < size; i++ { ans[i] = <-c } ed := time.Now()

概要 上一章 介绍了斐波那契堆的基本概念，并通过C语言实现了斐波那契堆。本章是斐波那契堆的C++实现。 目录 1. 斐波那契堆的介绍 2. 斐波那契堆的基本操作 3. 斐波那契堆的C++实现(完整源码) 4. 斐波那契堆的C++测试程序 转载请注明出处： http://www.cnblogs.com/skywang12345/p/3659069.html 更多内容： 数据结构与算法系列 目录 (01) 斐波那契堆(一)之 图文解析 和 C语言的实现 (02) 斐波那契堆(二)之 C++的实现 (03) 斐波那契堆(三)之 Java的实现 斐波那契堆的介绍 斐波那契堆(Fibonacci heap)是一种可合并堆 ，可用于实现合并优先队列 。它比二项堆具有更好的平摊分析性能，它的合并操作的时间复杂度是O(1)。 与二项堆一样，它也是由一组堆最小有序树组成，并且是一种可合并堆。 与二项堆不同的是，斐波那契堆中的树不一定是二项树；而且二项堆中的树是有序排列的，但是斐波那契堆中的树都是有根而无序的。 斐波那契堆的基本操作 1. 基本定义 template <class T> class FibNode { public: T key; // 关键字(键值) int degree; // 度数 FibNode<T> *left; // 左兄弟 FibNode<T> *right; //

计算并返回斐波那契（Fibonacci）数列中第n项的值。 Code #include < iostream > using namespace std; int Fibonacci( int ); int Fib( int ); int main() { int n; cin >> n; cout << " 递归：Fibonacci数列的第 " << n << " 项是 " << Fib(n) << endl; cout << " 非递归：Fibonacci数列的第 " << n << " 项是 " << Fibonacci(n) << endl; return 0 ; } // 非递归 int Fibonacci( int n) { int fib1 = 1 ; int fib2 = 1 ; int fib3; if (n == 1 || n == 2 ) return 1 ; else { for ( int i = 3 ; i <= n; i ++ ) { fib3 = fib1 + fib2; fib1 = fib2; fib2 = fib3; } return fib3; } } // 递归 int Fib( int n) { int fib = 1 ; if (n == 1 || n == 2 ) fib = 1 ; else fib = Fib(n - 1 ) +

函数递归 递归定义： 程序调用自身的编程技巧称为递归（ recursion）。 递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。 递归的主要思考方式在于： 把大事化小 递归的必要条件： 存在限制条件，当满足这个限制条件的时候，递归便不再继续。 每次递归调用之后越来越接近这个限制条件。 递归函数举例： 接受一个整型值（无符号），按照顺序打印它的每一位。 解析： 如输入1234，要使按顺序输出1 2 3 4 函数带入参数（1234） 由于1234不是单个数字，则进入向内层 递 的过程（给1234/10） 再次带入参数（123） 由于123不是单个数字，则进入向内层 递 的过程（给123/10） 再次带入参数（12） 由于12不是单个数字，则进入向内层 递 的过程（给12/10） 再次带入参数（1） 由于1是单个数字，则进行打印并向外层 归 的过程。 代码： # include <stdio.h> void print ( int n ) { if ( n > 9 ) { print ( n / 10 ) ; } printf ( "%d " , n % 10 ) ;

我们讲过，generator保存的是算法，每次调用next(g) 就计算出g 的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出stopIteration 的错误 当然，上面这种不断调用 next(g) 实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象： >>> g = (x*x for x in range(10)) >>> for n in g: ... print(n) ... 0 1 4 9 16 25 36 49 64 81 >>> 所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它,并且不需要关心StopIteration的错误。 generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。 比如，著名的斐波那契(Fibonacci)，除第一个和第二个数外，任意一个数都可由前两个数相加得到： 1，1，2，3，5，8，13，21，34，。。。。 斐波那契数列用列表生成式写不出来，但是，用函数把它打印出来却很容易： def fib(max): n, a, b = 0, 0, 1 while n < max: print(b) a, b = b, a+b n = n + 1 return 'done'注意，赋值语句：a,b =

1、什么是斐波那契数列？ 1、1、2、3、5、8、13、21、34…… 斐波那契数列又被成为黄金分割数列，因为 前一项/后一项越来越趋近于0.618 由上面的数列，可以发现 除了前两项，后面每一项都是前两项的和，如3+5=8、8+13=21… 由此可以得到一下等式 F(n)=F(n-1)+F(n-2) (除了前两项) 2、斐波那契查找和斐波那契数列有什么联系？ 斐波那契查找原理与前两种相似，仅仅改变了中间结点（mid）的位置，mid不再是中间或插值得到，而是位于黄金分割点附近，即mid=low+F（k-1）-1（F代表斐波那契数列） 关于F（k）-1 由斐波那契数列可知，F(k)=F(k-1)+F(k-2),那F(k)-1=(F(k-1)-1)+(F(k-2)-1)+1,所以数组长度只要满足 F(k)-1，就可以将数组分为F(k-1)-1和F(k-2)-1左右两部分，其中mid=low+F(k-1)-1 代码实现: package com.yg.search;/* @author Mu_Mu @date 2020/3/1 10:47 */ import java.util.Arrays; public class FibonacciSearch { public static int maxSize = 10; public static void main(String[]

什么是斐波那契查找 斐波那契数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、····，在数学上，斐波那契被递归方法如下定义：F(1)=1，F(2)=1，F(n)=f(n-1)+F(n-2) （n>=2）。该数列越往后相邻的两个数的比值越趋向于黄金比例值（0.618）。 斐波那契查找就是在二分查找的基础上根据斐波那契数列进行分割的。在斐波那契数列找一个等于略大于查找表中元素个数的数F[n]，将原查找表扩展为长度为 F[n] (如果要补充元素，则补充重复最后一个元素，直到满足 F[n] 个元素)，完成后进行斐波那契分割，即F[n]个元素分割为前半部分F[n-1]个元素，后半部分F[n-2]个元素，找出要查找的元素在那一部分并递归，直到找到。 代码实现 package test.algorithm.FastSlowPointer; /** * 斐波那契查找（黄金分割法查找） * @author serenity * */ public class FibonacciSearch { public final static int MAXSIZE = 20; /** * 斐波那契数列 * @return */ public static int[] fibonacci(){ int[] f = new int[20]; int i =0; f[0] = 1;

繁殖力超强的兔子 说到斐波那契数，我们自然会想到曾经有一群繁殖力超强的兔子。比萨的商人斐波那契（Fibonacci，12-13世纪，称为比萨的列奥那多）接触到阿拉伯数学后，在其著作《Liber Abaci》中，引入了这个著名的兔子问题。但如果向前追溯下去，则可以追溯到 古老的印度数学 。斐波那契使用了一个理想化了的兔子生长模型进行研究，并假设： 第一个月初有一对刚诞生的兔子 两个月之后(第三个月初)它们可以生育 每月每对可生育的兔子会诞生下一对新兔子 兔子永不死去 从第一个月开始，兔子的数目（对）依次是：1，1，2，3，5，8。。。这样就形成了一个序列，记为{Fn}，则该序列存在一个递推关系： F(n)=F(n-1)+F(n-2) ，n >= 3。可以通过如下简单的推断得出：F(n)表示在第n个月时兔子的对数，这些兔子分为两部分，一是在第n-1个月已有的兔子，因为它们都活了下来（实际上会一直活下去），也就是F(n-1)；二是F(n-1)对兔子中可生育的兔子，也就是已经生活了至少二个月的兔子，这个数字恰好是在第n-2个月已有的兔子，即F(n-2)。如果令F(0)=0，则F(n)的定义可推广至所有非负整数（ 公式一 ）： F(0)=0 F(1)=1 F(n) = F(n-1) + F(n-2)，当n > 1 递归求值 这看起来是个非常简单的递推关系，若要通过程序求值， 很自然地

# include <stdio.h> # include <stdlib.h> int feibo ( int n ) ; //非递归 int feiboDigui ( int n ) ; //递归 int main ( ) { int n ; while ( scanf ( "%d" , & n ) != EOF ) { printf ( "%d\n" , feiboDigui ( n ) ) ; //目前是递归方法，非递归换一下就ok } return 0 ; } int feibo ( int n ) { //非递归 int sum1 = 1 , sum2 = 1 , sum , i ; if ( n == 1 ) { return 1 ; } if ( n == 2 ) { return 1 ; } for ( i = 3 ; i <= n ; i ++ ) { sum = sum1 + sum2 ; sum1 = sum2 ; sum2 = sum ; } return sum ; } int feiboDigui ( int n ) { if ( n == 1 || n == 2 ) { //递归函数出口 return 1 ; } else { return ( feiboDigui ( n - 2 ) + feiboDigui ( n - 1 ) ) ; } }

问题： 有一堆个数为n(n>=2)的石子，游戏双方轮流取石子，规则如下： 1)先手不能在第一次把所有的石子取完，至少取1颗； 2)之后每次可以取的石子数至少为1，至多为对手刚取的石子数的2倍。 约定取走最后一个石子的人为赢家，求必败态。 结论： 当n为Fibonacci数的时候，先手必败。 f[i]：1,2,3,5,8,13,21,34,55,89…… 证明： 数学归纳法： 为了方便，我们将n记为f[i]。 1、当i=2时，先手只能取1颗，显然必败，结论成立。 2、假设当i<=k时，结论成立。 则当i=k+1时，f[i] = f[k]+f[k-1]。 则我们可以把这一堆石子看成两堆，简称k堆和k-1堆。 （一定可以看成两堆，因为假如先手第一次取的石子数大于或等于f[k-1]，则后手可以直接取完f[k]，因为f[k] < 2*f[k-1]） 对于k-1堆，由假设可知，不论先手怎样取，后手总能取到最后一颗。下面我们分析一下后手最后取的石子数x的情况。 如果先手第一次取的石子数y>=f[k-1]/3，则这小堆所剩的石子数小于2y，即后手可以直接取完，此时x=f[k-1]-y，则x<=2/3*f[k-1]。 我们来比较一下2/3*f[k-1]与1/2*f[k]的大小。即4*f[k-1]与3*f[k]的大小，对两值作差后不难得出，后者大。 所以我们得到，x<1/2*f[k]。 即后手取完k