矩形嵌套

import java.util.*;
import java.math.*;
public class Main {

    public static void main(String[] args) {
        
        Solution s = new Solution();
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] result = new int[N];
        
        for(int i = 0; i < N; i++) {
            int n = sc.nextInt();
            block[] groupBlock = new block[n];
            
            for(int j = 0; j < n; j++) {
                s.insertSort(groupBlock, new block(sc.nextInt(), sc.nextInt()), j);
            }
            result[i] = s.getResult(groupBlock);
        }
        for(int i : result) {
            System.out.println(i);
        }
        sc.close();
    }
}

class Solution {
    public int getResult(block[] groupBlock) {
        int N = groupBlock.length;
        int[] states = new int[N];
        int result = 0;
        for(int i = 0; i < N; i++) {
            int maxNum = 1;
            for(int j = 0; j < i; j++) {
                if(groupBlock[i].a > groupBlock[j].a && groupBlock[i].b > groupBlock[j].b) {
                    //保证可以嵌套
                    maxNum = states[j] + 1 > maxNum ? states[j] + 1: maxNum; //修改最大值
                }
            }
            states[i] = maxNum;
            if(maxNum > result)
                result = maxNum;
        }
        return result;
    }
    public void insertSort(block[] groupBlock, block blo, int j) {
        while(j > 0 && groupBlock[j - 1].a > blo.a) {
            groupBlock[j] = groupBlock[j - 1];
            j--;
        }
        groupBlock[j] = blo;
    }
}

class block {
    public int a = 0;
    public int b = 0;
    public block() { };
    public block(int length, int width) {
        a = length >= width ? length : width;
        b = length <= width ? length : width;
    }
}

这道题真的让我苦思冥想好久啊，原因在与完全没有学过动态规划强行去解这道题。自己在初期的思路完全走了错误的方向，而且还根深蒂固。不由得让我想起我遇到的第一道动态规划，也是靠蛮力硬解，导致了完全陷入了成堆的“也许可行”的逻辑控制当中，不得不说还是应当学习别人的先进想法再来动手。
解法很是明白，当然这和刘佳汝大神更优化的解法相差还是十分遥远，不过算是大众的思路了，先排序，再用类似LIS的方法求解。