static final int INSERT_COMMAND = 1;
    static final int DELETE_COMMAND = 2;
    static final int SEARCH_COMMAND = 3;

    // Complete the freqQuery function below.
    static List<Integer> freqQuery(List<List<Integer>> queries) {
        List<Integer> answerList = new ArrayList<>();

        Map<Integer, Integer> numberMap = new HashMap<>();  // 저장할 숫자 기준으로 빈도수를 가지고 있는 맵
        Map<Integer, Integer> frequencyMap = new HashMap<>();  // 빈도수를 기준으로 몇개의 숫자가 있는지 관리하는 맵

        for (List<Integer> query : queries) {
            int command  = query.get(0);
            int num = query.get(1);

            switch (command) {
                case INSERT_COMMAND:
                    if (numberMap.containsKey(num)) { 
                        // 저장전 빈도수 관리맵에서 해당 숫자의 빈도수를 제거
                        frequencyMap.computeIfPresent(numberMap.get(num), (key, frequency) -> frequency - 1);
                    }

                    numberMap.merge(num, 1, Integer::sum);

                    // 저장후 빈도수 관리맵에서 해당 숫자의 빈도수를 추가
                    frequencyMap.compute(numberMap.get(num), (key, frequency) -> frequency == null ? 1 :  frequency + 1);
                    break;
                case DELETE_COMMAND:
                    if (numberMap.containsKey(num)) {
                        // 저장 명령어와 동일한 처리
                        frequencyMap.computeIfPresent(numberMap.get(num), (key, frequency) -> frequency - 1);
                    }

                    numberMap.computeIfPresent(num, (key, value) -> value > 0 ? value - 1 : 0);

                    if (numberMap.containsKey(num)) {
                        // 저장 명령어와 동일한 처리
                        frequencyMap.compute(numberMap.get(num), (key, frequency) -> frequency == null ? 1 : frequency + 1);
                    }
                    break;
                case SEARCH_COMMAND:
                    int answer =  frequencyMap.getOrDefault(num, 0) > 0 ? 1 : 0;
                    answerList.add(answer);
                    break;
            }
        }

        return answerList;
    }

    static int getMinimumCost(int k, int[] c) {
        List<Integer> descendingList = Arrays.stream(c).boxed()
                .sorted(Collections.reverseOrder())
                .collect(Collectors.toList());

        int minimizedCost = 0;
        int multiply = 0;  // 덤탱이 곱셈

        for (int i = 0; i < descendingList.size(); i++) {
            if (i % k == 0) {
                multiply++;
            }

            minimizedCost += (multiply) * descendingList.get(i);
        }

        return minimizedCost;
    }

    public static int sherlockAndAnagrams(String s) {
        Map<String, Integer> countMap = new HashMap<>();

        for (int i = 0; i < s.length(); i++) {
            for (int j = i + 1; j < s.length() + 1; j++) {
                // 부분 문자열을 알파벳 오름차순 순서로 변경하여 새로운 부분 문자열을 생성
                String a = s.substring(i, j).chars()
                        .sorted()
                        .mapToObj(ch -> String.valueOf((char) ch))
                        .collect(Collectors.joining());

                // 부분 문자열을 카운팅하는 해쉬맵에 저장
                countMap.merge(a, 1, Integer::sum);
            }
        }

        // 카운팅된 수를 기준으로 2개를 뽑아 조합한 값이 개별 경우의 수
        // 각 개별 경우의 수를 합한 값이 총 문자열의 Anagram 경우의 수
        return countMap.values().stream()
                .filter(value -> value > 1)
                .mapToInt(value -> value * (value - 1) / 2)
                .sum();
    }

    public static int maxMin(int k, int[] arr) {
        Arrays.sort(arr);

        int minimizedValue = Integer.MAX_VALUE;  // 최적해를 구하기전 임시값 설정

        for (int i = 0; i < arr.length - k + 1; i++) {
            // k개의 숫자 중 가장 큰 수와 작은 수의 차이를 구함
            int temp = arr[i + k - 1] - arr[i];

            if (minimizedValue > temp) {
                minimizedValue = temp;
            }
        }

        return minimizedValue;
    }

    public static int luckBalance(int k, int[][] contests) {
        sortOrderByImportantAndLuckValue(contests);

        int balance = 0;

        for (int i = 0; i < contests.length; i++) {
            if (contests[i][1] == 1) {
                if (k > 0) {
                    k--;        // 중요한 경기는 k번만 가능함
                    balance += contests[i][0];      // 이미 행운 값이 큰 순서로 정렬이 되어 있으므로 k번의 중요 경기는 모두 지는 것으로 간주
                } else {
                    balance -= contests[i][0];
                }
            } else {
                balance += contests[i][0];
            }
        }

        return balance;
    }

    /**
     * 중요도 높은 순서(중요 -> 비중요)로 우선 정렬(내림차순)
     * 중요도가 동일한 경우, 행운 값이 더 많은 순서로 정렬(내림차순)
     */
    public static void sortOrderByImportantAndLuckValue(int[][] arr) {
        Arrays.sort(arr, (a, b) -> {
            if (a[1] < b[1]) {
                return 1;
            } else if (a[1] == b[1]) {
                return b[0] - a[0];
            } else {
                return -1;
            }
        });
    }

    // 도서관 건설 최소 비용을 구함
    static long roadsAndLibraries(int n, int c_lib, int c_road, int[][] cities) {
        List<ArrayList<Integer>> roadGraph = initRoadGraph(n, cities);
        boolean[] visited = new boolean[n];

        long totalCost = 0;

        for (int i = 0; i < roadGraph.size(); i++) {
            if (!visited[i]) {
                if (c_lib > c_road) {
                    totalCost += c_lib + (c_road * (countNumberOfVisitsByDfs(i, visited, roadGraph) - 1));
                } else {
                    totalCost += c_lib * countNumberOfVisitsByDfs(i, visited, roadGraph);
                }
            }
        }

        return totalCost;
    }

    // 도시간 연결하는 그래프
    static List<ArrayList<Integer>> initRoadGraph(int n, int[][] cities) {
        List<ArrayList<Integer>> roadGraph = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            roadGraph.add(new ArrayList<>());
        }

        for (int i = 0; i < cities.length; i++) {
            roadGraph.get(cities[i][0] - 1).add(cities[i][1] - 1);
            roadGraph.get(cities[i][1] - 1).add(cities[i][0] - 1);
        }

        return roadGraph;
    }

    // 도시별 방문 횟수
    static long countNumberOfVisitsByDfs(int index, boolean[] visited, List<ArrayList<Integer>> roadGraph) {
        long cityVisitCount = 1;
        visited[index] = true;

        for (int i = 0; i < roadGraph.get(index).size(); i++) {
            if (!visited[roadGraph.get(index).get(i)]) {
                cityVisitCount += countNumberOfVisitsByDfs(roadGraph.get(index).get(i), visited, roadGraph);
            }
        }

        return cityVisitCount;
    }