hyoding

[프로그래머스 고득점 Kit/Java] 더 맵게

효딩 — Tue, 15 Apr 2025 00:44:01 +0900

배열의 모든 값이 K(스코빌 지수) 이상이 될 때까지

가장 낮은 두 개의 음식을 특별한 방법으로 섞는다.

가장 맵지 않은 음식의 스코빌 지수 + (두 번째로 맵지 않은 음식의 스코빌 지수 * 2)

모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 섞어야 하는 최소 횟수를 return 한다.

원래는 ArrayList를 만들어 스코빌 지수를 넣고

매번 정렬을 하려고 했다.

그러나 시간 + 정확도 테스트에서 모두 점수를 제대로 받지 못했다.

그러던 중 우선순위 큐를 사용해야 함을 알게 됐다.

우선순위 큐는 일반적인 큐와 달리, 들어가는 순서와 상관없이 우선순위가 높은 데이터가 먼저 나가므로

따로 정렬을 해줄 필요가 없어 기존 방식에 비해 훨씬 효율적이다.

// 기본형: 우선순위가 낮은 숫자가 먼저 나옴 (작은 숫자)
PriorityQueue<Integer> pQ = new PriorityQueue<>();
 
// 우선순위가 높은 숫자가 먼저 나옴 (큰 숫자)
PriorityQueue<Integer> pQ = new PriorityQueue<>(Collections.reverseOrder());

이걸 이용해서 해결한 방식은 다음과 같다.

PriorityQueue 사용

import java.util.*;
import java.io.*;
class Solution {
    public int solution(int[] scoville, int K) {
        int cnt = 0;
        
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        for (int scov : scoville) {
            pq.offer(scov);
        }
        
        while (true) {
            int first = pq.poll();
            if (first >= K) return cnt;
            if (pq.size() < 1) return -1;
            int second = pq.poll();
            pq.offer(first + (second * 2));
            cnt++;
        }
    }
}

여기서 또 하나 주의할 점이 있었는데,

문제에서 "모든 음식의 스코빌 지수를 K 이상으로 만들 수 없는 경우 -1을 return" 하라고 했다.

따라서 첫 번째 숫자(가장 낮은 스코빌 지수)가 K 이하인데,

pq의 size가 1보다 작다면 (모든 수를 다 poll했는데도 K 이상이 없었다면) -1을 return 해준다.

[BOJ 길라잡이/Java] 14일차 #9095 1, 2, 3 더하기

효딩 — Sun, 6 Apr 2025 15:34:18 +0900

알고리즘 분류

- 다이나믹 프로그래밍

주어진 정수 n(양수, 11보다 작음)을 1, 2, 3의 합으로 나타내는 방법의 수를 구하는 문제다.

공책에 쭉쭉 경우의 수를 적다가 규칙을 발견했다.

cases[n] = cases[n-1] + cases[n-2] + cases[n-3]

이렇게 n의 방법의 수는 n-1, n-2, n-3의 방법의 수를 모두 합친 것과 같다는 것이었다.

써내려가다보니

cases[1] = 1

cases[2] = 2

cases[3] = 4

cases[4] = 7

cases[5] = 13

cases[6] = 24

cases[7] = 44

cases[8] = 81

cases[9] = 149

cases[10] = 274

이런 식으로 값이 나왔다.

작성한 코드는 다음과 같다.

import java.util.*;
import java.io.*;

class Main {
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int T = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < T; i++) {
            int n = Integer.parseInt(br.readLine());
            sb.append(dp(n)).append("\n");
        }

        System.out.println(sb);
                
    }

    private static int dp(int n) {
        if (n == 1) {
            return 1;
        } else if (n == 2) {
            return 2;
        } else if (n == 3) {
            return 4;
        } else {
            return dp(n-1) + dp(n-2) + dp(n-3);
        }
    }
}

예전에 풀었던 방법을 보니

어차피 n이 11보다 작다고 문제에 주어져 있으므로

dp[4]부터 dp[10]까지 값을 모두 구한 뒤

n에 해당하는 값만 출력해도 됐다.

이게 이전에 작성했던 코드다.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    static int[] dp = new int[11];
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());

        dp[1] = 1; // 1
        dp[2] = 2; // 1+1, 2
        dp[3] = 4; // 1+1+1, 1+2, 2+1, 3

        for (int i = 4; i < 11; i++) {
            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
        }

        for (int i = 0; i < T; i++) {
            int n = Integer.parseInt(br.readLine());
            System.out.println(dp[n]);
        }
    }
}

