NA의 개발냥발

[프로그래머스] 예상 대진표 (JAVA/자바)

nyrimmm — Tue, 10 Feb 2026 20:47:42 +0900

[문제 링크]

https://school.programmers.co.kr/learn/courses/30/lessons/12985

문제 설명

N명의 참가자가 각각 1~N번을 배정받아서 토너먼트 형식의 게임에 참가한다.

1번↔2번, 3번↔4번,... N-1번↔N번 끼리 게임을 진행하고, 다음 라운드에 진출한 참가자들은 다시 1번부터 (N/2)번을 배정받아서 게임을 진행한다.

이 때, 처음 라운드에서 A번을 가진 참가자가 B번 참가자와 만나게 되는 라운드 번호를 구한다.
A번 참가자와 B번 참가자는 서로 만날 때까지 항상 이긴다고 가정한다.

문제 풀이

알고리즘 분류

이진탐색

최종 라운드에서 시작해서 아래로 내려가면서 a와 b가 만나는 라운드를 구한다.

N = 2^x 일 때, N명의 참가자가 토너먼트 게임을 진행하면 총 x번의 라운드가 진행된다.

answer의 초기값을 최대 라운드 수인 x로 설정하고, 전체 대진표를 반으로 나눠서 중간값을 mid라고 한다.

(두 구역이 범위는 각각 1~mid, (mid+1)~N)

mid를 기준으로 a와 b가 어느 구역에 속해 있는지 확인한다.

a와 b가 서로 다른 구역에 있을 경우, answer 번의 라운드에서 a와 b가 만난다.

a와 b가 서로 같은 구역에 있을 경우, answer번의 라운드보다 더 낮은 라운드에서 만난다.

→ answer을 -1 하고, a와 b가 있는 구역으로 범위를 변경한다.

위의 과정을 계속 반복하면서 a와 b가 서로 다른 구역에 있는 경우를 구한다.

전체코드(나의 풀이)

class Solution {
    public int solution(int n, int a, int b) {
        int answer = 0;
        int start = 1, end = n;
        
        //총 라운드 횟수 구하기
        int x = 1;
        for(int i = 1; i <= 20; i++) {
            x *= 2;
            if(x == n) {
                answer = i;
                break;
            }
        }
        
        while(answer > 0) {
            int mid = (start + end) / 2;
            if((a <= mid && b > mid) || (a > mid && b <= mid)) {
                break;
            } else {
                if(a > mid && b > mid) {
                    start = mid + 1;
                } else if(a <= mid && b <= mid) {
                    end = mid;
                }
                answer--;
            }
        }
        return answer;
    }
}

전체코드(다른 풀이)

1라운드부터 시작해서 위로 올라가면서 a와 b가 만나는 라운드르 구한다.

A와 B는 서로 만나기 전까지 항상 이긴다고 가정하기 때문에, 매 라운드마다 번호가 바뀐다.

만약 현재 x번 참가자일 경우, 다음 라운드에서 부여받는 번호는 (x+1)/2 번이다.

ex) 현재 라운드 3번일 경우, 다음 라운드에는 (3+1)/2=2번

현재 라운드 6번일 경우, 다음 라운드에는 (6+1)/2=3번

while문을 돌면서 매 라운드마다 a와 b의 번호를 갱신하면서 두 참가자의 번호가 같아지는 시점을 찾는다.

두 참가자의 번호가 같아지는 시점이 두 참가자가 만나게 되는 라운드이다.

class Solution {
    public int solution(int n, int a, int b) {
        int answer = 1;
        
        while((a + 1) / 2 != (b + 1) / 2) {
            answer++;
            a = (a + 1) / 2;
            b = (b + 1) / 2;
        }
        return answer;
    }
}

[프로그래머스] 주차 요금 계산 (JAVA/자바)

nyrimmm — Mon, 9 Feb 2026 17:11:01 +0900

[문제 링크]

https://school.programmers.co.kr/learn/courses/30/lessons/92341

문제 설명

주차장의 요금표와 차량들의 입차, 출차 기록이 주어질 때, 차량별로 주차 요금을 계산해서 차량번호가 작은 자동차부터 순서대로 주차요금을 출력한다.

- 누적 주차 시간 <= 기본 시간 : 기본 요금

- 누적 주차 시간 > 기본시간 : 기본요금 + (초과시간에 대해 단위시간당 요금 청구)

- 초과시간이 단위 시간으로 나누어떨어지지 않으면 올림해서 계산

- 어떤 차량이 입차된 후에 출차된 내역이 없다면 23:59에 출차된 것으로 간주하고 계산

문제 풀이

알고리즘 분류

구현
HashMap

