猴子摘桃问题（最大递增子列问题）

问题描述：小猴子下山，沿着下山的路由一排桃树，每棵树都结了一些桃子。小猴子想摘桃子，但是有一些条件需要遵守，小猴子只能沿着下山的方向走，不能回头，每棵树最多摘一个，而且一旦摘了一棵树的桃子，就不能再摘比这棵树结的桃子少的树上的桃子了，那么小猴子最多能摘几个桃子呢？举例说明，比如有5课树，分别结了10,4,5,12,8颗桃子，那么小猴子最多能摘3颗桃子，来自于结了4,5,8颗桃子的树。

问题分析：仔细看下题目其实不难理解，就是对于任给的一个整数数列，要求返回它最长非递减子列的长度。

解题思路：一开始的想法是能不能只遍历一遍数列，也就是复杂度为$O(n)$的算法找出来，很快发现不可能，因为每当连续跳过一些较小数时，都需要检查跳过的子列里面有没有包含比前面更长的递增列，这样必然需要回溯判断，复杂度就超过n了；后来想到既然需要不断的回溯检查子列，不如用递归实现，又发现里面包含了分支判断语句，还有不同的返回值，太复杂不会写；最后换了一种思路，既然是要找数列A非递减的子列B，那B必然也是数列A本身非递减排列后所得数列C的子列，因此通过C找出它和A的最长公共子列即是题目的解。

实现方法：
首先将数列非递减排序，并称为original和increment：

之后遍历increment数列，如从4开始，再从0位置开始顺序检索original，找到4的位置，是第2位，接着确定increment中下一个数字5，此时从origin中4的后一位也就是第3位开始检索，直到数列结束，若有元素和5相等，则更新下一轮original的检索位置，继续查找increment中的下一个，否则不更新检索位置直接查找increment中的下一个，直到increment中全部元素被比较完成，记录这一次的最大子列长度。接着从increment中下一位5开始重复上述步骤，并记录最大子列长度，直到遍历increment所有位置，最终得出最大子列长度即是最大非递减子列的长度。

C语言实现：

#include<stdio.h>

//冒泡排序法
void BubbleSort(int *a, int n)
{
    int i, j, t;
    for (i = 0; i < n - 1; i++){
        for (j = 0; j<n - i - 1; j++){
            if (a[j] >= a[j + 1]){
                t = a[j + 1];
                a[j + 1] = a[j];
                a[j] = t;
            }
        }
    }
}
//查找函数
int SearchSub(int *orginal, int *incre,int n)
{
    int maxsub = 0;
    for (int i=0; i<n-1; i++){
        int tempsub = 0, index = 0;    //初始化最大长度和检索位置
        for (int j = i; j < n; j++){
            for (int k = index; k < n; k++){
                if (orginal[j] == incre[k]){
                    index = j+1;       //匹配成功时更新检索位置，子列长度+1
                    tempsub += 1;
                }
            }
        }
        if (tempsub > maxsub)          //每完成一轮比较，更新最大子列长度
            maxsub = tempsub;
    }
    return maxsub;
}

int main()
{
    int a[5] = { 10,4,5,12,8 };    //输入原数列
    int n = 5;
    int b[5];
    for (int i = 0; i < n; i++){
        b[i] = a[i];
    }
    BubbleSort(b, n);              //对原数列进行排序
    int result = SearchSub(a, b, n);
    printf("最长递增子列长度为：%d\n", result);
    system("pause");
    return 0;
}

输出结果为：

python实现方法，和C原理相同：

def Search_Subcolumn(list_orginal,list_incre):
    templist = []
    for k in range(len(list_orginal)-1):
        maxsub = 0
        index = 0
        for i in range(k,len(list_incre)):
            for j in range(index,len(list_orginal)):
                if(list_incre[i] == list_orginal[j]):
                    index = j+1
                    maxsub += 1
        templist.append(maxsub)
    return max(templist)

def BubbleSort(list):
    temp = 0
    for i in range(len(list)):
        for j in range(len(list)-i-1):
            if list[j] >= list[j+1]:
                temp = list[j]
                list[j] = list[j+1]
                list[j+1] = temp
    return list

def main():
    a = [10,4,5,12,8]
    c = a[:]
    b = BubbleSort(a)
    n = Search_Subcolumn(c,b)
    print('最长非递增子列长度为:%d'%n)

main()

结果：

  这个算法直观容易想到，但复杂度为$O(n^3)$比较高，其中搜索过程可以继续优化，如increment从4开始，最终得到最大子列长为3，而当遍历从10开始时，它后面的元素数已经小于3，不可能找出大于3的非递减子列，因此可以停止循环，直接返回结果。这种更改在子列较长且首元位于原数列靠前位置时可以减少搜索次数，起到明显的优化效果。

网上也有大牛总结出了$O(n^2)$和$O(nlogn)$的解法，参见：
http://blog.youkuaiyun.com/gao23191879/article/details/77461401?locationNum=5&fps=1