[프로그래머스 고득점 Kit/Java] 기능개발

효딩 — Wed, 2 Apr 2025 15:40:06 +0900

깔깔

답지를 볼까 수많은 유혹의 생각들이 들었지만

보지 않고 스스로의 힘으로 해냈다

이렇게 발전해나가는 나..

제법 대견할지도?

각설하고,

문제를 풀어보자!

각 기능은 진도가 100%일 때 서비스에 반영할 수 있다.

또, 각 기능의 개발 속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있지만,

뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포된다.

배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와

각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때

각 배포마다 몇 개의 기능이 배포되는지를 return 하는 문제다.

import java.util.*;

class Solution {
    public int[] solution(int[] progresses, int[] speeds) {
        int[] answer = {};
        ArrayList<Integer> q = new ArrayList<>();
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < speeds.length; i++) {
            int num = (100 - progresses[i]) / speeds[i];
            if ((100 - progresses[i]) % speeds[i] != 0) {
                num++;
            }
            q.add(num);
        }
        
        int last = q.get(0);
        int index = 0;
        int cnt = 0;
        
        while(true) {
            if (index >= speeds.length) {
                list.add(cnt);
                break;
            }
            if (last < q.get(index)) {
                list.add(cnt);
                last = q.get(index);
                cnt = 0;
            } else {
                index++;
                cnt++;
            }
        }
        return list.stream().mapToInt(i->i).toArray();
    }
}

처음에는 queue를 사용해서

앞에서부터 하나씩 poll()할까 생각했지만,

queue는 index를 사용하지 못해서

내가 생각하는 방법에 적용할 수 없었고 arraylist로 변경했다.

먼저 배열에

(100 - progress(작업진도)) / speed(작업속도)를 넣어준다.

앞으로 100%가 될 때까지 며칠이 걸리는지를 나타낸다.

이때 주의해야 할 점은

만약 나머지가 있다면 올림해주어야 한다는 것이다.

그렇게 하고 last에 배열의 첫 번째 값을 저장,

index와 cnt는 0으로 초기화한 후

index를 마지막까지 돌며

다음 과정을 거친다.

- index가 배열 길이에 도달하면 마지막 cnt값을 list에 넣고 종료한다.

- last 값이 해당 index에 해당하는 배열 값보다 작으면

지금까지 쌓인 cnt값을 배열에 넣고, last를 해당 index의 값으로 바꾸고

cnt는 0으로 초기화한다.

- last 값이 해당 index에 해당하는 배열 값보다 크거나 같으면

함께 배포되어야할 친구들이므로 index와 cnt를 1씩 늘려주고

다음으로 넘어간다.

마지막에는 list를 int배열로 바꿔 출력하면 된다.

원래 생각한대로 queue를 사용한다면 어땠을까?

import java.util.*;

class Solution {
    public int[] solution(int[] progresses, int[] speeds) {
        Queue<Integer> days = new LinkedList<>();
        
        for (int i = 0; i < progresses.length; i++) {
            int day = (100 - progresses[i]) / speeds[i];
            if ((100 - progresses[i]) % speeds[i] != 0) {
                day++;
            }
            days.add(day);
        }
        
        List<Integer> result = new ArrayList<>();
        int current = days.poll();
        int count = 1;
        
        while (!days.isEmpty()) {
            if (days.peek() <= current) {
                days.poll();
                count++;
            } else {
                result.add(count);
                current = days.poll();
                count = 1;
            }
        }
        result.add(count); // 마지막 묶음
        
        return result.stream().mapToInt(i -> i).toArray();
    }
}

[BOJ 길라잡이/Java] 13일차 #1182 부분수열의 합

효딩 — Tue, 1 Apr 2025 15:36:44 +0900

알고리즘 분류

- 브루트포스 알고리즘

- 백트래킹

주어진 수열의 부분수열 중 원소를 다 더한 값이 S가 되는 경우의 수를 구하는 문제다.

문제를 보고 depth를 하나씩 더해나가면서 백트래킹으로 풀어야겠다

까지는 생각했는데 그걸 어떻게 구현해야 할지는 감이 안 왔다.

구글링 통해 알아낸 방법을 이해하려 노력했다.

import java.util.*;
import java.io.*;

class Main {
    static int N, S, cnt;
    static int[] arr;
    
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        S = Integer.parseInt(st.nextToken());

