最长递增子序列(LIS)的问题是要找到一个给定序列的最长子序列的长度,使得子序列中的所有元素被排序的顺序增加。
例如,{10,22,9,33,21,50,41,60,80} LIS的长度是6和 LIS为{10,22,33,50,60,80}。
有两种方式来求解,一种是转化为LCS问题。即,首先对数组排序,将排序后的结果存储在辅助数组中。排序时间复杂度O(NlogN),排序后的数组与原数组组成了LCS(N,N)问题。解决LCS问题的时间复杂度为O(N^2),故整个算法的时间复杂度为O(N^2),空间复杂度为O(N)
另一种方式是直接用DP求解,算法如下:时间复杂度为O(N^2)
①最优子问题
设lis[i] 表示索引为 [0...i] 上的数组上的 最长递增子序列。初始时,lis[i]=1,注意,在DP中,初始值是很重要的,
它是整个算法运行正确的关键。而初始值 则可以 通过 画一个小的示例来 确定。
当 arr[i] > arr[j],lis[i] = max{lis[j]}+1 ;其中,j 的取值范围为:0,1...i-1
当 arr[i] < arr[j],lis[i] = max{lis[j]} ;其中,j 的取值范围为:0,1...i-1
②重叠子结构
例如,{10,22,9,33,21,50,41,60,80} LIS的长度是6和 LIS为{10,22,33,50,60,80}。
有两种方式来求解,一种是转化为LCS问题。即,首先对数组排序,将排序后的结果存储在辅助数组中。排序时间复杂度O(NlogN),排序后的数组与原数组组成了LCS(N,N)问题。解决LCS问题的时间复杂度为O(N^2),故整个算法的时间复杂度为O(N^2),空间复杂度为O(N)
另一种方式是直接用DP求解,算法如下:时间复杂度为O(N^2)
①最优子问题
设lis[i] 表示索引为 [0...i] 上的数组上的 最长递增子序列。初始时,lis[i]=1,注意,在DP中,初始值是很重要的,
它是整个算法运行正确的关键。而初始值 则可以 通过 画一个小的示例来 确定。
当 arr[i] > arr[j],lis[i] = max{lis[j]}+1 ;其中,j 的取值范围为:0,1...i-1
当 arr[i] < arr[j],lis[i] = max{lis[j]} ;其中,j 的取值范围为:0,1...i-1
②重叠子结构
从上面可以看出,计算 lis[i]时,需要计算 lis[j],其中 j < i,这说明有重叠子问题。
具体实例及实现代码如下所示:
/** * @Title: LIS.java * @Package dynamicprogramming * @Description: TODO * @author peidong * @date 2017-6-5 上午8:45:48 * @version V1.0 */ package dynamicprogramming; import java.util.Arrays; import java.util.Stack; /** * @ClassName: LIS * @Description: 最长递增子序列 * @date 2017-6-5 上午8:45:48 * */ public class LIS { // 使用动态规划求最长递增子序列的长度 public static int lis(int[] arr) { if (arr == null || arr.length == 0) return 0; return lis(arr, arr.length); } public static int lis(int[] arr, int length) { // 初始化数组 int[] lis = new int[length]; for (int i = 0; i < length; i++) { lis[i] = 1; } // 查找递增子序列 for (int i = 1; i < length; i++) { for (int j = 0; j < i; j++) { if (arr[i] > arr[j] && lis[j] + 1 > lis[i]) { lis[i] = lis[j] + 1; } } } int max = lis[0]; for (int i = 1; i < length; i++) { if (max < lis[i]) { max = lis[i]; } } return max; } // 利用辅助数组转变成求最长公共子串的问题 /** * * @Title: getLCS * @Description:获取两个数组的最长公共子串 * @param arr * @param data * @return void * @throws */ public static void getLCS(int[] arr, int[] data) { int len1 = arr.length; int len2 = data.length; int[][] newArr = new int[len1 + 1][len2 + 1]; // 设置第0行和第0列为0 for (int i = 0; i < newArr.length; i++) { newArr[i][0] = 0; } for (int j = 0; j < newArr[0].length; j++) { newArr[0][j] = 0; } // 二维数组记录相同的字符序列 for (int i = 1; i < newArr.length; i++) { for (int j = 1; j < newArr[i].length; j++) { if (arr[i - 1] == data[j - 1]) { // 动规公式一:LCS(Xm, Yn) = LCS(Xm-1, Yn-1) +Xm newArr[i][j] = newArr[i - 1][j - 1] + 1; } else { // 动规公式二:LCS(Xm, Yn) = MAX{LCS(Xm-1, Yn), LCS(Xm, Yn-1)} newArr[i][j] = max(newArr[i - 1][j], newArr[i][j - 1]); } } } Stack<Integer> stack = new Stack(); int m = arr.length - 1; int n = data.length - 1; while (n >= 0 && m >= 0) { // 遍历数组 if (arr[m] == data[n]) { stack.push(arr[m]); m--; n--; } else {// 字符不同时,根据打印出的二维矩阵(测试数据)查找上一个相同的字符 if (newArr[m + 1][n] > newArr[m][n + 1]) { n--; } else { m--; } } } while (!stack.isEmpty()) {// 打印出最长的递增子序列 System.out.print(stack.pop() + ","); } } public static int max(int a, int b) { return (a > b) ? a : b; } public static void main(String[] args) { int[] arr = { 10, 22, 9, 33, 21, 50, 41, 60, 80 }; int len = arr.length; int[] array = new int[len]; // 将arr复制给array for (int j = 0; j < arr.length; j++) { array[j] = arr[j]; } Arrays.sort(array, 0, array.length - 1); System.out.print("排序前的数组:"); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i] + ","); } System.out.println(); System.out.print("排序后的数组:"); for (int i = 0; i < array.length; i++) { System.out.print(array[i] + ","); } System.out.println(); System.out.println("最长递增子序列为:"); getLCS(arr, array); System.out.println(); int res = lis(arr); System.out.println("最长递增子序列长度为:" + res); } }