문제는 이해했는데 구현을 하는데 시간이 오래걸렸다.

처음에는 먼저 차량번호와 시각 기준 오름차순 정렬한 후에, 차량번호가 작은 순서부터 차례로 순회하면서 차량별 총 주차 시간을 구하려 했다. 근데 생각해보니 하나의 차량번호에 여러 개의 입출차 내역이 있는데, 굳이 이 많은 내역을 처음부터 정렬할 필요 없이 차량별 총 주차시간을 모두 구한 후에 정렬해도 된다.

하나의 문자열로 되어있는 입출차내역을 시간, 분, 차량번호, 입출차내역으로 나눈다.

String[] record = s.split(" ");
String[] time = record[0].split(":");

int hour = Integer.parseInt(time[0]);   //시간
int minute = Integer.parseInt(time[1]); //분
String number = record[1];  //차량번호
String state = record[2];   //입출차 내역

입출차내역이 "IN"이면 map에 삽입, "OUT"이면 map에서 같은 차량번호의 정보를 꺼내서 주차 시간을 계산한다. → calculate() 함수 사용

if(state.equals("IN")) {
    map.put(number, new int[]{hour, minute});
} else {
    int[] t = map.get(number);
    calculate(number, t[0], t[1], hour, minute);
}

한 번 순회가 끝나고 map에 남아있는 차량들은 입차내역은 있지만 출차내역이 없는 차량이다.

이 경우 23:59에 출차한 것으로 간주하고 주차 시간을 계산한다. → calculate() 함수 사용

if(map.size() != 0) {
    ArrayList<String> list = new ArrayList<>(map.keySet());
    for(String key : list) {
        int[] t = map.get(key);
        calculate(key, t[0], t[1], 23, 59);
    }
}

차량별 총 주차 시간이 담겨 있는 sumMap을 사용해서 차량별 총 주차 요금을 계산한다.

이 때, sumMap의 key들을 오름차순 정렬해서 차량번호가 작은 자동차부터 순서대로 계산할 수 있게 한다.

ArrayList<String> keys = new ArrayList<>(sumMap.keySet());
Collections.sort(keys);

int[] answer = new int[sumMap.size()];
int idx = 0;
for(String key : keys) {
    int time = sumMap.get(key);

    int extraFee = 0;
    if(time > fees[0]) {
        double extraTime = Math.ceil((double)(time - fees[0]) / (double)fees[2]);
        extraFee = (int)extraTime * fees[3];
    }
    answer[idx] = fees[1] + extraFee;
    idx++;
}

전체코드

import java.util.*;

class Solution {
    
    HashMap<String, Integer> sumMap = new HashMap<>();	//차랑번호별 총 주차 시간을 담는다.
    HashMap<String, int[]> map = new HashMap<>();	//차량번호별 입차 시각을 담는다.
    
    public int[] solution(int[] fees, String[] records) {
        //시간, 분, 차량번호, 내역별로 나누기
        for(String s : records) {
            String[] record = s.split(" ");
            String[] time = record[0].split(":");
            
            int hour = Integer.parseInt(time[0]);   //시간
            int minute = Integer.parseInt(time[1]); //분
            String number = record[1];  //차량번호
            String state = record[2];   //입출차 여부
            
            //"IN"이면 map에 삽입, "OUT"이면 map에서 같은 차량번호의 정보를 꺼내서 시간 계산
            if(state.equals("IN")) {
                map.put(number, new int[]{hour, minute});
            } else {
                int[] t = map.get(number);
                calculate(number, t[0], t[1], hour, minute);
            }
        }
        
        //출차 안된 차량들의 주차 시간 계산
        if(map.size() != 0) {
            ArrayList<String> list = new ArrayList<>(map.keySet());
            for(String key : list) {
                int[] t = map.get(key);
                calculate(key, t[0], t[1], 23, 59);
            }
        }
        
        //차량번호 기준 오름차순 정렬
        ArrayList<String> keys = new ArrayList<>(sumMap.keySet());
        Collections.sort(keys);
        
        //차량별 총 주차 요금 계산
        int[] answer = new int[sumMap.size()];
        int idx = 0;
        for(String key : keys) {
            int time = sumMap.get(key);
            
            int extraFee = 0;
            if(time > fees[0]) {
                double extraTime = Math.ceil((double)(time - fees[0]) / (double)fees[2]);
                extraFee = (int)extraTime * fees[3];
            }
            answer[idx] = fees[1] + extraFee;
            idx++;
        }
        
        return answer;
    }
    