        arr = new int[N];
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }

        dfs(0, 0);
        if (S == 0) cnt--; // 공집합 제외
        System.out.println(cnt);
                
    }

    public static void dfs(int depth, int sum) {
        if (depth == N) {
            if (sum == S) cnt++;
            return;
        }

        dfs(depth + 1, sum + arr[depth]); // 원소를 선택한 경우
        dfs(depth + 1, sum); // 원소를 선택하지 않은 경우
    }
}

이 함수는 모든 부분 수열을 탐색한다.

(2^N개의 조합을 체크)

선택 or 선택하지 않음의 2갈래로 분기하는 재귀

[프로그래머스 고득점 Kit/Java] 같은 숫자는 싫어

효딩 — Tue, 1 Apr 2025 12:44:29 +0900

배열 arr에서 연속적으로 나타나는 숫자를 하나만 남기고 제거해야 한다.

이때 제거된 후 남은 수들은 배열 arr의 원소들의 순서를 유지해야 한다.

처음에는 문제를 제대로 안 읽고

set을 사용해서 중복을 제거하려고 했지만,

연속적으로 나타나는 숫자를 하나로 남기는 문제이므로 set은 사용할 수 없음을 알았다.

그래서 생각한 방법은

앞에 숫자랑 비교해서 일치하지 않는 경우에만 list에 추가하고,

마지막에 list를 arr로 바꿔 출력하는 것이었다.

정확성 테스트, 효율성 테스트 모두 통과했다.

import java.util.*;

public class Solution {
    public int[] solution(int []arr) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(arr[0]);
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] != arr[i - 1]) {
                list.add(arr[i]);
            }
        }
        int[] answer = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            answer[i] = list.get(i);
        }
        // list.stream().mapToInt(i->i).toArray();
        return answer;
    }
}

구글링해보니 스택을 사용하는 방법도 있었다.

전체적인 플로우는 같았다.

import java.util.*;

public class Solution {
    public int[] solution(int []arr) {
        Stack<Integer> stack = new Stack<>();
        
        for (int i : arr) {
            if (stack.isEmpty() || !stack.peek().equals(i)) {
            stack.push(i);
        }
        
        return stack.stream().mapToInt(i->i).toArray();
    }
}

[BOJ 길라잡이/Java] 12일차 #6603 로또

효딩 — Sat, 29 Mar 2025 14:02:54 +0900

알고리즘 분류

- 수학

- 조합론

- 백트래킹

- 재귀

크기가 k인 집합 S가 주어졌을 때 그 중 6개를 고를 수 있는

경우의 수를 모두 출력하는 문제다.

머릿속으로는 kC6 경우의 수를

집합 S에서 해당 index 찾아 출력하면 되겠다~

생각했는데, 코드로 어떻게 combination을 구현하는지 몰라서 헤맸다.

찾아보니 재귀와 백트래킹을 사용해야 하는 문제였다.

아직 나에게는 너무나 낯선 백트래킹 구현...

머리로는 알겠는데 코드로 구현하는게 쉽지 않은 것 같다.

import java.util.*;
import java.io.*;

class Main {
    static int k;
    static int[] S, numbers;
    static StringBuilder sb;
    
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        sb = new StringBuilder();
        
        while(true) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            k = Integer.parseInt(st.nextToken());
            if (k == 0) {
                break;
            }
            S = new int[k];
            numbers = new int[6];
            
            for (int i = 0; i < k; i++) {
                S[i] = Integer.parseInt(st.nextToken());
            }

            combi(0, 0);
            sb.append("\n");
        }

        System.out.println(sb);
        
    }

    public static void combi(int depth, int start) {
        if (depth == 6) {
            for (int i = 0; i < 6; i++) {
                sb.append(numbers[i]).append(" ");
            }
            sb.append("\n");
            return;
        }
        for (int i = start; i < k; i++) {
            numbers[depth] = S[i]; // 현재 depth(위치)에 숫자 저장
            combi(depth + 1, i + 1); // 다음 자리로 이동, 중복 방지를 위해 i+1부터 시작
        }
    }
}

combi(0, 0)으로 조합 생성을 시작한다.

depth = 0: 현재까지 고른 숫자 수

start = 0: 시작 인덱스

아직 6개가 안 골라졌다면 start부터 k까지 반복하며 숫자를 선택하고,

6개를 고르면 numbers[] 배열을 출력한다.

i+1부터 시작하므로 중복 없이 오름차순 조합이 만들어진다.

