最长递增(减)子序列

http://skynewborn.blog.sohu.com/66594610.html（比较详细）

http://hi.baidu.com/dufangst/blog/item/483ef917ceb756dff6039e13.html

http://blog.sina.com.cn/s/blog_4d3c631901000b8d.html

最长单调序列的动态规划优化问题

       最长单调序列是动态规划解决的经典问题。现在以求最长下降序列（严格下降）为例，来说明怎样用O(nlogn)来解决它。设问题处理的对象是序列a[1..n]。整个动态规划算法是这样实现的：

procedure longest-decreasing-subsequence begin        ans ←0 for  i←1 to n do    begin           j←1,k←ans           while (j≤k) do               begin                    m ← (j+k) div 2                    if b[m]>a[i] j←m+1                      else k←m-1               end          if j>ans  ans←ans+1          b[j]←a[i]    end return ans end

  这一程序非常短小精悍，其中的奥妙还是不少的。

    今天先学会了最长递减子序列的求法，一想序列最后一个数开始找，岂不就找到了序列的最长递增子序列。

  求最长递增子序列时即可从最后一个元素开始求最长递减子序列，反一下即可。

    代码如下：

          最长递减子序列求法

 int longest_decreasing_sequence(int a[4000],int n)
{
    int i,j,k,ans,m;
   
    ans=0;
    for(i=1;i<=n;i++)
    {
        j=1;
        k=ans;
        while(j<=k)
        {
            m=(j+k)/2;
            if(b[m]>a[i])  j=m+1;
            else    k=m-1;
        }
     
        if(j>ans)    ans+=1;
        b[j]=a[i];
    }

    return ans;
}

 

 最长递增子序列解决  HOJ1288

  函数实现代码如下：

   int longest_increasing_sequence(int a[4000],int n)
{
    int i,j,k,ans,m;
   
    ans=0;
    for(i=n;i>=1;i--)
    {
        j=1;
        k=ans;
        while(j<=k)
        {
            m=(j+k)/2;
            if(b[m]>a[i])  j=m+1;
            else    k=m-1;
        }
        if(j>ans)    ans+=1;
        b[j]=a[i];
    }
   
    return ans;
}

终于明白二分法的意思了。二元搜索树来判定。

http://blog.163.com/eriol_chen@126/blog/static/6447718020101029101455342/

问题描述：给出一个数列，找出其中最长的单调递减（或递增）子序列。

解题思路：动态规划。假设0到i-1这段数列的最长递减序列的长度为s，且这些序列们的末尾值中的最大值是t。对于a[i]有一下情况：
(1) 如果a[i]比t小，那么将a[i]加入任何一个子序列都会使0到i的最长单调序列长度变成s+1，这样的话，在0到i的数列中，长度为s+1的递减子序列的末尾值最大值就是a[i]；
(2) 如果a[i]和t相等，那么说明数列从0项到i项的最长单调子序列长度就是s；
(3) 如果a[i]比t大，那么a[i]就不一定能够成为长度为s的递减子序列的末项，这取决于长度为s-1的各个递减子序列的末尾值的最大值t'。
     如果t'比a[i]要大，那么就可以形成长度为s的递减子序列，如果t'比a[i]小，那么问题就在往前递推，把a[i]和长度为s-2的各个递减子序列的末尾值的最大值比较，直到：(1) a[i]比长度为s'的递减子序列的末尾值的最大值要小，那么a[i]就是数列0到i部分长度为s'+1的递减子序列的末尾值中的最大值；(2) a[i]比任何长度的递减子序列的末尾值的最大值都要大，那么a[i]就是长度为1的递减子序列的最大值。
   所以，引入数组c[i]表示长度为i的递减子序列的末尾值的最大值。显然c数组必然是单调递减的。b[i]数组用于子序列的输出，b[i]表示从a[0]到a[i]且终止于a[i]的最长递减序列的长度。

算法复杂度：O(nlogn)，对于数组c的查找使用二分查找，降低了整体的算法复杂度。

算法步骤：
1）读入n和a[i].
2）将数组c全部赋值为-1.
3）定义变量s，初始化为1，s表示目前为止最长单调序列的长度，同时也是数组C的有效容量。c[1] = a[0].
4）对于0到n-1的每个i：
       查找c[1]到c[s]，找到一个值k满足下列几种情况：
        （1）c[k] <= a[i] 而 c[k-1] > a[i] （如果k>1）
        （2）找不到（1）中k的话，k等于s+1，并且s自加一。
       c[k] = a[i]；
       b[i] = k;
5）最后所得s即为所求值。

import java.util.Scanner;

public class LongestSubSeq {

    public static int bsearch(int[] a, int s, int m) {
        int low = 1;
        int high = s;
        int mid;
        
        while (low < high) {
            mid = (low + high) / 2;
            if (a[mid] == m )
                return mid;
            if (a[mid] > m)
                low = mid + 1;
            else
                high = mid;
        }
        if (a[low] <= m)
            return low;
        else
            return low+1;
    }
    
    public static void print(int[] a, int[] b, int level, int start) {
        if (level == 0)
            return;
        int i = start;
        while (b[i] != level)
            i--;
        print(a, b, level-1, i-1);
        System.out.print(a[i] + " ");
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        
        int[] array = new int[n];
        int[] b = new int[n];
        int[] c = new int[n+1];
        
        for (int i = 0; i < n; i++) {
            array[i] = in.nextInt();
            c[i] = -1;
        }
        
        int s = 1;
        int k;
        c[1] = array[0];
        
        for (int i = 0; i < n; i++) {
            k = bsearch(c, s, array[i]);
            if(k > s)
                s++;    
            c[k] = array[i];
            b[i] = k;
        }
        
        System.out.println("The length of longest squence is: " + s);
        System.out.print("The squence is: ");
        print(array, b, s, n-1);
    }
}

http://blog.sina.com.cn/s/blog_411fed0c0100tq41.html