20200806笔记.198.336（待）.213

198.打家劫舍①
是昨天做的打家劫舍三的最简单版，一样的dp思想

213
打家劫舍②，跟第一个一样，但是这回的房子是成环的。
我寻思要把头和尾都特殊判断，特殊处理一下呢，结果答案很巧妙啊
由于头和尾不共存，所以就可以拆分成两个198问题。

收获：
Array.copyOfRange,from是包括在新数组的，但是to是不包括的，截断到to前一位

336.回文对，每日一题，真难啊。我不会，我就是写暴力都不一定写对，还会超时。

关于PriorityQueue，可以用于获得最小值或者最大值
Queue<> q = new PriorityQueue<>();
默认升序排列，对象队列可以自定义比较器，写在（）里
比较器两个参数i1，i2
如果想降序排列，返回用后一个参数减去前一个参数

static Comparator<Integer> cmp = new Comparator<Integer>() {
      public int compare(Integer e1, Integer e2) {
        return e2 - e1;
      }
    };

https://www.cnblogs.com/wei-jing/p/10806236.html
如何自定义对象的比较器

class Node{
    public Node(int chang,int kuan)
    {
        this.chang=chang;
        this.kuan=kuan;
    }
    int chang;
    int kuan;
}

public class Test {
　　　　//自定义比较类，先比较长，长升序排列，若长相等再比较宽，宽降序
    static Comparator<Node> cNode=new Comparator<Node>() {
        public int compare(Node o1, Node o2) {
            if(o1.chang!=o2.chang)
                return o1.chang-o2.chang;
            else
                return o2.kuan-o1.kuan;
        }
        
    };
    public static void main(String[] args) {
        Queue<Node> q=new PriorityQueue<>(cNode);
        Node n1=new Node(1, 2);
        Node n2=new Node(2, 5);
        Node n3=new Node(2, 3);
        Node n4=new Node(1, 2);
        q.add(n1);
        q.add(n2);
        q.add(n3);
        Node n;
        while(!q.isEmpty())
        {
            n=q.poll();
            System.out.println("长: "+n.chang+" 宽：" +n.kuan);
        }
　　　　　/**
　　　　　　* 输出结果
　　　　　　* 长: 1 宽：2
　　　　　　* 长: 2 宽：5
　　　　　　* 长: 2 宽：3
　　　　　　*/
    }
}