    //차량별 총 주차 시간 계산
    public void calculate(String num, int inH, int intM, int outH, int outM) {          
        int tmp_h = outH - inH;
        int tmp_m = 0;
        if(outM < intM) {
            tmp_m = (60 + outM) - intM;
            tmp_h -= 1;
        } else {
            tmp_m = outM - intM;
        }

        int total = tmp_h * 60 + tmp_m;
        sumMap.put(num, sumMap.getOrDefault(num, 0) + total);
        map.remove(num); //map에서 같은 차량번호 정보 삭제
    }
}

[백준] 7490번 : 0 만들기 (JAVA/자바)

nyrimmm — Tue, 3 Feb 2026 17:09:09 +0900

[문제 링크]

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

문제 설명

1 ~ N까지 오름차순으로 된 수열의 숫자들 사이에 '+', '-', ' '(공백) 를 적절하게 삽입한다.

이렇게 해서 만들어진 수식을 계산한 결과가 0이 되는 모든 수식을 찾는다.

문제 풀이

알고리즘 분류

문자열
완전탐색
깊이 우선 탐색(DFS)

수식의 결과가 0이 되는 모든 수식을 찾아야 하기 때문에 완전탐색으로 모든 경우의 수를 탐색한다.

1. 재귀함수를 사용해서 숫자들 사이에 +, - " "(공백) 중 하나를 선택해서 만들 수 있는 수식을 문자열 형태로 생성한다.

dfs(num + 1, str + " " + (num+1));
dfs(num + 1, str + "+" + (num+1));
dfs(num + 1, str + "-" + (num+1));

하나의 수식이 완성되면 calculate() 함수로 수식의 결과값이 0 이 되는 경우를 찾는다.

문자열로 된 수식을 숫자와 연산자(+, -)로 나눈 후 수식을 계산한다.

1. 숫자와 숫자 사이가 " "(공백)인 경우, 공백을 제거한다.

"1 2-3"인 경우, 공백을 제거하면 "12-3"

String express = str.replace(" ", "");

2. +, - 의 앞뒤로 공백 한 칸씩을 추가한다.(여기서 추가한 " "(공백)을 기준으로 숫자와 연산자를 나누기 위해)

"1+2-3" → "1 + 2 - 3"→ {"1", "+", "2", "-", "3"}

String express1 = express.replace("+",  " + ").replace("-", " - ");

3. 위의 express1 배열을 공백을 기준으로 나눠서 새로운 배열 strings를 생성한다.

String[] strings = express1.split(" ");

4. strings 배열을 처음부터 탐색하면서 +, -를 찾아서 계산한다.

for(int i = 1; i < strings.length; i += 2) {
    if(strings[i].equals("+")) {
        sum += Integer.parseInt(strings[i + 1]);
    } else if (strings[i].equals("-")) {
        sum -= Integer.parseInt(strings[i + 1]);
    }
}

전체코드

import java.io.*;

public class Main {

    static int n;
    static StringBuilder sb = new StringBuilder();

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

        while(t > 0) {
            n = Integer.parseInt(br.readLine());
            dfs(1, "1");
            sb.append("\n");
            t--;
        }
        System.out.println(sb);
    }

    public static void dfs(int num, String str) {
        if(num == n) {
            if(calculate(str) == 0) {   //수식을 계산에서 값이 0이면 sb에 추가
                sb.append(str + " \n");
            }
            return;
        }

        dfs(num + 1, str + " " + (num+1));
        dfs(num + 1, str + "+" + (num+1));
        dfs(num + 1, str + "-" + (num+1));
    }

    public static int calculate(String str) {
        String express = str.replace(" ", "");  //숫자와 숫자 사이 공백 제거

        /* +. - 앞뒤로 공백 한 칸씩을 추가한 후, " "(공백)을 기준으로 문자열을 쪼갠다.
          1+2-3 -> 1 + 2 - 3 -> {"1", "+", "2", "-", "3"}
        */
        String express1 = express.replace("+",  " + ").replace("-", " - ");
        String[] strings = express1.split(" ");

        int sum = Integer.parseInt(strings[0]);
        for(int i = 1; i < strings.length; i += 2) {
            if(strings[i].equals("+")) {
                sum += Integer.parseInt(strings[i + 1]);
            } else if (strings[i].equals("-")) {
                sum -= Integer.parseInt(strings[i + 1]);
            }
        }
        return sum;
    }
}

[프로그래머스] 야근지수 (JAVA/자바)

nyrimmm — Tue, 3 Feb 2026 15:26:07 +0900

[문제 링크]

https://school.programmers.co.kr/learn/courses/30/lessons/12927

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

문제 설명

야근피로도 = (N시간 동안 야근 후 남은 일의 각 작업량^2) 을 모두 더한 값

N시간동안 works 배열에 담긴 각 일의 작업량을 적절하게 처리했을 때, 야근 피로도의 최소값을 구한다.

