Task Scheduler: Minimum Time

/*
 * Problem : Least time.
 * Input   : Types and K.
 * Output  : The time.
 * Approach: Formula from the most frequent type
 * Time    : O(n)
 * Space   : O(types)
 * Java    : 8 or newer.
 */
import java.util.Scanner;

public class Main {
    // This method solves the task. It receives the input and returns the answer.
    static long solve(int[] a, int k) {
        // Step 1: Count each type. The most frequent type decides the shape of the schedule.
        java.util.Map<Integer, Integer> freq = new java.util.HashMap<Integer, Integer>();
        int maxCount = 0;
        for (int type : a) {
            int now = freq.merge(type, 1, Integer::sum);
            maxCount = Math.max(maxCount, now);
        }
        // Step 2: How many types have that same highest count? They all end the last row.
        int withMax = 0;
        for (int count : freq.values()) {
            if (count == maxCount) {
                withMax++;
            }
        }
        // Step 3: Make full rows of size K + 1, then a last row with the top types.
        // Idle time is only needed when the rows are not full.
        // Step 4: If other tasks fill every gap, the time is just the number of tasks.
        return Math.max(a.length, (long) (maxCount - 1) * (k + 1) + withMax);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int size = scanner.nextInt();
        int[] a = new int[size];
        for (int i = 0; i < size; i++) {
            a[i] = scanner.nextInt();
        }
        int k = scanner.nextInt();
        System.out.println(solve(a, k));
    }
}