算法--递归（4）

求n个元素的最大元问题

理解：
方法1：
n = 1时， return
n = 2时，return max
n = 3时，
m = Max(n-1)
if a[n]>m
return a[n]
else return m
方法2：
二分递归求最大值
i > n || j>n || i >j return
i = j
return a[i]
j - i =1
return max(a[i], a[j])
else
k = (i+j)/2
before = Max(i, k)
after = Max(k+1, j)
return max(before, after)

时间复杂度：

#include <iostream>
#include <algorithm>
#include <cstdlib>
using namespace std;

//求n个元素的全排列
//自然数拆分

//求n个元素的最大元问题

int a[1000];

int Max(int i, int j)
{
    if (i == j)
        return a[i];
    if (j - i == 1)
        return max(a[i],a[j]);
    int k = (i+j)/2;
    return max(Max(i, k), Max(k+1, j));
}


int main(void)
{
    for (int i = 0; i < 5; ++i)
    {
        a[i] = i;
    }
    cout << Max(0, 4) << endl;
}

台阶问题

理解：
n <1
return 0
n=1
return 1
n = 2
return 2
n>2
return jump(n-1)+jump(n-2)

#include <iostream>
#include <algorithm>
#include <cstdlib>
using namespace std;

//求n个元素的全排列
//自然数拆分

//台阶问题
/*
 * n <1
return 0
n=1
return 1
n = 2
return 2
n>2
return jump(n-1)+jump(n-2)
 */

int a[1000];

int jump(int n)
{
    if (n <= 2)
        return n;
    return jump(n-1) + jump(n-2);
}


int main(void)
{
    cout << jump(4) << endl;
}

烤汉堡问题

理解：
n 为偶数时，直接为n即可，不会浪费时间
n为奇数时，可以递归：
n = 1 return 2
n = 3 return 3
n>3 return 2 + ham(n-2)
不用递归的话，应该也可以直接n>3的情况输出n