LongestIncreasingSubsequence300.java

/**
 * Given an unsorted array of integers, find the length of longest increasing
 * subsequence.
 *
 * For example,
 * Given [10, 9, 2, 5, 3, 7, 101, 18],
 * The longest increasing subsequence is [2, 3, 7, 101], therefore the length
 * is 4. Note that there may be more than one LIS combination, it is only
 * necessary for you to return the length.
 *
 * Your algorithm should run in O(n2) complexity.
 *
 * Follow up: Could you improve it to O(n log n) time complexity?
 */

public class LongestIncreasingSubsequence300 {
 public int lengthOfLIS(int[] nums) {
 if (nums == null || nums.length == 0) return 0;
 int N = nums.length;
 int[] dp = new int[N + 1];
 int res = 0;
 for (int i=1; i<=N; i++) {
 dp[i] = 1;
 for (int j=1; j<i; j++) {
 if (nums[i-1] > nums[j-1]) {
 dp[i] = Math.max(dp[i], dp[j] + 1);
 }
 }
 if (dp[i] > res) res = dp[i];
 }
 return res;
 }


 /**
 * https://leetcode.com/problems/longest-increasing-subsequence/solution/
 * https://www.geeksforgeeks.org/longest-monotonically-increasing-subsequence-size-n-log-n/
 */
 public int lengthOfLIS2(int[] nums) {
 int[] dp = new int[nums.length];
 int len = 0;
 for (int num : nums) {
 int i = Arrays.binarySearch(dp, 0, len, num);
 if (i < 0) {
 i = -(i + 1);
 }
 dp[i] = num;
 if (i == len) {
 len++;
 }
 }
 return len;
 }


 /**
 * https://leetcode.com/problems/longest-increasing-subsequence/solution/
 */
 public int lengthOfLIS3(int[] nums) {
 int memo[][] = new int[nums.length + 1][nums.length];
 for (int[] l : memo) {
 Arrays.fill(l, -1);
 }
 return lengthofLIS(nums, -1, 0, memo);
 }

 public int lengthofLIS(int[] nums, int previndex, int curpos, int[][] memo) {
 if (curpos == nums.length) {
 return 0;
 }
 if (memo[previndex + 1][curpos] >= 0) {
 return memo[previndex + 1][curpos];
 }
 int taken = 0;
 if (previndex < 0 || nums[curpos] > nums[previndex]) {
 taken = 1 + lengthofLIS(nums, curpos, curpos + 1, memo);
 }

 int nottaken = lengthofLIS(nums, previndex, curpos + 1, memo);
 memo[previndex + 1][curpos] = Math.max(taken, nottaken);
 return memo[previndex + 1][curpos];
 }


 /**
 * https://leetcode.com/problems/longest-increasing-subsequence/discuss/74824/JavaPython-Binary-search-O(nlogn)-time-with-explanation
 */
 public int lengthOfLIS4(int[] nums) {
 int[] tails = new int[nums.length];
 int size = 0;
 for (int x : nums) {
 int i = 0, j = size;
 while (i != j) {
 int m = (i + j) / 2;
 if (tails[m] < x)
 i = m + 1;
 else
 j = m;
 }
 tails[i] = x;
 if (i == size) ++size;
 }
 return size;
 }

}