每日一题（刷题记录）

H指数 10.7

给你一个整数数组 citations ，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数。计算并返回该研究者的 h 指数。

根据维基百科上 h 指数的定义：h 代表“高引用次数” ，一名科研人员的 h 指数 是指他（她）至少发表了 h 篇论文，并且每篇论文 至少 被引用 h 次。如果 h 有多种可能的值，h 指数 是其中最大的那个。

示例 1：输入：citations = [3,0,6,1,5] 输出：3

解释：给定数组表示研究者总共有 5篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5次。由于研究者有 3 篇论文每篇 至少 被引用了 3
次，其余两篇论文每篇被引用 不多于 3 次，所以她的 h 指数是 3。

示例 2：输入：citations = [1,3,1] 输出：1

class Solution {
    public int hIndex(int[] citations) {
        Arrays.sort(citations);
        for(int i=0;i=citations.length-i)
            {
                return Math.min(citations[i],citations.length-i);
            }
        }
        return 0;
    }
}

该解决方案首先对传入的引用次数组进行排序。然后，通过遍历排序后的数组，从最低引用次开始，检查是否存在至少有citations.size() - i次引用的论文数量。如果存在，则返回当前引用次和剩余未遍历的论文数量中较小的那个值作为H指数。如果不满足条件，则返回0。

O(1)时间复杂度增删获取随即元素

实现RandomizedSet 类：

• RandomizedSet() 初始化 RandomizedSet 对象
• bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 。
• bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。
• int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 相同的概率 被返回。

你必须实现类的所有函数，并满足每个函数的 平均 时间复杂度为 O(1) 。

示例：

输入
["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
[[], [1], [2], [2], [], [1], [2], []]
输出
[null, true, false, true, 2, true, false, 2]

解释
RandomizedSet randomizedSet = new RandomizedSet();
randomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。
randomizedSet.remove(2); // 返回 false ，表示集合中不存在 2 。
randomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
randomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。
randomizedSet.remove(1); // 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
randomizedSet.insert(2); // 2 已在集合中，所以返回 false 。
randomizedSet.getRandom(); // 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。

提示：

• -231 <= val <= 231 - 1
• 最多调用 insert、remove 和 getRandom 函数 2 * 105 次
• 在调用 getRandom 方法时，数据结构中 至少存在一个 元素。

class RandomizedSet {
    ArrayList list;
    public RandomizedSet() {
        this.list=new ArrayList<>();
    }

    public boolean insert(int val) {
        if(list.contains(val))return false;
        list.add(val);
        return true;
    }

    public boolean remove(int val) {
        if(list.contains(val))
        {
            list.remove((Integer) val);
            return true;
        }
        return false;

    }

    public int getRandom() {
        Random random=new Random();
        int x=random.nextInt(list.size());
        return list.get(x);
    }
}

 此题实现很简单，有个雷，就是remove方法，要类型转换，不然删除的就是下标为val的值而不是元素val，淦！ex！又是想念c++的一天~

查找最小K对数字 

对列表排序（暴力做法）（想念c++的第10086天~呜呜呜）

class Solution {
    public List> kSmallestPairs(int[] nums1, int[] nums2, int k) {
        List> arr=new ArrayList<>();
        if(nums1.length==0||nums2.length==0||k==0)return arr;
        PriorityQueue minHeap = new PriorityQueue<>();
        for(int i=0;i0&&!minHeap.isEmpty())
        {
            Nums c=minHeap.poll();
            Listlist=new ArrayList<>();
            list.add(c.a);
            list.add(c.b);
            arr.add(list);
        }
        return arr;
    }
}
class Nums implements Comparable{
    int a,b,sum=0;
    public Nums(int a,int b)
    {
        this.a=a;
        this.b=b;
        this.sum=a+b;
    }

    @Override
    public int compareTo(Nums o) {
        return this.sum-o.sum;
    }
}

堆优化+lamdba表达式

class Solution {
    public List> kSmallestPairs(int[] nums1, int[] nums2, int k) {
        List> arr=new ArrayList<>();
        if(nums1.length==0||nums2.length==0||k==0)return arr;
        PriorityQueue minHeap = new PriorityQueue((a, b) -> a[0] - b[0]);
        for (int i = 0; i < Math.min(nums1.length, k); i++) {
            minHeap.offer(new int[]{nums1[i]+nums2[0],i,0});
        }
        while(k>0&&!minHeap.isEmpty())
        {
            int c[]=minHeap.poll();
            Listlist=new ArrayList<>();
            if (c[2]+1