俄罗斯套娃问题

https://blog.youkuaiyun.com/lsjweiyi/article/details/70879776

【题目】

输入：第一行 n ,表示有n个套娃。之后n行，每行两个整数：分别表示宽和高。
只有宽和高都大于的才能嵌套。
输出：嵌套的最大层数。

提示：插入排序+LIS算法（最大上升子序列）

【解答】

方法一：暴力算法，空间复杂度为O（1）（不算读取数据的数组）。时间复杂度：O（n*n）。

import java.util.Scanner;
public class RussiaPutBaby1 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[] wide=new int[n];
        int[] high=new int[n];
        for(int i=0;i<n;i++){
            wide[i]=sc.nextInt();
            high[i]=sc.nextInt();
        }
        System.out.println(Solution(n, wide, high));
    }

    static int Solution(int n,int[] wide,int[] high){//n^2
        int max=0;//记录嵌套的最大值
        int levels;//以某一个为基础的情况下套下的层数
        for(int i=0;i<n;i++){
            levels=0;
            //以一个套娃为基础，算算有多少能被他嵌套的（这里貌似是有问题的，重点看下一种方法）
            for(int j=0;j<n;j++){
                if(wide[i]>wide[j] && high[i]>high[j])
                    levels++;
            }
            max=max>levels?max:levels;
        }
        return max;
    }
}

方法二：先用宽进行排序，再对高求LIS。

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();

        int[] wide=new int[n];
        int[] high=new int[n];
        int w;
        int h;
        int index;
        for(int i=0;i<n;i++){
            index=i;
            w=sc.nextInt();
            h=sc.nextInt();
            while(index!=0 && w<wide[index-1]){//插入排序
                wide[index]=wide[index-1];
                high[index]=high[index-1];
                index--;
            }
            wide[index]=w;
            high[index]=h;
        }
        System.out.println(Solution(n, high));
    }

    //最长递增子序列问题（俄罗斯套娃问题：先按宽排序，再按高求LCS）
    public static int lis(int[] arr){
        if(arr == null || arr.length == 0)
            return 0;
        return lis(arr, arr.length);
    }

    private static int lis(int[] arr, int length){
        int lis[] = new int[length];//以i元素结尾的最长递增长度
//        for(int i = 0; i < length; i++)
//            lis[i] = 1;
        Arrays.fill(lis, 1); //初始化

        for(int i = 1; i < length; i++)
        {
            for(int j = 0; j < i; j++)
            {
             //lis[i]=max{lis[i-1], lis[i-1]+1}
                if(arr[i] > arr[j] && lis[j] + 1 > lis[i])
                    lis[i] = lis[j] + 1;
            }
        }

        int max = lis[0];
        int index = 0; //最长递增子序列末尾元素
        for(int i = 1; i < length; i++)
            if(max < lis[i]){
                max = lis[i];
                index = i;
            }
        System.out.println("末尾元素是：" + arr[index]);
        return max;
    }