[프로그래머스 고득점 Kit/Java] 전화번호 목록

효딩 — Sat, 29 Mar 2025 10:57:36 +0900

다음과 같이 풀었다.

성공 코드

import java.util.*;
class Solution {
    public boolean solution(String[] phone_book) {
        Arrays.sort(phone_book);
        for (int i = 0; i < phone_book.length - 1; i++) {
            String phone = phone_book[i];
            if (phone_book[i + 1].startsWith(phone)) {
                return false;
            }
        }
        return true;
    }
}

처음에는 아래와 같이 j의 범위를 i + 1부터 phone_book.length까지로 설정했다.

실패 코드

import java.util.*;
class Solution {
    public boolean solution(String[] phone_book) {
        Arrays.sort(phone_book);
        for (int i = 0; i < phone_book.length - 1; i++) {
            String phone = phone_book[i];
            for (int j = i + 1; j < phone_book.length; j++) {
                if (phone_book[j].startsWith(phone)) {
                    return false;
                }
            }
        }
        return true;
    }
}

그랬더니 정확성은 테스트는 모두 통과했는데

효율성 테스트의 테스트3, 4를 시간 초과로 통과하지 못했다.

도저히 모르겠어서 힌트를 구한 결과

Arrays.sort로 사전순 정렬을 했으니,

내 바로 뒤에 있는 문자열과만 비교해도

접두어인지 아닌지를 판별할 수 있다는 것을 알게 됐다.

따라서 j의 범위를 따로 설정하지 않고,

i번째 문자열과 i+1번째 문자열을 비교해서

i번째 문자열이 i+1번째 문자열의 접두어인지 확인했다.

모든 정확성 테스트와 효율성 테스트를 통과했다!

2025 아시아태평양 금융포럼 (APFF) 참석 후기

효딩 — Thu, 27 Mar 2025 00:29:49 +0900

오늘 좋은 기회로 아주경제 주최 '2025 아시아태평양 금융포럼'에 참석했다.

금융 IT에 관심이 있고 입사를 꿈꾸는 취준생 입장에서

세계 경제의 불확실성과 양극화 문제를 알아보고,

해당 상황에서 당국은 어떻게 대응해야 할 지 전문가들의 견해를 들어보고 싶어서

서포터즈를 신청했다. ~~(10만원 상당의 호텔 중식에도 끌린 건 안 비밀)~~

https://linkareer.com/activity/230410

2025 아시아태평양금융포럼(Asia-Pacific Financial Forum) 서포터즈 모집 | 공모전 대외활동-링커리어

대외활동인 2025 아시아태평양금융포럼(Asia-Pacific Financial Forum) 서포터즈 모집입니다. 혜택으로는 사은품 지급, 수료증 및 인증서 등이 있습니다.

linkareer.com

9시 시작이라 8시반까지 가서 안내를 받고 들어갔다.

이번 행사는 웨스틴 조선 서울 1층 그랜드불룸에서 진행 되었다.

너무 멋져..

전날 담당자님으로부터 받은 진행순서를 확인했을 때도 크고 공식적인 행사임은 직감했지만,

행사장에 들어가서 규모에 한 번 놀라고

내빈소개에 두 번 놀랐다. (내가 평생 볼 기회..가 있을까 싶은 분들이 ..)

일단 이번 포럼의 주제가

트럼프 2기(Second Presidency of Trump)

글로벌 분극화 시대, 금융의 위기와 기회

인 만큼, 대부분의 이야기가 트럼프의 관세 정책 및 금융 불확실성과 연관 됐다.

사실 모든 이야기가 관련이 있었다 해도 과언이 아니다.

4월 2일에 있을 트럼프의 상호관세부과,

딥시크 쇼크와 함께 급부상한 중국 시장,

비정상적으로 높아진 원화 환율,

작년 하반기부터 격화된 우리나라 정치 갈등과 탄핵 이슈,

치솟은 집값,

출산율 감소 및 고령화, 그리고 인구 감소까지

그야말로 우리나라는 현재 "혼돈의 시기"다.

모리스 옵스펠드 UC 버클리 교수님께서는 (무려 IMF 수석 이코노미스트..)

앞서 언급한 문제들 외에도

우리나라 산업의 불균형, 칩 과다 공급, 국방비 문제 등

당국이 직면한 경제 상황들을 언급하시고

WTO rules에 따른(rule-based) 무역 유지와 협력을 포함하여

한국이 어떻게 이 문제들을 해결해나갈 수 있을지 조언해주셨다.

