[고득점 kit] 베스트 앨범

문제 설명

1. 속한 노래가 많이 재생된 장르를 먼저 수록합니다.

2. 장르 내에서 많이 재생된 노래를 먼저 수록합니다.

3. 장르 내에서 재생 횟수가 같은 노래 중에서는 고유 번호가 낮은 노래를 먼저 수록합니다.

제한사항

• genres[i]는 고유번호가 i인 노래의 장르입니다.

• plays[i]는 고유번호가 i인 노래가 재생된 횟수입니다.

• genres와 plays의 길이는 같으며, 이는 1 이상 10,000 이하입니다.

• 장르 종류는 100개 미만입니다.

• 장르에 속한 곡이 하나라면, 하나의 곡만 선택합니다.

• 모든 장르는 재생된 횟수가 다릅니다.

입출력 예

입출력 예 설명

• 고유 번호 3: 800회 재생

• 고유 번호 0: 500회 재생

• 고유 번호 2: 150회 재생

• 고유 번호 4: 2,500회 재생

• 고유 번호 1: 600회 재생

• 장르 별로 가장 많이 재생된 노래를 최대 두 개까지 모아 베스트 앨범을 출시하므로 2번 노래는 수록되지 않습니다.

class Solution {
    public int[] solution(String[] genres, int[] plays) {
        int[] answer = {};
        return answer;
    }
}

정답

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

class Solution {
	public int[] solution(String[] genres, int[] plays) {
		Map<String, List<Integer>> collectMap = new HashMap<>(); // 매개변수로 주어진 값들을 공통 장르끼리 모아두는 변수
		Map<String, List<Integer>> indexMap = new HashMap<>(); // 매개변수로 주어진 값들을 공통 장르끼리 모아두는 변수
		Map<String, Integer> countMap = new HashMap<>(); // 하나의 장르와 총 플레이 집계를 넣어두는 변수

		
		// collectMap에 장르와 장르에 맞는 인덱스를 수집해준다.
		for (int i = 0; i < genres.length; i++) {
			if (collectMap.containsKey(genres[i])) {
				collectMap.get(genres[i]).add(plays[i]);
				indexMap.get(genres[i]).add(i);
			} else {
				List<Integer> list = new ArrayList<>();
				list.add(plays[i]);
				collectMap.put(genres[i], list);
				List<Integer> indexList = new ArrayList<>();
				indexList.add(i);
				indexMap.put(genres[i], indexList);
			}
		}

		// 수집한 collectMap을 기준으로 하나의 장르와 총 플레이 집계를 계산
		for (Map.Entry<String, List<Integer>> entry : collectMap.entrySet()) {
			List<Integer> list = entry.getValue();
			int count = 0;
			for (int i = 0; i < list.size(); i++) {
				count += list.get(i);
			}
			countMap.put(entry.getKey(), count);
		}

		// countMap을 기준으로 값이 가장 높은 순서대로 정렬 후 List<String>으로 반환 (가장 높은 카운트를 들고있는 장르부터 우선순위로 등록됨)
		List<String> sortedKeys = countMap.entrySet().stream()
				.sorted(Map.Entry.<String, Integer>comparingByValue().reversed()).map(Map.Entry::getKey)
				.collect(Collectors.toList());

		// 결과 도출 시작
		List<Integer> resultList = new ArrayList<>();
		for (int j = 0; j < sortedKeys.size(); j++) {
			
			List<Integer> countList = collectMap.get(sortedKeys.get(j));
			List<Integer> indexList = indexMap.get(sortedKeys.get(j));
			
			// 사이즈가 1이라면 그냥 집어 넣는다
			if (countList.size() == 1) {
				resultList.add(indexList.get(0));
				continue;
				
			// 사이즈가 2이면서 서로 값이 같다면 그냥 집어 넣는다
			} else if (countList.size() == 2 && countList.get(0) == countList.get(1)) {
				resultList.add(indexList.get(0));
				resultList.add(indexList.get(1));
				continue;
			}

			int firstIndex = -1; // 첫번째로 반환할 인덱스
	        int secondIndex = -1; // 두번째로 반환할 인덱스
	        int firstCount = Integer.MIN_VALUE; // 계산에 필요한 카운트
	        int secondCount = Integer.MIN_VALUE; // 계산에 필요한 카운트
	        
			// 첫 번째 루프: 가장 높은 COUNT와 해당 인덱스 찾기
	        for (int i = 0; i < countList.size(); i++) {
	            if (countList.get(i) > firstCount) {
	                firstCount = countList.get(i);
	                firstIndex = indexList.get(i);
	            } else if (countList.get(i) == firstCount && indexList.get(i) < firstIndex) {
	                firstIndex = indexList.get(i);
	            }
	        }

	        // 두 번째 루프: 두 번째로 높은 COUNT와 해당 인덱스 찾기
	        for (int i = 0; i < countList.size(); i++) {
	            if (countList.get(i) > secondCount && indexList.get(i) != firstIndex) {
	                secondCount = countList.get(i);
	                secondIndex = indexList.get(i);
	            } else if (countList.get(i) == secondCount && indexList.get(i) < secondIndex && indexList.get(i) != firstIndex) {
	                secondIndex = indexList.get(i);
	            }
	        }
			resultList.add(firstIndex);
			resultList.add(secondIndex);
		}
		return resultList.stream().mapToInt(Integer::intValue).toArray();
	}
}

• 자세한 코드 설명은 주석을 참고

• 예외케이스를 쳐내는게 너무 힘들었다..