Leetcode刷题 2021.03.14

Leetcode5702 找出星型图的中心节点

有一个无向的 星型 图，由 n 个编号从 1 到 n 的节点组成。星型图有一个 中心 节点，并且恰有 n - 1 条边将中心节点与其他每个节点连接起来。

给你一个二维整数数组 edges ，其中 edges[i] = [ui, vi] 表示在节点 ui 和 vi 之间存在一条边。请你找出并返回 edges 所表示星型图的中心节点。

昨天晚上做美团笔试，被折磨了两个小时，今天就不想周赛了。美团笔试也不是太难，但是力扣最多了有时候就会直接排除暴力解法，然后一直想最优解，导致浪费了很多时间。实际上很多时候暴力就能过一半以上的用例。最后五题a了3.6，还算可以吧，要是把浪费的时间利用上的话能做更多吧。下午看了看周赛，这次周赛还是比较简单的。Hard题也出的比较常规，也有好几百个人都做出来了。
这题感觉应该是简单难度，没什么好讲的。

class Solution {
    public int findCenter(int[][] edges) {
        int n = edges.length;
        //计算入度，看了题解实际上应该更简单，但是比赛的时候肯定是没时间想那么多的
        int[] map = new int[n + 2];
        for(int[] ele : edges){
            map[ele[0]]++;
            map[ele[1]]++;
        }
        int res = -1, max = 0;
        for(int i = 1; i < map.length; i++){
            if (map[i] > max){
                max = map[i];
                res = i;
            }
        }
        return res;
    }
}

Leetcode5703 最大平均通过率

一所学校里有一些班级，每个班级里有一些学生，现在每个班都会进行一场期末考试。给你一个二维数组 classes ，其中 classes[i] = [passi, totali] ，表示你提前知道了第 i 个班级总共有 totali 个学生，其中只有 passi 个学生可以通过考试。

给你一个整数 extraStudents ，表示额外有 extraStudents 个聪明的学生，他们 一定 能通过任何班级的期末考。你需要给这 extraStudents 个学生每人都安排一个班级，使得 所有 班级的 平均 通过率 最大 。

一个班级的 通过率 等于这个班级通过考试的学生人数除以这个班级的总人数。平均通过率 是所有班级的通过率之和除以班级数目。

请你返回在安排这 extraStudents 个学生去对应班级后的 最大 平均通过率。与标准答案误差范围在 10-5 以内的结果都会视为正确结果。

这题不难，但是卡了蛮久的。对于比较函数一直都不是很熟悉，还有double的转换。这题很明显的贪心思想，加入一个人，肯定是加入能使通过率提高最大的班级。提升的通过率可以简单的通分计算一下，然后用优先队列维护就行了。

class Solution {
    public double maxAverageRatio(int[][] classes, int extraStudents) {
    	//维护一个优先队列，按通过率提高幅度降序排列
        PriorityQueue<int[]> queue = new PriorityQueue<>(new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                double d1 = distance(o1);
                double d2 = distance(o2);
                if (d1 < d2){
                    return 1;
                }else{
                    return -1;
                }
            }
        });
        //加到队列
        for(int[] ele : classes){
            queue.offer(ele);
        }
        //不断维护
        while (extraStudents > 0){
            int[] temp = queue.poll();
            queue.offer(new int[]{temp[0] + 1, temp[1] + 1});
            extraStudents--;
        }
        double res = 0;
        int n = queue.size();
        //求结果
        while (!queue.isEmpty()){
            int[] temp = queue.poll();
            double ans = ((double) temp[0] / (double)temp[1]);
            res += ans;
        }
        return res / n;
    }
	
	//提升幅度计算实际就是(x + 1) / (y + 1) - x / y
    private double distance (int[] point){
        double x = (double)(point[1] - point[0]);
        double y = (double)(point[1] * (point[1] + 1));
        return x / y;
    }
}

Leetcode706 设计哈希映射

不使用任何内建的哈希表库设计一个哈希映射（HashMap）。

实现 MyHashMap 类：

MyHashMap() 用空映射初始化对象
void put(int key, int value) 向 HashMap 插入一个键值对 (key, value) 。如果 key 已经存在于映射中，则更新其对应的值 value 。
int get(int key) 返回特定的 key 所映射的 value ；如果映射中不包含 key 的映射，返回 -1 。
void remove(key) 如果映射中存在 key 的映射，则移除 key 和它所对应的 value 。

hard题明天再记录好了，今天的每日一题反而比较重要。面试也可能经常考，设计一个hashmap。没有涉及到扩容的函数还是比较简单的。就是需要对各个情况多做判断就行了。

class MyHashMap {

    /** Initialize your data structure here. */
    //创建Node类
    class Node{
        int key;
        int val;
        Node next;

        public Node(int key, int val){
            this.key = key;
            this.val = val;
        }
    }
    Node[] Entry;
    //Entry数组
    public MyHashMap() {
        Entry = new Node[857];
    }
    
    /** value will always be non-negative. */
    public void put(int key, int value) {
    	//计算索引值
        int index = hash(key);
        //先判断为空情况
        if (Entry[index] == null){
            Entry[index] = new Node(key, value);
            return;
        }
        Node cur = Entry[index];
        //否则就用拉链法，遍历链表判断，或者插在最后，get和remove类似的思路
        while (cur != null){
            if (cur.key == key){
                cur.val = value;
                return;
            }
            if (cur.next == null){
                cur.next = new Node(key, value); 
                return;
            }
            cur = cur.next;
        }
        
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    public int get(int key) {
        int index = hash(key);
        if (Entry[index] == null){
            return -1;
        }
        Node cur = Entry[index];
        while (cur != null){
            if (cur.key == key){
                return cur.val;
            }
            cur = cur.next;
        }
        return -1;
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    public void remove(int key) {
        int index = hash(key);
        if (Entry[index] == null) return;
        if (Entry[index].key == key){
            Entry[index] = Entry[index].next;
            return;
        }
        Node cur = Entry[index];
        while (cur.next != null){
            if (cur.next.key == key){
                cur.next = cur.next.next;
                return;
            }
            cur = cur.next;
        }
    }

    private int hash(int key){
        return key % 857;
    }
}