catalogue
Problem Description:
Given a sequence, such as arr=[10, 9, 2, 5, 3, 7, 101, 18], find the longest increasing subsequence of the sequence.
The longest increasing subsequence (LIS) can be solved by dynamic programming with n^2 complexity or greedy plus dichotomy with nlongn complexity.
Dynamic programming: (n^2)
Let dp[i] be the maximum length at the end of arr[i], then at the beginning, the element values in dp array are all 1 (self length). Take the above array as an example:
dp[0] = 1(10)
dp[1] = 1(9)
dp[2] = 1(2)
dp[3] = dp[2] + 1 = 2(2,5)
dp[4] = dp[2] + 1 = 2(2,3)
dp[5] = dp[2] + 1 = 2 or dp[5] = dp[3] + 1 = 3 or dp[5] = dp[4] + 1 = 3 (2,7) (2,5,7) (2,3,7)
dp[6] = dp[0... 5] + 1, DP [i] < DP [6], whichever is the largest
The maximum value stored in dp is the final maximum length.
java code:
public class Main {
public static void main(String[] args) {
int []arr = new int[] {10, 9, 2, 5, 3, 7, 101, 18};
int []dp = new int[arr.length];
for(int i = 0; i < arr.length; i++) {//Traversing elements in arr
dp[i] = 1;//The dp array is initialized to 1, that is, its length is 1
for(int j = 0; j < i; j++) {//Element before traversing dp[i]
if(arr[j] < arr[i]) {//Less than current element
dp[i] = Math.max(dp[i], dp[j] + 1);//compare
}
}
}
int max = Integer.MIN_VALUE;//Find the maximum value stored in dp
for(int i = 0; i < arr.length; i++) {
max = Math.max(max, dp[i]);
}
System.out.println(max);
}
}Greed + dichotomy: (nlongn)
For a rising subsequence, the smaller the element of the end value, the more conducive it is to add new elements after it, making the length the longest.
Taking arr=[10, 9, 2, 5, 3, 7, 101, 18] as an example, let the element values in the dp array be the longest sequence. The following is the dynamic change process of dp:
① dp[0] = 10. If there is no element, add 10 directly
② dp[0] = 9, because 9 is smaller than 10, and the length is still 1 after changing to 9, and it is more likely to butt the following elements
③ dp[0] = 2, because 2 is smaller than 9, and the length is still 1 after changing to 2, and it is more likely to connect with the following elements. For example, when 5 comes later, 2 can be directly followed by 5, while 9 cannot (greedy thinking, local optimization)
④ dp[1] = 5, adding 5 can make the length longer
⑤ dp[1] = 3, you should find the element that is just less than 3, and then overwrite the following element with 3 (you can use two points when searching)
⑥ dp[2] = 7 (ditto below)
⑦dp[3] = 101
⑧dp[3] = 18
java code:
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int []arr = new int[] {10, 9, 2, 5, 3, 7, 101, 18};
int []dp = new int[arr.length];
int len = 0;//The rightmost end of binary search (card range), the number of "meaningful" elements in dp
for(int i = 0; i < arr.length; i++) {
int index = Arrays.binarySearch(dp, 0, len, arr[i]);
if(index < 0) {
index = -(index + 1);//Change index to expected position
}
dp[index] = arr[i];//Update or append
if(index == len) {
len++;
}
}
System.out.println(len);
}
}Use of binarysearch():
binnarySearch() of the tool class Arrays is called during binary search. When using this method to find the element to be found, the found index is returned; If it cannot be found, a negative number is returned. Assuming that the non-existent elements should be located at index r when sorting, then - (r + 1) is the returned negative value.
For example:
public class BinarySeach {
public static void main(String[] args) {
int[] src = { 1, 2, 4, 5, 7, 8, 12 };
System.out.print(Arrays.binarySearch(src, 10)); //-7
}
}
If 10 does not exist in the src array, a negative number is returned. When 10 is placed in the ordered array src, it should be at index 6, so the negative value returned is - (6 + 1), that is, - 7.