最长递增子序列问题

题目描述

给定一个未排序的整数数组，找出最长递增子序列。
例如给定数组[10, 9, 2, 5, 3, 7, 101, 18]，最长递增子序列就是[2, 3, 7, 101]，长度就是4，最长递增子序列不一定只有一个，只要求出最长的长度。

---

解法一

动态规划法，定义一个数组dp，dp[i]代表了第i个数为结尾的最长递增子序列长度。当计算第dp[i]时，比较i位置的值和前面的所有值相比，如果值大于前面j处的值，就记录当前最大的dp[i]为dp[j]+1，dp[i]中的最大值。遍历过程中可以设置一个值记录最大递增子序列。
时间复杂度：由于每次判断dp[i]，需要和i前面的所有值比较，因此，时间复杂度为O(n²)。
实现：

1. publicstaticint longestSubstring(int[] arr){
2. if(arr ==null|| arr.length <=0)return0;
3. int[] dp =newint[arr.length];
4. dp[0]=1;
5. int max = dp[0];
6. for(int i =1; i < arr.length; i++){
7. dp[i]=1;
8. for(int j =0; j < i; j++){
9. if(arr[j]< arr[i]){
10. dp[i]= dp[i]>= dp[j]+1? dp[i]: dp[j]+1;
11. }
12. }
13. max = max >= dp[i]? max : dp[i];
14. }
15. return max;
16. }

解法二

解法二中，同样定义一个数组h[]，h[i]表示的是长度为i+1的递增子序列的最小末尾。h数组是有序的，每次遍历一个数，就在数组h的有效区中（填充了数据的部分）找到第一个大于自己的数，将其覆盖。
时间复杂度：O(nlogn)
实现:

1. publicstaticint longestSubstringFast(int[] arr){
2. if(arr ==null|| arr.length <=0)return0;
3. int[] h =newint[arr.length];
4. h[0]= arr[0];
5. int low =0;
6. int high =0;
7. int curr =0;//记录h的最后一个位置
9. for(int i =1; i < arr.length; i++){
10. if(arr[i]> h[curr]){
11. h[++curr]= arr[i];//比当前最后一个大，则直接插入在末尾
12. }
13. else{
14. low =0;
15. high = curr;
16. while(low <= high){
17. if(h[high]< arr[i]){
18. h[high+1]= arr[i];
19. break;
20. }
21. if(h[low]> arr[i]){
22. h[low]= arr[i];
23. break;
24. }
25. int mid =(low + high)/2;
26. if(arr[i]== h[mid])break;
27. elseif(arr[i]> h[mid]) low = mid +1;
28. else high = mid;
29. }
30. }
31. }
33. return curr+1;
34. }

---

扩展题目

描述：给定一个N×2 的二维数组，看作是一个个二元组，例如[[a1,b1],[a2,b2],[a3,b3]]，
规定：一个如果想把二元组甲放在二元组乙上，甲中的a 值必须大于乙中的a 值，甲中的b
值必须大于乙中的b 值。如果在二维数组中随意选择二元组，请问二元组最多可以往上摞
几个？
例如：[[5,4],[6,4],[6,7],[2,3]], 最大数量可以摞3 个，[2,3] => [5,4] => [6,7]
要求：实现时间复杂度O(NlogN)的解法

---

解法一

与上面求最长递增子序列方法一样，首先需要将数组排序，定义一个类用于表示二元组。排序规则为首先对二元组第一个数递增排序，然后第一个数相同的情况下，对第二个数递增排序。其中dp[i]表示以第i个二元组为结尾的最大长度。
时间复杂度：O(n²)
实现：
二元组定义

1. /**
2. * 二元组类，保存两个数
3. * Created by GGM on 2016/7/25.
4. */
5. publicclassTwoTuples{
6. privateint a;
7. privateint b;
9. publicint getA(){
10. return a;
11. }
13. publicint getB(){
14. return b;
15. }
17. publicTwoTuples(int a,int b){
18. this.a = a;
19. this.b = b;
20. }
22. publicboolean canBeUpper(TwoTuples twoTuples){
23. if(this.a > twoTuples.a &&this.b > twoTuples.b)returntrue;
24. returnfalse;
25. }
26. }

