【leetcode】最长上升子序列

题目要求

给定一个无序的整数数组，找到其中最长上升子序列的长度。（详情见leetcode-300）

思路

方法1

解答：1、对数组进行升序排序 2、LCS（最长公共子序列）
注意：该解法的时间复杂度为O(n*logn)+O(n*n)
java

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums.length==0) return 0;
        /*复制原数组*/
        int[] copyNums = new int[nums.length];
        for(int i=0;i<nums.length;i++)
        {
            copyNums[i] = nums[i];
        }
        /*快速排序*/
        quickSort(nums,0,nums.length-1);
        /*最长公共子序列*/
        return LCS(copyNums,nums,copyNums.length,nums.length);
    }
    private void quickSort(int[] nums,int start,int end)
    {
        if(start<end)
        {
            int middle = subQuickSort(nums,start,end);
            quickSort(nums,start,middle-1);
            quickSort(nums,middle+1,end);
        }
    }
    private int subQuickSort(int[] nums,int low,int high)
    {
        int value = nums[low];
        while(low<high)
        {
            if(nums[high]<value)
            {
                nums[low] = nums[high];
                low++;
            }
            if(nums[low]>value)
            {
                nums[high] = nums[low];
                high--;
            }
        }
        nums[low] = value;
        return low;
    }
    private int LCS(int[] a,int[] b,int i,int j)
    {
        int temp1=1,temp2=1;
        if(i==-1 || j==-1) return 0;
        if(a[i]==b[j]) return LCS(a,b,i-1,j-1)+1;
        temp1=LCS(a,b,i-1,j);
        temp2=LCS(a,b,i,j-1);
        return (temp1>temp2)?temp1:temp2;
    }
}

方法2

前提：使用a[i]表示以当前值结尾的递增序列的长度,初始值为1
解答：if(nums[j]>nums[i]){a[j]=a[i]+1;}
注意：该解法的时间复杂度为O(n*n)
java

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums.length==0) return 0;
        int[] a = new int[nums.length];
        a[0]=1;
        int max = 1;
        for(int i=1;i<nums.length;i++)
        {
            a[i] = 1;
            for(int j=0;j<i;j++)
            {
                if(nums[i]>nums[j] && a[i]<=a[j]) a[i] = a[j]+1;
            }
            if(a[i]>max) max=a[i];
        }
        return max;
    }
}

方法3

前提：使用c[i]存储达到相同最长序列长度时的最小数值,c[i]的长度即为最长上升子序列的长度
解答：if(a[i]>c[len]) c[len+1]=a[i]; else{ //寻找c中a[i]的合适位置并替换}
注意：查找方法使用二分查找思路，时间复杂度为O(logn),该解法的时间复杂度为O(n*logn)
java

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums.length==0) return 0;
        int[] c = new int[nums.length];c[0]=nums[0];
        int lenC = 0;
        for(int i=1;i<nums.length;i++)
        {
            if(nums[i]>c[lenC])
            {
                lenC++;
                c[lenC] = nums[i];
            }
            if(nums[i]<c[lenC])
            {
                //寻找小于nums[i]的最大值并替换
                findBinarySearch(c,0,lenC,nums[i]);
            }
        }
        return lenC+1;
    }
    /*查找a[i]在c中的位置并进行替换*/
    private void findBinarySearch(int[] n,int start,int end,int value)
    {
        if(start == end && value<n[start]) n[start] = value;
        if(start<end)
        {
            int middle = (start+end)/2;
            if(value<n[middle]) 
            {
                findBinarySearch(n,start,middle,value);
            } else if(value>n[middle]){
                if(value<n[middle+1])
                {
                    n[middle+1] = value;
                } else {
                    findBinarySearch(n,middle,end,value);
                }
            }
        }
    }
}