교수님의 발표와 1:1 좌담회 후에는

글로벌 패권 경쟁과 한국의 선택

이라는 주제로

두 강연을 들었다.

가장 주목할 현 상황은

1) 최근 중국이 급부상 하면서

미국 중심의 공급망이 재편되고 있고,

2) 트럼프 정부가 들어선 2개월 간

상호관세, 친가상자산 등의 정책들로 큰 변동성이 있었으며,

3) 곧 있을 트럼프 정부의 상호관세부과로 인해

경제 불확실성이 상당히 크다는 것이다.

그리고 앞으로 당분간은 이런 기조가 유지될듯 싶다.

세계는 탈세계화의 흐름을 타고 있고,

자국우선주의 및 보호 정책이 지속될 가능성이 높다.

이러한 상황에서 한국 경제는 근본적인 변화를 직시하고,

관세 정책에 대응하기 위해 대응책을 찾아야 한다.

강연 중 말씀해주신 바에 의하면

SMR, 조선업 등 협력 유망분야 제시,

적극적이고 유연한 협상을 위한 대응 논리 마련

등의 방법들이 있다.

+) 트럼프의 친가상자산 정책과 관련해서는

우리나라 역시 가상자산을 무조건 규제하기 보다는

블록체인 인프라와 거래소의 글로벌 경쟁력 지원 등이 필요하다.

이렇게 오전 강연이 끝나고,

아기다리고기다리던 코 스 요 리 등장이시다.

진심으로 감동적인 맛이었읍니다...

멋진 강연과 함께 맛있는 음식까지..

거지 바보 아기 취준생이 마다할 이유가 없잖아 !!!

이후 오후 강연이 시작되었다.

난 이때 진행된 "양극화 시대, 한국 금융의 방향" 토론을

진행된 행사 중 가장 재미있게 들었다.

좌장으로 참석해주신 김용진 서강대학교 교수님을 비롯해

금융감독원 국장님, 우리은행 선임연구원님, 하나금융연구소 연구위원님, KDI 팀장님

이렇게 어마어마하신 분들이.. 토론을 이어가셨다.

가장 인상깊었던 건

우리나라 원화 약세는 금융 위기로는 이어지지 않을 것이며,

1) 실물경기자본 양극화

2) 금융자본 양극화

로 수급이 꼬여서 나타나는 문제라고 말씀하신 부분이었다.

우리나라 정치적 이슈가 해결되면 원화 환율은 안정화를 찾아갈 것이라고도 첨언해주셨다.

그리고 이렇게 미국이 빨아들이는 힘이 커지는 상황에서 우리나라는

1) 선배 세대에서 후배 세대로의 자본 조달

2) 정책 및 관습 개선

3) 가상자산의 적극적 활용

등이 필요할 것으로 보인다.

이후 "분극화 시대"의 투자 해법과 관련하여

대체거래소(ATS) 출범과

역발상 투자 전략, ETF 연금투자 전략에 대해

심도 있는 강연을 들을 수 있었다.

내가 과연 경제 이야기를 집중해서 잘 들을 수 있을까,

이해는 할 수 있을까 걱정했는데

평소 구독형 뉴스를 챙겨보던 게 도움이 좀 됐던 것 같다.

그리고 오늘 정말 통감했던 바는

금융과 정치는 뗄레야 뗄 수 없는 관계

라는 것이다.

금융포럼이지만 모든 이야기의 기저에는 "정치"가 있었다.

다음에 기회가 된다면 다시 참석하고 싶은 유익한 포럼이었다.

(근데 그 전에 취직해서 못 오면 더 좋겠다...)

[BOJ/Java] #11279 최대 힙 - PriorityQueue

효딩 — Mon, 24 Mar 2025 19:41:55 +0900

알고리즘 분류

- 자료 구조

- 우선순위 큐

https://www.acmicpc.net/problem/11279

N개의 줄에 정수 x가 주어진다. (1<=N<=100,000)

x가 자연수라면 배열에 x라는 값을 넣고,

x가 0이라면 배열에서 가장 큰 값을 출력, 그 값을 배열에서 제거한다.

배열이 비어있는 경우 가장 큰 값을 출력하라고 하면 0을 출력한다.

먼저 내가 처음 생각했던 방법은

ArrayList를 선언하고,

x가 자연수라면 add,

x가 0이라면 Collections.max()로 max 값을 찾아 출력 및 제거하는 거였다.