比较器定义

1. /**
2. * Created by GGM on 2016/7/25.
3. */
4. publicclassComparatorGenerator{
5. /**
6. * 第一个数递增排序，第二个数递增排序
7. * @return
8. */
9. publicstaticComparator<TwoTuples> orderComparator(){
10. returnnewComparator<TwoTuples>(){
11. @Override
12. publicint compare(TwoTuples o1,TwoTuples o2){
13. if(o1.getA()== o2.getA()){
14. return o1.getB()> o2.getB()?1:(o1.getB()== o2.getB()?0:-1);
15. }else{
16. return o1.getA()> o2.getA()?1:-1;
17. }
18. }
19. };
20. }
22. /**
23. * 第一个数大递增排序，第二数递减排序
24. * @return
25. */
26. publicstaticComparator<TwoTuples> reverseComparator(){
27. returnnewComparator<TwoTuples>(){
28. @Override
29. publicint compare(TwoTuples o1,TwoTuples o2){
30. if(o1.getA()== o2.getA()){
31. return o1.getB()> o2.getB()?-1:(o1.getB()== o2.getB()?0:1);
32. }else{
33. return o1.getA()> o2.getA()?1:-1;
34. }
35. }
36. };
37. }
38. }

算法实现

1. publicstaticint longestOfTwoTuples(TwoTuples[] arr){
2. if(arr ==null|| arr.length <=0)return0;
3. int[] dp =newint[arr.length];
4. Arrays.sort(arr,ComparatorGenerator.orderComparator());
5. dp[0]=1;
6. int max = dp[0];
7. for(int i =1; i < arr.length; i++){
8. dp[i]=1;
9. for(int j =0; j < i; j++){
10. if(arr[i].canBeUpper(arr[j])){//如果当前i可以放在j上面
11. dp[i]= dp[i]>= dp[j]+1? dp[i]: dp[j]+1;
12. }
13. }
14. max = max >= dp[i]? max : dp[i];
15. }
16. return max;
17. }

解法二

本解法同样需要对数组先排序，排序使用如下规则：对第一个数升序排序，如果第一个数相同，则第二个数降序排序。 h[i]存放的是二元组的b的值，因为相同的a的情况的下，b是按降序排序，相同的a情况下，b会覆盖第一个比它大的值，如果b的值比有效区最后一个值，那么说明是a也比有效区最后一个值，那么，将其添加在后面。
时间复杂度：O(nlogn)
实现：
二元组和比较器在上面定义，此处就省略了
算法实现

1. publicstaticint longestOfTwoTuplesFast(TwoTuples[] arr){
2. if(arr ==null|| arr.length <=0)return0;
3. int[] h =newint[arr.length];
4. Arrays.sort(arr,ComparatorGenerator.reverseComparator());
5. h[0]= arr[0].getB();
6. int low =0;
7. int high =0;
8. int curr =0;//记录h的最后一个位置
10. for(int i =1; i < arr.length; i++){
11. if(arr[i].getB()> h[curr]){
12. h[++curr]= arr[i].getB();//比当前最后一个大，则直接插入在末尾
13. }
14. else{
15. low =0;
16. high = curr;
17. while(low <= high){
18. if(h[high]< arr[i].getB()){
19. h[high+1]= arr[i].getB();
20. break;
21. }
22. if(h[low]> arr[i].getB()){
23. h[low]= arr[i].getB();
24. break;
25. }
26. int mid =(low + high)/2;
27. if(arr[i].getB()== h[mid])break;
28. elseif(arr[i].getB()> h[mid]) low = mid +1;
29. else high = mid;
30. }
31. }
32. }
34. return curr+1;
35. }

来自为知笔记(Wiz)