力扣 第79场双周赛

力扣 第79场双周赛

6083. 判断一个数的数字计数是否等于数位的值

啪的一下很快呀

class Solution {
	public boolean digitCount(String num) {
		int len = num.length();
		int[] nums = new int[10];
		for(int i = 0; i < num.length(); i++){
			nums[Character.getNumericValue(num.charAt(i))]++;
		}
		for(int i = 0; i < num.length(); i++){
			if(Character.getNumericValue(num.charAt(i)) == nums[i]){
				continue;
			}else {
				return false;
			}
		}
		return true;
		

	}
}

6084.最多单词数的发件人

啪的一下，答案错误，很快呀，修修改改，注意细节，不要紧张

class Solution {
    public String largestWordCount(String[] messages, String[] senders) {
		String res = "";
		int ms = messages.length;
		int sd = senders.length;
		int len = -1;
		HashMap<String, Integer> map = new HashMap<>();
		for(int i = 0; i < sd; i++){
			int cur = messages[i].replaceAll(" ", ",,").length() - messages[i].length() + 1;
			if(!map.containsKey(senders[i])){
				map.put(senders[i], cur);
			}else {
				map.put(senders[i], map.get(senders[i]) + cur);
			}
			if(map.get(senders[i]) > len){
				res = senders[i];
				len = map.get(senders[i]);
			}else if(map.get(senders[i]) == len && res.compareTo(senders[i]) < 0){
				res = senders[i];
				len = cur;
			}
            if(senders[i].equals("FnZd")){
                System.out.println(len + " " + res);
                System.out.println(cur);
            }
		}
		System.out.println(len + " " + res);
		return res;
	}
}

6085. 道路的最大总重要性

啪的一下很快呀，简简单单哈，优先队列，但代码很烂，得学习别人的代码

class Solution {
    class Node{
		int key;
		int val1;
		
		Node(int key, int val1){
			this.key = key;
			this.val1 = val1;
		}

		public int getKey() {
			return key;
		}

		public void setKey(int key) {
			this.key = key;
		}

		public int getVal() {
			return val1;
		}

		public void setVal(int val) {
			this.val1 = val;
		}
	}
	public long maximumImportance(int n, int[][] roads) {
		int[] val = new int[n];
		int[] temp = new int[n];
		long res = 0;
		for (int i = 0; i < roads.length; i++){
			val[roads[i][0]]++;
			val[roads[i][1]]++;
		}
		PriorityQueue<Node> priorityQueue = new PriorityQueue<>(new Comparator<Node>() {
			@Override
			public int compare(Node o1, Node o2) {
				if(o1.val1 > o2.val1){
					return -1;
				}else if(o1.val1 < o2.val1){
					return 1;
				}
				return 0;
			}
		});
		for(int i = 0; i < val.length; i++){
			Node cur = new Node(i, val[i]);
			priorityQueue.add(cur);
		}
		int len = priorityQueue.size();
		for(int i = 0; i < len; i++){
			Node per = priorityQueue.poll();
            System.out.println(per.key + " " + per.val1);
			temp[per.key] = n--; 
		}

		for (int i = 0; i < roads.length; i++){
			res += temp[roads[i][0]] + temp[roads[i][1]];
		}
		return res;

	}
}

别人滴代码，真优美

class Solution {
    public long maximumImportance(int n, int[][] roads) {
        int[] cnts = new int[n]; // 存每个节点的边的个数
        int len = roads.length;
        for (int i = 0; i < len; ++i) {
            cnts[roads[i][0]]++;
            cnts[roads[i][1]]++;
        }
        Arrays.sort(cnts);
        long ans = 0;
        for (int i = 0; i < n; ++i) {
            ans += (i + 1L) * cnts[i]; // 注意1L使得在计算值的过程中转为long计算, 否则可能会溢出int
        }
        return ans;
    }
}

10011. 以组为单位订音乐会的门票

啪的一下，很快啊，答案错误啊，一看结构设计，数据弱，直接模拟以为，没想到啊，是线段树呀