ArrayList 사용 (실패 코드)

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();
        ArrayList<Integer> list = new ArrayList<>();

        for (int i = 0; i < N; i++) {
            int cal = Integer.parseInt(br.readLine());
            if (cal == 0) {
                if (list.size() == 0) {
                    sb.append("0\n");
                } else {
                    int max = Collections.max(list);
                    sb.append(max).append("\n");
                    list.remove(list.indexOf(max));
                }
            } else {
                list.add(cal);
            }
        }

        System.out.println(sb);
    }
}

그러나 이 방법은 Collections.max()와 list.remove()가 각각

O(N)의 시간 복잡도를 가지기 때문에

전체적으로 O(N^2)가 되어 10^10 즉 1초를 넘게 된다.

방법을 알아보니

PriorityQueue를 사용하는 문제였고, 이를 사용하니 아주 쉽게 풀었다.

PriorityQueue 사용 (성공 코드)

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());

        for (int i = 0; i < N; i++) {
            int cal = Integer.parseInt(br.readLine());
            if (cal == 0) {
                if (pq.isEmpty()) {
                    sb.append("0\n");
                } else {
                    sb.append(pq.poll()).append("\n");
                }
            } else {
                pq.offer(cal);
            }
        }

        System.out.println(sb);
    }
}

이 기회에 PriorityQueue에 대해 정리하고자 한다.

PriorityQueue

우선순위 큐

일반적인 큐의 구조 FIFO(First In First Out)를 가지면서,

데이터가 들어온 순서대로 데이터가 나가는 것이 아닌,

우선순위를 먼저 결정하고 그 우선순위가 높은 데이터가 먼저 나가는 자료구조이다.

int, String, Double과 같은 기본 타입은 Comparable을 이미 구현하고 있어서

그냥 PriorityQueue에 넣어도 우선순위가 자동으로 정해진다.

그러나 직접 만든 클래스에서 PriorityQueue를 사용하기 위해서는

우선순위 큐에 저장할 객체는 필수적으로 Comparable Interface를 구현해야 한다.

Comparable Interface를 구현하면 compareTo method를 override 하게 되고,

해당 객체에서 처리할 우선순위 조건을 리턴해주면

PriorityQueue가 알아서 우선순위가 높은 객체를 추출해준다.

class Task implements Comparable<Task> {
    int priority;
    String name;

    public Task(int priority, String name) {
        this.priority = priority;
        this.name = name;
    }

    // compareTo를 override해서 우선순위 기준을 정의
    @Override
    public int compareTo(Task other) {
        // priority가 클수록 우선순위 높게 하고 싶다면 (MaxHeap처럼)
        return other.priority - this.priority;
    }
}

PriorityQueue<Task> pq = new PriorityQueue<>();
pq.add(new Task(3, "A"));
pq.add(new Task(5, "B"));
pq.add(new Task(1, "C"));

System.out.println(pq.poll().name); // "B"

내부 요소는 힙으로 구성되어 이진트리 구조로 이루어져 있다.

내부구조가 힙으로 구성되어 있기에 시간 복잡도는 O(logN)이다.

import java.util.*;

// 낮은 숫자가 우선 순위인 int형 우선순위 큐
// 최소힙(Min Heap)
PriorityQueue<Integer> pqLowest = new PriorityQueue<>();

// 높은 숫자가 우선 순위인 int형 우선순위 큐
// 최대힙(Max Heap)
PriorityQueue<Integer> pqHighest = new PriorityQueue<>(Collections.reverseOrder());

[프로그래머스 고득점 Kit/Java] 폰켓몬

효딩 — Sun, 23 Mar 2025 20:56:50 +0900

다음과 같이 풀었다.

nums를 돌며 map에 종류 번호와 해당 번호가 나온 횟수를 저장한다.

1) 종류 번호가 nums 배열 크기 / 2 보다 크다면 -> nums 배열 크기 / 2만큼만 선택할 수 있다.

2) 작거나 같다면 -> 종류 번호 만큼 선택한다.

import java.util.*;
import java.io.*;
class Solution {
    public int solution(int[] nums) {
        int answer = 0;
        HashMap<Integer, Integer> pokemon = new HashMap<>();
        for (int num : nums) {
            pokemon.put(num, pokemon.getOrDefault(num, 0) + 1);
        }
        if (pokemon.size() > nums.length / 2) {
            answer = nums.length / 2;
        } else {
            answer = pokemon.size();
        }
        return answer;
    }
}