最长单调子序列LIS的简单动态规划算法
给定一个序列，要求求出该序列的最长单调子序列， 即 longest increasing subsequence
这是一个经典的动态规划求解问题。
设给定序列为 a[]，大小为 n，如何求其最长单调子序列呢？
考虑将最长单调子序列的长度作为所求的最优值
最长单调子序列必定以序列a[]中的某一个元素结尾，这是废话。
设序列count[i]为以a[i]结尾的最长单调子序列的长度，那么a[]的LIS的长度就是
max{count[i]}, 对所有i
显然此问题具有最优子结构性质，
count[0] = 1, count[i] = max{count[j] | 0 <= j < i, a[j] < a[i]} + 1
据此可得出简单的动态规划算法：
import java.util.Random;
/** sequence resolved with dynamic design
* @author Ewan
* @author http://blog.csdm.net/whmii
*/
public class Sequence {
/** the data of the sequence,
* express as an array
*/
private int[] a;
/**default constructor
* produce an array randomly
*/
public Sequence() {
long seed = System.nanoTime();
Random rand = new Random(seed);
int size = 5 + rand.nextInt(8);
a = new int[size];
for(int i = 0; i < size; i++) {
a[i] = rand.nextInt(50);
}
}
public String toString() {
String result = "";
for(int i = 0, len = a.length; i < len; i++) {
result += a[i];
result += "/t";
}
return result;
}
/** get out the LIS use dynamic design
* time O(n*n)
*/
public int[] LIS() {
int n = a.length;
int currentLISLength; //LIS length end with current element
int maxLength = 0; //the result's length
int endIndex = 0; //the last element's index
int[] count = new int[a.length]; //count[i] stores the LIS ends with a[i]
int[] result;
count[0] = 1; //LIS contains one element at least
for(int i = 1; i < n; i++) {
currentLISLength = 0;
for(int j = 0; j < i; j++) {
if(a[j] <= a[i] && currentLISLength < count[j]) {
//a[j] is in LIS ends with a[i]
currentLISLength = count[j];
}
}
count[i] = currentLISLength + 1; //compute a[i] self
//compute the max length and last element's index of LIS
if(count[i] > maxLength) {
maxLength = count[i];
endIndex = i;
}
}
//store LIS into result[]
result = new int[maxLength];
int index = maxLength;
result[--index] = a[endIndex];
for(int i = endIndex, currentIndex = endIndex; i >=0; i--) {
if(a[i] <= a[currentIndex] && count[i] == count[currentIndex] - 1) {
result[--index] = a[i];
currentIndex = i;
}
}
return result;
}
}