俄罗斯信封套娃

leetcode || 俄罗斯信封套娃

class Solution {
    public int maxEnvelopes(int[][] envelopes) {
        int row = envelopes.length;
        quicksort(envelopes,0,row - 1);
        return longsub(envelopes);
    }
    
  //最长绝对递增子序列
    public int longsub(int[][] nums)
    {
        int len = nums.length;
        int[] res = new int[len];
        res[0] = 1;
        int max;
        int Maxx=1;
        for(int i =1;i<len;i++)
        {
            max = 1;
            for(int j =0;j < i;j++)
            {
                if(compare2(nums[i],nums[j]) == true )
                {
                    if (res[j] + 1 >max)
                    {
                        max = res[j]+1;
                    }
                }
            }
            res[i] = max;
            if(res[i]>Maxx)
                Maxx=res[i];
        }
        return Maxx;
    }
    //排序时使用的比较函数
    public boolean compare(int[] a1,int[] a2)
    {
        return a1[0]>a2[0]?true:false;
    }
//求最长递增子序列时用的比较函数
      public boolean compare2(int[] a1,int[] a2)
    {
        return a1[0]>a2[0]&&a1[1]> a2[1]?true:false;
    }
    //快排！
     public void quicksort(int[][] nums,int start,int end)
    {
        if(start >= end)
            return;
//        第一个为基准点
        int[] key = nums[start];
        int i = start,j = end;
        while(i<j)
        {
//            从右到左，找到比key小的元素，放到基准的位置
            while(i < j && compare(nums[j],key)== true)
                j--;
            if(i < j)
            {
                nums[i++] = nums[j];
            }
//从左到右，找到比基准大的元素，放到j的位置
            while(i < j && compare(nums[i],key) == false)
                i++;
            if(i < j)
            {
                nums[j--] = nums[i];
            }

        }

        nums[i] = key;
        quicksort(nums,start,i-1);
        quicksort(nums,i+1,end);
    }
}

1.基础知识—快排

import java.util.Enumeration;

public class test {
    public void quicksort(int[] nums,int start,int end)
    {

        if(start >= end)
            return;
//        第一个为基准点
        int key = nums[start];
        int i = start,j = end;
        while(i<j)
        {
//            从右到左，找到比key小的元素，放到基准的位置
            while(i < j && nums[j] > key)
                j--;
            if(i < j)
            {
                nums[i++] = nums[j];
            }
//从左到右，找到比基准大的元素，放到j的位置
            while(i < j && nums[i] < key)
                i++;
            if(i < j)
            {
                nums[j--] = nums[i];
            }

        }

        nums[i] = key;
        quicksort(nums,start,i-1);
        quicksort(nums,i+1,end);
      
    }
    public static void main(String[] args) {
        int[] arr = {13,6,1,8};
        test t = new test();
        t.quicksort(arr,0,3);
//        for(int i = 0;i<arr.length;i++)
//        System.out.println(arr[i]);
    }
}