学习递归典型例子的一些心得

斐波那契数列

f(n) = f(n-1)+f(n-2),(n>=2)

f(n) = 1,(n = 1)

f(n) = 0,(n=0)

这里很容易得到函数的递归形式

直接给出C++代码

int Fibonacci(int n)
{
if (n <= 0)
return 0;
if (n == 1)
return 1;

return Fibonacci(n - 1) + Fibonacci(n - 2);
}

但是递归有一个坏处，就是计算值会重复，那么相应的时间复杂度会指数增加，举例：计算f(10) = f(9)+f(8),f(9) = f(8)+f(7),f(8) = f(7)+f(6).....这里发现f(9)、f(8)、f(7)....计算了两次

 

可以利用自底向上进行计算

 

int Fibonacci2(int n)
{
int result[2] = { 0, 1 };
if (n < 2)
return result[n];

int num0 = 0;
int num1 = 1;
int sum = 0;
for (int i = 2; i <= n; i++)
{
sum = num0 + num1;
num0 = num1;
num1 = sum;
}
return sum;
}

这样避免了重复计算，这里也算是运用了动态规划的思想吧

说到动态规划，那么也讲一讲动态规划的核心思想：找子结构

举个例子：找一串字符串的最长回文串

那么运用动态规划的思想，如果最长回文串为s，那么s的子串也是回文串，那么可以声明一个二维数组P[][],数组中的元素P[i][j],其中(i<=j),表示从字符串位置i到j是否为回文串，那么P[i][j] = (P[i+1][j-1]&&s.at(i) == s.at[j])

所以相应代码如下

string findLongestPalindrome(string &s)
{
    const int length=s.size();
    int maxlength=0;
    int start;
    bool P[50][50]={false};
    for(int i=0;i<length;i++)//初始化准备
    {
        P[i][i]=true;
        if(i<length-1&&s.at(i)==s.at(i+1))
        {
            P[i][i+1]=true;
            start=i;
            maxlength=2;
        }
    }
    for(int len=3;len<length;len++)//子串长度
        for(int i=0;i<=length-len;i++)//子串起始地址
        {
            int j=i+len-1;//子串结束地址
            if(P[i+1][j-1]&&s.at(i)==s.at(j))
            {
                P[i][j]=true;
                maxlength=len;
                start=i;
            }
        }
    if(maxlength>=2)
        return s.substr(start,maxlength);
    return NULL;
}