1시간동안 작업량 1을 처리할 수 있다.

문제 풀이

알고리즘 분류

우선순위 큐(PriorityQueue)

야근 피로도의 최소값을 구하려면 작업량이 가장 많은 일부터 처리해서 제곱근의 크기를 작게 한다.

PriorityQueue에 현재 남은 작업량을 담고, ollections.reverseOrder()로 내림차순 정렬한다.

n번만큼 반복하면서 작업량이 가장 많은 일부터 -1 한다.

작업량이 0인 경우에는 큐에 다시 넣지 않는다.

전체코드

import java.util.*;

class Solution {
    public long solution(int n, int[] works) {
        long answer = 0;

        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
        
        for(int w : works) {
            pq.add(w);
        }
        
        while(n > 0 && !pq.isEmpty()) {
            int poll = pq.poll();
            if((poll - 1) > 0) {
                pq.add(poll - 1);
            }
            n--;
        }
        
        while(!pq.isEmpty()) {
            int work = pq.poll();
            answer += work * work;
        }
        return answer;
    }
}

[백준] 1713번 : 후보 추천하기 (JAVA/자바)

nyrimmm — Wed, 28 Jan 2026 12:01:57 +0900

[문제 링크]

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

문제 설명

N개의 사진틀에 추천받은 학생회장 후보 사진을 아래 규칙을 따라 게시할 때, 최종 후보들의 번호를 출력한다.

1. 추천받은 순서대로 사진을 사진틀에 게시한다.

2. N개의 사진틀 중 비어있는 사진틀이 없는 경우

2-1. 새롭게 추천받은 학생이 현재 게시된 학생에 포함된 경우, 해당 학생의 추천 횟수 + 1

2-2. 새롭게 추천받은 학생이 현재 게시된 학생에 포함되지 않은 경우,

- 현재까지 추천 받은 횟수가 가장 적은 학생 삭제 + 삭제한 자리에 새로운 학생 게시

- 추천 받은 횟수가 가장 적은 학생이 2명 이상일 경우, 가장 오래된 학생 삭제

문제 풀이

알고리즘 분류

구현
HashMap(LinkedHashMap)

문제를 읽고 이전에 풀었던 완주하지 못한 선수가 떠올랐다. HashMap의 getOrDefault() 함수를 사용해서 key값의 개수를 센다.

하지만 이 문제에서는 추천받은 "순서"가 중요하기 때문에 요소가 삽입된 순서대로 저장되는 LinkedHashMap을 사용해서 문제를 풀었다.

(학생 번호, 추천 횟수)쌍으로 값을 저장하고, getOrDefault() 함수를 사용해서 해당 key 값이 존재하면 value + 1, 존재하지 않으면 새로운 쌍을 생성해서 hashmap에 추가한다.

비어있는 사진틀이 없는 경우, 먼저 새롭게 추천 받은 학생(new 학생)이 현재 게시되어 있는지 확인한다.

게시되어 있지 않으면 현재 게시된 학생들 중에서 추천횟수가 가장 적은 한 명을 찾아서 삭제하고 new 학생을 게시한다.

이미 게시되어 있으면 해당 학생의 추천 횟수 + 1

if(hm.size() == n && !hm.containsKey(students[i])) {
    int minKey = 0;
    int minValue = 1001;
    //현재까지 추천횟수가 가장 적은 학생 탐색
    for(Integer key : hm.keySet()) {
        if (minValue > hm.get(key)) {
            minValue = hm.get(key);
            minKey = key;
        }
    }
    hm.remove(minKey);  //추천횟수가 가장 적은 학생 삭제
}

전체코드

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

        int n = Integer.parseInt(br.readLine());    //사진틀의 개수
        int m = Integer.parseInt(br.readLine());    //전체 학생 추천 횟수

        int[] students = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();

        for(int i = 0; i < students.length; i++) {
            if(hm.size() == n && !hm.containsKey(students[i])) {
                int minKey = 0;
                int minValue = 1001;
                //현재까지 추천횟수가 가장 적은 학생 탐색
                for(Integer key : hm.keySet()) {
                    if (minValue > hm.get(key)) {
                        minValue = hm.get(key);
                        minKey = key;
                    }
                }
                hm.remove(minKey);  //추천횟수가 가장 적은 학생 삭제
            }

            hm.put(students[i], hm.getOrDefault(students[i], 0) + 1);
        }

        Object[] array = hm.keySet().toArray();
        Arrays.sort(array);

        for (Object o : array) {
            System.out.print(o + " ");
        }
    }
}

[백준] 2467번 : 용액 (JAVA/자바)