class BookMyShow {
    int n, m;
    int[] min;
    long[] sum;

    public BookMyShow(int n, int m) {
        this.n = n;
        this.m = m;
        min = new int[n * 4];
        sum = new long[n * 4];
    }

    public int[] gather(int k, int maxRow) {
        int i = index(1, 1, n, maxRow + 1, m - k);
        if (i == 0) return new int[]{}; // 不存在
        var seats = (int) query_sum(1, 1, n, i, i);
        add(1, 1, n, i, k); // 占据 k 个座位
        return new int[]{i - 1, seats};
    }

    public boolean scatter(int k, int maxRow) {
        if ((long) (maxRow + 1) * m - query_sum(1, 1, n, 1, maxRow + 1) < k) return false; // 剩余座位不足 k 个
        // 从第一个没有坐满的排开始占座
        for (var i = index(1, 1, n, maxRow + 1, m - 1); ; ++i) {
            var left_seats = m - (int) query_sum(1, 1, n, i, i);
            if (k <= left_seats) { // 剩余人数不够坐后面的排
                add(1, 1, n, i, k);
                return true;
            }
            k -= left_seats;
            add(1, 1, n, i, left_seats);
        }
    }

    // 将 idx 上的元素值增加 val
    void add(int o, int l, int r, int idx, int val) {
        if (l == r) {
            min[o] += val;
            sum[o] += val;
            return;
        }
        var m = (l + r) / 2;
        if (idx <= m) add(o * 2, l, m, idx, val);
        else add(o * 2 + 1, m + 1, r, idx, val);
        min[o] = Math.min(min[o * 2], min[o * 2 + 1]);
        sum[o] = sum[o * 2] + sum[o * 2 + 1];
    }

    // 返回区间 [L,R] 内的元素和
    long query_sum(int o, int l, int r, int L, int R) { // L 和 R 在整个递归过程中均不变，将其大写，视作常量
        if (L <= l && r <= R) return sum[o];
        var sum = 0L;
        var m = (l + r) / 2;
        if (L <= m) sum += query_sum(o * 2, l, m, L, R);
        if (R > m) sum += query_sum(o * 2 + 1, m + 1, r, L, R);
        return sum;
    }

    // 返回区间 [1,R] 中 <= val 的最靠左的位置，不存在时返回 0
    int index(int o, int l, int r, int R, int val) { // R 在整个递归过程中均不变，将其大写，视作常量
        if (min[o] > val) return 0; // 说明整个区间的元素值都大于 val
        if (l == r) return l;
        var m = (l + r) / 2;
        if (min[o * 2] <= val) return index(o * 2, l, m, R, val); // 看看左半部分
        if (m < R) return index(o * 2 + 1, m + 1, r, R, val); // 看看右半部分
        return 0;
    }
}

暴力

class BookMyShow {
    long linehas[];
    long m;
    public BookMyShow(int n, int m) {
        linehas = new long[n];
        this.m = m;
    }
    
    public int[] gather(int k, int maxRow) {
        for(int i = 0; i <= maxRow; i ++){
            if (m - linehas[i] >= k){
                int idx = (int)linehas[i];
                linehas[i] += k;
                return new int[] {i, idx};
            }
        }
        return new int[]{};
    }
    
    public boolean scatter(int k, int maxRow) {
        long allhas = 0;
        for(int i = 0; i <= maxRow; i ++) {
            allhas += (long)m - (long)linehas[i];
        }
        if (allhas >= k) {
            for(int i = 0; i <= maxRow; i ++) {
                long has = m - linehas[i];
                if (k >= has){
                    linehas[i] = m;
                    k -= has;
                }else {
                    linehas[i] += k;
                    k = 0;
                }
            }
            return true;
        }
        return false;
    }
}

/**
 * Your BookMyShow object will be instantiated and called as such:
 * BookMyShow obj = new BookMyShow(n, m);
 * int[] param_1 = obj.gather(k,maxRow);
 * boolean param_2 = obj.scatter(k,maxRow);
 */