SW练习_P1233 木棍加工_变形LIS

从dilworth定理中，我们可知，下降子序列的最小划分等于最长不下降子序列的长度
主要是这个定理

package com.company.luogu;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.StringTokenizer;
public class P1233 {
//从dilworth定理中，我们可知，下降子序列的最小划分等于最长不下降子序列的长度
    public static void main(String[] args) throws Exception{
        BufferedReader reader=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer(reader.readLine());
        int N=Integer.parseInt(st.nextToken());//棍子的个数
        Node1233[] nodes=new Node1233[N];
        st=new StringTokenizer(reader.readLine());
        for (int i = 0; i  list=new LinkedList();
        list.add(arrs[0]);
        for (int i = 1; i list.getLast()){
                list.add(arrs[i]);
            }else{
                int index=searchList(list,arrs[i]);
                list.set(index,arrs[i]);
            }
            //len[i]=list.size();
        }
        return list.size();
    }
    private static int searchList(LinkedList list, int a) {
        int low=0;
        int high=list.size()-1;
        while(low<=high){
            int mid=(low+high)/2;
            if(list.get(mid)==a){
                return mid;
            }else if(list.get(mid)>a){
                high=mid-1;
            }else{
                low=mid+1;
            }
        }
        return low;
    }
}
class Node1233 implements Comparable{
    int l;//长度
    int w;//宽度
    public Node1233(int l, int w) {
        this.l = l;
        this.w = w;
    }
    @Override
    public int compareTo(Node1233 o) {//按照从大到小排序
        if(this.l!=o.l){
            return o.l-this.l;
        }else{
            return o.w-this.w;
        }
    }
}