nyrimmm — Wed, 14 Jan 2026 14:58:38 +0900

[문제 링크]

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

문제 설명

주어진 용액들 중에서 서로 다른 2개의 용액을 혼합해서 나온 값이 0에 가장 가까운 용액을 만들어 내는 두 용액을 구한다.

문제 풀이

알고리즘 분류

투포인터

용액이 오름차순 정렬되어 있는 상태이므로 가장 첫 번째 값 인덱스(left)와 가장 마지막 값 인덱스(right)를 포인터로 지정한 후, 배열이 안쪽 방향으로 두 포인터를 움직이면서 0에 가까운 두 수를 구한다.

1. 0과 n-1 를 투 포인터 left, right로 지정한다.

2. left와 right 인덱스가 가리키는 두 값을 더한 값(sum)을 구한다.

3. Math.abs(sum) < minValue sum 절대값이 현재 저장된 값보다 작을 경우 현재 저장된 값 업데이트

4-1. sum >= 0 0보다 크거나 같을 경우 오른쪽 포인터 이동(right 감소)

4-2. sum < 0 0보다 작을 경우 왼쪽 포인터 이동(left 증가)

전체코드

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

public class Main {

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

        int n = Integer.parseInt(br.readLine());    //전체 용액의 수

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

        int left = 0;
        int right = n - 1;

        int mixL = 0;
        int mixR = 0;
        long minValue = Long.MIN_VALUE;

        while(left < right) {
            long sum = array[left] + array[right];
            if(Math.abs(sum) < minValue) {
                mixL = left;
                mixR = right;
                minValue = Math.abs(sum);
            }

            if(sum >= 0) {
                //둘 다 양수이거나
                //|array[left]| < |array[right]|(양수의 절댓값이 더 큰 경우)
                right--;
            } else {
                //둘 다 음수이거나
                //|array[left]| > |array[right]|(음수의 절댓값이 더 큰 경우
                left++;
            }
        }
        System.out.println(array[mixL] + " " + array[mixR]);
    }
}

[백준] 1092번 : 배 (JAVA/자바)

nyrimmm — Sun, 11 Jan 2026 02:52:48 +0900

[문제 링크]

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

문제 설명

크레인 N대를 사용해서 박스 M개를 모두 옮기는 데 드는 시간의 최솟값을 구한다.

1분에 박스를 하나씩 옮길 수 있고, 모든 크레인은 동시에 움직인다.

각 크레인의 무게 제한보다 무거운 박스는 옮길 수 없다.

모든 박스를 옮길 수 없는 경우 -1

문제 풀이

알고리즘 분류

그리디 알고리즘
정렬

크레인과 박스를 각각 내림차순 정렬한다.

boxes.get(0) > crane.get(0) 박스 무게의 최대값이 크레인 무게제한의 최대값보다 클 경우 모든 박스를 옮길 수 없다.

1. 가장 무거운 박스부터 차례대로 탐색하면서 각 크레인이 해당 박스를 옮길 수 있는지 확인한다.

2. 해당 박스를 옮길 수 있으면 크레인 사용 처리, 리스트에서 박스 제거3. 모든 크레인이 한 번씩 사용되면 시간 증가위의 과정을 모든 박스가 옮겨질 때까지 반복한다.

전체코드

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

public class Main {

    static int n, m, cnt = 0;
    static ArrayList<Integer> crane = new ArrayList<>();
    static ArrayList<Integer> boxes = new ArrayList<>();

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

        n = Integer.parseInt(br.readLine());    //크레인 수

        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < n; i++) {
            crane.add(Integer.parseInt(st.nextToken()));
        }

        m = Integer.parseInt(br.readLine());    //박스 수
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < m; i++) {
            boxes.add(Integer.parseInt(st.nextToken()));
        }

        Collections.sort(crane, Collections.reverseOrder());    //크레인 내림차순 정렬
        Collections.sort(boxes, Collections.reverseOrder());    //박스 내림차순 정렬

        //모든 박스를 배로 옮길 수 없는 경우
        if (boxes.get(0) > crane.get(0)) {
            System.out.println(-1);
            return;
        }

        while (!boxes.isEmpty()) {
            int craneIdx = 0;
            int boxIdx = 0;

            //박스를 모두 돌면서 1회차에 크레인으로 옮길 수 있는 박스 탐색
            while(boxIdx < boxes.size()) {
                if(craneIdx >= n) break;
                if(boxes.get(boxIdx) <= crane.get(craneIdx)) {  //크레인으로 박스를 옮길 수 있는 경우
                    boxes.remove(boxIdx);   //박스 제거
                    craneIdx++;
                } else {
                    boxIdx++;
                }
            }
            cnt++;
        }

        System.out.println(cnt);
        return;
    }
}

