【java-array】1338. Reduce Array Size to The Half

Given an array arr. You can choose a set of integers and remove all the occurrences of these integers in the array.
Return the minimum size of the set so that at least half of the integers of the array are removed.

Example 1:

Input: arr = [3,3,3,3,5,5,5,2,2,7]
Output: 2
Explanation: Choosing {3,7} will make the new array [5,5,5,2,2] which has size 5 (i.e equal to half of the size of the old array).
Possible sets of size 2 are {3,5},{3,2},{5,2}.
Choosing set {2,7} is not possible as it will make the new array [3,3,3,3,5,5,5] which has size greater than half of the size of the old array.

Example 2:

Input: arr = [7,7,7,7,7,7]
Output: 1
Explanation: The only possible set you can choose is {7}. This will make the new array empty.

Example 3:

Input: arr = [1,9]
Output: 1

Example 4:

Input: arr = [1000,1000,3,7]
Output: 1

Example 5:

Input: arr = [1,2,3,4,5,6,7,8,9,10]
Output: 5

Constraints:

1 <= arr.length <= 10^5
arr.length is even.
1 <= arr[i] <= 10^5

Accepted
10,949
Submissions
16,555
只返回取出不同数字的个数。

answer one

Count the numbers' frequency
Create an array of lists, with the frequency being the key, the numbers with that frequency in the list.
Count backwards, return once half size is reached.

Time: O(N)
Space: O(N)

public int minSetSize(int[] arr) {
	Map<Integer, Integer> map = new HashMap<>();
	ArrayList<Integer>[] list = new ArrayList[arr.length + 1];
	
	for (int num : arr) {
		map.put(num, map.getOrDefault(num, 0) + 1);
	}

	for (int num : map.keySet()) {
		int count = map.get(num);
		if (list[count] == null) {
			list[count] = new ArrayList<Integer>();
		}
		list[count].add(num);
	}
	
	int steps = 0, res = 0;
	for (int i = arr.length; i > 0; i--) {
		List<Integer> cur = list[i];
		if (cur == null || cur.size() == 0) continue;
		for (int num : cur) {
			steps += i;
			res++;
			if (steps >= arr.length / 2)
				return res;
		}
	}
	return arr.length;
}

answer two

public int minSetSize(int[] arr) {
        Map<Integer, Integer> map = new HashMap<>();
        int len = arr.length;
        for(int i : arr){
            map.put(i, map.getOrDefault(i, 0) + 1);
            if(map.get(i) >= len/2) return 1;
        }
        
        List<Integer> orderedVal = new ArrayList<>(map.values());
        orderedVal.sort((a,b) -> b - a);
        
        int count = 0;
        int sum = 0;
        for(int val : orderedVal){
            sum += val;
            count++;
            if(sum >= len/2) return count;
        }
       return count;
    }

answer three

Count the occurrences of each number using a hash map.
Sort occurrences in the descending order using a multiset.
Greedily sum occurrences from largest to smallest until it's equal or greater the half size of the array.

int minSetSize(vector<int>& arr) {
    unordered_map<int, int> m;
    multiset<int, greater <int>> s;        
    for (auto n : arr) ++m[n];
    for (auto &p : m) s.insert(p.second);
    int res = 0, cnt = 0;
    for (auto it = begin(s); cnt * 2 < arr.size(); ++it) {
        ++res;
        cnt += *it;
    }
    return res;
}

Priority Queue Solution
Instead of using a multiset, we can use a priority queue, which is a good news for Java programmers 😃

int minSetSize(vector<int>& arr) {
    unordered_map<int, int> m;
    priority_queue<int> pq;
    for (auto n : arr) ++m[n];
    for (auto &p : m) pq.push(p.second);
    int res = 0, cnt = 0;
    while (cnt * 2 < arr.size()) {
        ++res;
        cnt += pq.top(); pq.pop();
    }
    return res;
}

Complexity Analysis

O(m log m), where m is the number of unique numbers. We sort occurrences for m unique numbers.
O(m) to store the occurrences of m unique numbers.

answer four

public int minSetSize(int[] arr) {
        int n = arr.length;
        PriorityQueue<Map.Entry<Integer, Integer>> pq = new PriorityQueue<>((e1, e2) -> (e2.getValue() - e1.getValue()));
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
            map.put(arr[i], map.getOrDefault(arr[i], 0) + 1);
        }
        pq.addAll(map.entrySet());
        int count = 0, res = 0;
        while (true) {
            count += pq.poll().getValue();
            res++;
            if (count >= n / 2) {
                break;
            }
        }
        return res;
    }