[백준] 14503번 : 로봇청소기 (JAVA/자바)

nyrimmm — Sat, 8 Nov 2025 15:37:35 +0900

[문제 링크]

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

문제 설명

0-청소X, 1-벽

청소기가 작동하는 순서는 아래와 같다.
1. 현재 칸이 아직 청소되지 않은 경우, 현재 칸 청소
2. 현재 칸 주변 4칸 중 청소되지 않은 빈 칸이 없는 경우(4칸이 모두 청소된 경우)
2-1. 바라보는 방향 기준 한 칸 후진할 수 있다면, 후진 후 1으로 돌아감
2-2. 후진할 수 없는 경우(벽인 경우) stop
3. 현재 칸 주변 4칸 중 청소되지 않은 빈 칸이 있는 경우
3-1. 청소기 반시계방향으로 90도 회전
3-2. 바라보는 방향 기준 앞쪽 칸이 청소되지 않은 경우, 한 칸 전진

3-3. 1으로 돌아감

문제 풀이

알고리즘 분류

구현
시뮬레이션

문제에 주어진 청소기 작동 순서대로 현재 칸을 기준으로 상하좌우 칸을 탐색하면서 청소가 된 칸인지 되지 않은 칸인지 확인한다.

청소가 되지 않은 칸은 0, 청소가 된 칸은 -1, 벽인 칸은 1 로 구분한다.

처음에는 청소가 된 칸과 벽인 칸을 둘 다 "로봇청소기가 갈 수 없는 공간"으로 생각해서 똑같이 1로 처리했었다.

하지만 이렇게 하면 4칸 중 청소되지 않은 빈칸이 없는 경우 한 칸 후진을 해야하는데, 후진을 할 수 있는지 없는지 알 수 없다.(후진할 칸이 청소가 된 칸이면 후진 가능, 벽이면 후진 불가능)

그래서 청소가 된 칸은 -1, 벽인 칸은 1로 구분해서 풀이했다.

전체코드

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

public class Main {

    static int n, m, r, c, d, count = 0;
    static int[][] rooms;
    static int[] dr = {-1, 0, 1, 0}; //북, 동, 남, 서
    static int[] dc = {0, 1, 0, -1};

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

        st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());

        st = new StringTokenizer(br.readLine());
        r = Integer.parseInt(st.nextToken());
        c = Integer.parseInt(st.nextToken());
        d = Integer.parseInt(st.nextToken()); //방향

        rooms = new int[n][m];
        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < m; j++) {
                rooms[i][j] = Integer.parseInt(st.nextToken());
            }
        }
        clean();
        System.out.println(count);
    }

    public static void clean() {
        while(true) {
            //현재 칸이 청소되지 않은 경우 현재 칸 청소
            if (rooms[r][c] == 0) {
                rooms[r][c] = -1;   //청소완료 상태로 변경
                count++;    //청소횟수 증가
            }

            int cleanCnt = 0;   //이미 청소된 칸 or 벽의 개수
            
            //현재 칸의 주변 4칸 중 청소되지 않은 빈 칸이 있는지 탐색
            for (int i = 0; i < 4; i++) {
                d = (d == 0) ? 3 : d - 1; //반시계방향으로 90도 회전

                int nr = r + dr[d];
                int nc = c + dc[d];

                //방의 범위를 벗어나는 경우
                if(nr < 0 || nc < 0 || nr >= n || nc >= m)  continue;

                //이미 청소된 칸이거나 벽일 경우
                if (rooms[nr][nc] == 1 || rooms[nr][nc] == -1)  cleanCnt++;

                //청소되지 않은 빈 칸이 있는 경우 한 칸 전진
                if(rooms[nr][nc] == 0) {
                    r = nr;
                    c = nc;
                    break;
                }
            }

            //주변 4칸 중 청소되지 않은 빈 칸이 없는 경우
            if(cleanCnt == 4) {
                int nr = r - dr[d];
                int nc = c - dc[d];

                //범위를 벗어나거나 뒤쪽이 벽이라 후진할 수 없는 경우
                if(nr < 0 || nc < 0 || nr >= n || nc >= m || rooms[nr][nc] == 1) {
                    return;
                }
                //한 칸 후진
                r = nr;
                c = nc;
            }
        }

    }
}

[백준] 17298번 : 오큰수 (JAVA/자바)

nyrimmm — Thu, 23 Oct 2025 01:43:31 +0900

[문제 링크]

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

문제 설명

오큰수(NGE) : 현재 원소 Ai보다 오른쪽에 있으면서 Ai보다 큰 수 중에서 가장 왼쪽에 있는 수, 존재하지 않으면 -1

ex) A = {9, 5, 4, 8}인 경우 NGE(1) = -1, NGE(2) = 8, NGE(3) = 8, NGE(4) = -1

문제 풀이

알고리즘 분류

스택

문제에서 수열의 크기 N이 최대 1,000,000(10^6) 이다.

그래서 단순하게 현재 원소를 기준으로 오른쪽에 있는 모든 원소를 다 비교해가며 오큰수를 찾으면 O(n^2)로 시간 초과가 나온다.

따라서 Stack 을 사용하면 이 문제를 풀 수 있다.(다른 풀이를 참고했다.)

스택에는 아직 오큰수를 찾지 못한 원소의 인덱스 를 담는다.

for문으로 수열을 돌면서 현재 수와 stack의 top을 인덱스로 하는 수를 비교한다.

현재 수 > stack의 top을 인덱스로 하는 수이면 현재 수가 stack의 top을 인덱스로 하는 수의 오큰수이다.

오큰수를 찾으면 stack의 top을 stack에서 pop

이 과정을 현재 수 > stack의 top을 인덱스로 하는 수 를 만족하지 않을 때까지 반복한다.

이후 현재 수의 인덱스를 stack에 push

예시

예시 1) A = {9, 5, 4, 8}

1) 현재 수 9, stack{}

stack이 비어있기 때문에 stack에 9의 인덱스 0 push

→ result : stack{0} nge={0, 0, 0, 0}

2) 현재 수 5, stack{0}

현재수(5) < stack.peek()의 수(9) 이므로 stack에 5의 인덱스 1 push

→ result : stack{0, 1} nge={0, 0, 0, 0}

3) 현재 수 4, stack{0, 1}

현재수(4) < stack.peek()의 수(5) 이므로 stack에 4의 인덱스 2 push

→ result : stack{0, 1, 2} nge={0, 0, 0, 0}

2-1) 현재 수 8, stack{0, 1, 2}

현재수(8) > stack.peek()의 수(4) 이므로 4의 오큰수=8

nge[2]=8, stack에서 2 pop

→ result : stack{0, 1} nge={0, 0, 8, 0}

2-2) 현재 수 8, stack{0, 1}

현재수(8) > stack.peek()의 수(5) 이므로 5의 오큰수=8

nge[1]=8, stack에서 1 pop

→ result : stack{0} nge={0, 8, 8, 0}

2-3) 현재 수 8, stack{0}

현재수(8) < stack.peek()의 수(9) 이므로 반복 끝, stack에 8의 인덱스 3 push

→ result : stack{0, 3} nge={0, 8, 8, 0}

더 이상 탐색할 원소가 없고, stack에 남아있는 0, 3을 인덱스로 가지는 수 9와 8의 오큰수=-1이 된다.

따라서 nge={-1, 8, 8, -1}

예시 2) A = {3, 5, 2, 7}

1) 현재 수 3, stack{}

stack이 비어있기 때문에 stack에 3의 인덱스 0 push

→ result : stack{0} nge={0, 0, 0, 0}

2) 현재 수 5, stack{0}

현재수(5) > stack.peek()의 수(3) 이므로 3의 오큰수=5

nge[0]=5, stack에서 0 pop이고 stack이 비어있기 때문에 반복 끝, stack에 5의 인덱스 1 push

→ result : stack{1} nge={5, 0, 0, 0}

3) 현재 수 2, stack{1}

현재수(2) < stack.peek()의 수(5) 이므로 stack에 2의 인덱스 2 push

→ result : stack{1, 2} nge={5, 0, 0, 0}

4-1) 현재 수 7, stack{1, 2}

현재수(7) > stack의 peek()의 수(2) 이므로 2의 오큰수=7

nge[2]=7, stack에서 2 pop

→ result : stack{1} nge={5, 0, 7, 0}

4-2) 현재 수 7, stack{1}

현재수(7) > stack의 peek()의 수(5) 이므로 5의 오큰수=7

nge[1]=7, stack에서 1 pop

→ result : stack{} nge={5, 7, 7, 0}

4-3) 현재 수 7, stack{}

stack이 비어있기 때문에 stack에 7의 인덱스 3 push

→ result : stack{3} nge={5, 7, 7, 0}

더 이상 탐색할 원소가 없고, stack에 남아있는 3을 인덱스로 가지는 수 7의 오큰수=-1이 된다.

따라서 nge={5, 7, 7, -1}

전체코드

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

public class Main {

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

        int n = Integer.parseInt(br.readLine());

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

        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < n; i++) {
            //현재 수(numbers[i])와 스택의 최상단 수(numbers[stack.peek()]) 비교
            //현재 수가 오큰수인 경우
            while (!stack.isEmpty() && numbers[stack.peek()] < numbers[i]) {
                nge[stack.peek()] = numbers[i];	//오큰수 저장
                stack.pop();	//stack에서 빼기
            }
            //stack에 현재 수의 인덱스 넣기
            stack.push(i);
        }

        //스택에 여전히 남아있는 수 -> 오큰수가 없는 경우이므로 -1
        while (!stack.isEmpty()) {
            nge[stack.pop()] = -1;
        }

        StringBuilder sb = new StringBuilder();
        for(int s : nge) {
            sb.append(s + " ");
        }

        System.out.println(sb);
    }
}

오답 코드

처음에 풀었던 방식(시간초과)

for문으로 수열의 처음부터 끝까지 돌면서 현재 원소의 오른쪽에 있는 수들과 비교해서 현재 원소보다 큰 수가 나오면 break, 큰 수가 없다면 -1(오큰수가 존재하지 않음)

하지만 이렇게 하면 최악의 경우 각 원소의 오큰수를 구할 때마다 오른쪽에 있는 모든 원소와 비교해야해서 시간복잡도가 O(n^2)로 시간초과가 발생한다.

예를 들어 수열 A = {9, 8, 7, 6} 일 경우, NGE={-1, -1, -1, -1}인데 각 원소가 오른쪽에 있는 모든 원소와 비교하게 된다.

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

public class Main {

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

        int n = Integer.parseInt(br.readLine());

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

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n - 1; i++) {
            int j = i + 1;
            boolean flag = false;   //오른쪽에 더 큰 수가 있는지 없는지 확인하는 플래그
            while(j < n) {
                if(numbers[i] < numbers[j]) {
                    sb.append(numbers[j] + " ");
                    flag = true;
                    break;
                }
                j++;
            }
            if(!flag)   sb.append(-1 + " ");
        }

        sb.append(-1);

        System.out.println(sb);
    }
}

[참고]

https://st-lab.tistory.com/196

[프로그래머스]완주하지 못한 선수 (JAVA/자바)

nyrimmm — Wed, 22 Oct 2025 15:41:27 +0900

[문제 링크]

https://school.programmers.co.kr/learn/courses/30/lessons/42576

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

문제 설명

마라톤 참여자 배열 participant 와 완주자 배열 completion이 있을 때, 완주하지 못한 한 명을 구한다.

문제 풀이

알고리즘 분류

HashMap

1. 배열 사용(내가 푼 방식)

import java.util.*;

class Solution {
    public String solution(String[] participant, String[] completion) {
        String answer = "";
      
        //참가자, 완주자 알파벳 순으로 정렬
        Arrays.sort(participant);
        Arrays.sort(completion);

        for(int i = 0; i < participant.length - 1; i++) { 
            if(!participant[i].equals(completion[i])) {
                return participant[i];
            }
        }
        return participant[participant.length - 1];
    }
}

참가자, 완주자 배열을 각각 알파벳 오름차순으로 정렬하고, 앞에서부터 하나씩 비교한다.

동일하지 않으면 participant 배열의 선수가 완주하지 못한 선수이므로 출력하고,

비교 후에도 다른게 없다면 participant 배열의 마지막 선수가 완주하지 못한 선수이다.

2. HashMap 사용

class Solution {
    public String solution(String[] participant, String[] completion) {
        String answer = "";
        
        HashMap<String, Integer> hm = new HashMap<>();
        
        //map에 참가자 추가
        for(String p : participant) {
            hm.put(p, hm.getOrDefault(p, 0) + 1);
        }
        
        //map에서 완주한 선수 제거
        for(String c : completion) {
            hm.put(c, hm.get(c) - 1);
        }
        
        for(String key : hm.keySet()) {
            if(hm.get(key) != 0) {
                answer = key;
                break;
            }
        }
        
        return answer;
    }
}

참여자 배열 participant를 돌면서 <참여자명, 참여자수> 쌍으로 HashMap에 참여자를 모두 넣는다.

보통은 value=1이지만 동명이인의 경우 value가 2 이상이 될 수 있다. 이 때 getOrDefault() 함수를 사용해서 동명이인까지 세서 값을 저장한다.

→ getOrDefault(Object key, V DefaultValue)

: 찾는 key가 존재하면 해당 key의 value 값 반환, 존재하지 않으면 DefaultValue 반환

완주자 배열 completion을 돌면서 map에서 해당 선수를 key로 가진 value를 1씩 감소해서 완주자를 제거한다.

마지막으로 map을 돌면서 value가 0 이 아닌 key를 찾아서 완주하지 못한 선수를 출력한다.