개발새발 블로그

[백준][Java] 1967번 트리의 지름

개발자 성현 — Sun, 16 Nov 2025 13:03:17 +0900

문제 링크

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

문제

풀이

한 정점에서 가장 먼 정점을 찾으면 찾은 정점이 무조건 지름의 끝점 중 하나이고

그 끝점을 기준으로 가장 먼 점까지의 거리를 찾으면 반드시 지름이다.

트리를 탐색하는 알고리즘은 DFS/BFS 상관없습니다. 다만 재귀는 트리가 깊으면 문제가 될 수 있기에 주의

코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    static List<List<Node>> graph = new ArrayList<>();
    static boolean[] visited;
    static int max = 0;
    static int maxId = 0;
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int n = Integer.parseInt(br.readLine());
        for (int i = 0; i <= n; i++) {
            graph.add(new ArrayList<>());
        }

        for (int i = 0; i < n-1; i++) {
            int[] info = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
            int a = info[0];
            int b = info[1];
            int cost = info[2];

            graph.get(a).add(new Node(b, cost));
            graph.get(b).add(new Node(a, cost));
        }

        visited = new boolean[n+1];
        visited[1] = true;
        dfs(1, 0);

        visited = new boolean[n+1];
        visited[maxId] = true;
        dfs(maxId, 0);

        System.out.println(max);
    }

    public static void dfs(int s, int result) {
        if (result > max) {
            maxId = s;
            max = result;
        }

        for (Node nx : graph.get(s)) {
            if (!visited[nx.id]) {
                visited[nx.id] = true;
                dfs(nx.id, result + nx.cost);
            }
        }
    }
}

class Node {
    int id;
    int cost;

    public Node(int id, int cost) {
        this.id = id;
        this.cost = cost;
    }
}

출력결과

[백준][Java] 19942번 다이어트

개발자 성현 — Mon, 13 Oct 2025 18:03:47 +0900

문제

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

풀이

그리디하게 풀 수 있는 방법이 떠오르지않았습니다. 그래서 백트래킹으로 순회하면서 찾기로했습니다.

우선 영양소의 최소 조건을 설정한 뒤 백트래킹으로 순회하면서 매번 최소 영양소 수치를 충족하는지 확인했습니다.

코드가 길어질 것 같아서 클래스로 따로 설정해서 풀어주었습니다.

코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    static String comboStr = "";
    static int[] minimumNutrient = new int[4];
    static int minCost = Integer.MAX_VALUE;
    static int[][] ingredients;
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int n = Integer.parseInt(br.readLine());
        int[] minimumTempNutrient = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        for (int i = 0; i < 4; i++) {
            minimumNutrient[i] = minimumTempNutrient[i];
        }

        ingredients = new int[n + 1][5];
        for (int i = 0; i < n; i++) {
            int[] ingredient = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
            for (int j = 0; j < 5; j++) {
                ingredients[i + 1][j] = ingredient[j];
            }
        }

        dfs(n, 1, new NutrientCombo(minimumNutrient[0], minimumNutrient[1], minimumNutrient[2], minimumNutrient[3]));

        if (minCost == Integer.MAX_VALUE) {
            System.out.println(-1);
        } else {
            System.out.println(minCost);
            System.out.println(comboStr);
        }
    }

    private static void dfs(int n, int start, NutrientCombo combo) {
        if (combo.isSatisfy()) {
            if (minCost > combo.cost) {
                minCost = combo.cost;
                comboStr = combo.printCombo();
            }
        }

        for (int i = start; i <= n; i++) {
            combo.addIngredient(i, ingredients[i]);
            dfs(n, i+1, combo);
            combo.removeIngredient(i, ingredients[i]);
        }
    }
}

class NutrientCombo {
    int lowerProtein;
    int lowerFat;
    int lowerTansoo;
    int lowerVitamin;

    int protein = 0;
    int fat = 0;
    int tansoo = 0;
    int vitamin = 0;
    int cost = 0;
    List<Integer> combo = new ArrayList<>();

    public NutrientCombo(int lowerProtein, int lowerFat, int lowerTansoo, int lowerVitamin) {
        this.lowerProtein = lowerProtein;
        this.lowerFat = lowerFat;
        this.lowerTansoo = lowerTansoo;
        this.lowerVitamin = lowerVitamin;
    }

    public void addIngredient(int idx, int[] ingredient) {
        protein += ingredient[0];
        fat += ingredient[1];
        tansoo += ingredient[2];
        vitamin += ingredient[3];
        cost += ingredient[4];
        combo.add(idx);
    }

    public void removeIngredient(int idx, int[] ingredient) {
        protein -= ingredient[0];
        fat -= ingredient[1];
        tansoo -= ingredient[2];
        vitamin -= ingredient[3];
        cost -= ingredient[4];
        combo.remove(combo.size() - 1);
    }

    public boolean isSatisfy() {
        if (lowerProtein > protein) return false;
        if (lowerFat > fat) return false;
        if (lowerTansoo > tansoo) return false;
        if (lowerVitamin > vitamin) return false;
        return true;
    }

    public String printCombo() {
        StringBuilder sb = new StringBuilder();
        for (Integer i : combo) {
            sb.append(i).append(" ");
        }
        return sb.toString();
    }
}

출력결과

[백준][Java] 23350번 K 물류창고

개발자 성현 — Thu, 18 Sep 2025 02:23:17 +0900

문제 링크

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

문제

풀이

구현문제입니다.

우선순위는 1에 가까울수록 낮은 우선 순위이며, M에 가까울수록 높은 우선순위를 갖습니다.

주의해야하는 부분은 우선순위가 높다해서 먼저 적재하는 것이 아니라, '낮은 우선순위'를 가질수록 먼저 적재합니다.

(깔아뭉개져도 상관없으니, 먼저 적재하는 것 같음)

낮은 우선순위에 따라 적재해야하며, 먼저 적재해야할 컨테이너가 레일에 있다면 그 외의 컨테이너는 레일의 처음으로 옮깁니다. 이때 비용은 무게만큼 지불해야합니다.

그리고 같은 우선순위를 가진 컨테이너 사이에서는 무게를 위에서부터 내림차순으로 쌓아야합니다.(무거운 것부터 아래로)

이때 먼저 적재된 컨테이너가 '현재 적재해야할 새로운 컨테이너'보다 무게가 적다면 있다면 옮겨놨다가 다시 쌓아야합니다. 컨테이너를 2번 옮겨야하기 때문에 비용이 이미 적재된 컨테이너의 무게의 2배를 비용으로 지불해야합니다.

따라서 비용은 아래와 같이 지불됩니다

- 레일의 처음으로 옮길 때

- 컨테이너를 적재할 때

- 무게가 작은 컨테이너를 잠시 옮길 때

코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    static PriorityQueue<Container> storage;
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // 컨테이너를 적재한다.
        // 1에 가까울 수록 높은 우선수위이며, M에 가까울수록 낮은 우선순위를 갖는다.
        // 우선순위가 낮은 순서로 적재한다.
        // 만일 우선순위가 낮은 컨테이너가 아직 존재한다면 높은 우선순위의 컨테이너는 레일의 처음으로 보낸다.
        // 우선순위 큐는 오직 메타정보를 저장하는 용도이자 내가 찾는 컨테이너가 무엇인지를 알려주고,
        // 컨테이너 자체 구현은 큐로 구현한다
        // 낮은 우선순위의 컨테이너가 오면 무조건 적재한다.
        // 따라서 추후에 우선순위가 같지만 무게가 더 무겁다면,
        // 이 과정을, 가벼운 컨테이너가 모두 빠질 때까지 반복한다. 이 과정에서 컨테이너를 뺄 때와 적재될 때 컨테이너의 무게만큼 비용이 발생한다.
        int[] input = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        int n = input[0];
        int m = input[1];

        List<Integer> priorities = new ArrayList<>();
        Deque<Container> rail = new ArrayDeque<>();
        // 레일의 처음으로 보낼 때, 컨테이너의 무게만큼 비용이 발생한다.
        storage = new PriorityQueue<>((Container a, Container b) -> {
            int val = Integer.compare(a.priority, b.priority);
            if (val == 0) return Integer.compare(a.weight, b.weight);
            return val;
        });

        for (int i = 0; i < n; i++) {
            int[] containerData = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
            int priority = containerData[0];
            int weight = containerData[1];
            priorities.add(priority);
            rail.offer(new Container(priority, weight));
        }

        priorities.sort((a, b) -> Integer.compare(b, a));

        int answer = 0;
        for (int idx = 0; idx < priorities.size(); idx++) {
            int targetPriority = priorities.get(idx);

            while (true) {
                Container cont = rail.poll();
                int curContPriority = cont.priority;

                if (curContPriority == targetPriority) {
                    // 찾았지만 아직 안에 넣어도 되는지 모른다. 무게 비교 필요
                    if (!storage.isEmpty()) answer += moveLighterContainer(cont);
                    storage.offer(cont);
                    answer += cont.weight;
                    break;
                }
                answer += cont.weight;
                rail.offer(cont);
            }
        }
        System.out.println(answer);
    }

    private static int moveLighterContainer(Container container) {
        int result = 0;
        int curContainerPriority = container.priority;
        int curContainerWeight = container.weight;
        List<Container> tempStorage = new ArrayList<>();

        while (!storage.isEmpty()) {
            Container topContainer = storage.peek();
            if (topContainer.priority == curContainerPriority && topContainer.weight < curContainerWeight) {
                result += topContainer.weight;
                tempStorage.add(storage.poll());
            } else {
                break;
            }
        }

        for (Container cont : tempStorage) storage.offer(cont);

        return result * 2;
    }
}

class Container {
    int priority;
    int weight;

    public Container(int priority, int weight) {
        this.priority = priority;
        this.weight = weight;
    }
}

출력결과

[백준][Java] 12834번 주간 미팅

개발자 성현 — Thu, 4 Sep 2025 15:27:07 +0900

문제

풀이

문제를 읽다보면 전형적으로 다익스트라 방식으로 구현해야한다는 것을 알 수 있습니다.

코드

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

public class Main {
    static int[][] graph;
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // KIST 기사단 N명의 집이 있는 노드 번호
        // KIST, 씨알푸드의 노드 번호
        // 한 사람의 거리 di = (집-KIST의 최단 거리) + (집-씨알푸드의 최단 거리)
        // 도달할 수 없는 경우의 최단 거리는 -1로 정의
        // 주어진 기사단의 총 거리 합을 계산하는 것이 목표

        int[] input = Arrays.stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt).toArray();
        int n = input[0];
        int v = input[1];
        int e = input[2];

        graph = new int[v+1][v+1];
        int[] targetNodes = Arrays.stream(br.readLine().split(" "))
                .mapToInt(Integer::parseInt).toArray();
        int kistNode = targetNodes[0];
        int crFoodNode = targetNodes[1];

        List<Integer> teammateNodes = Arrays.stream(br.readLine().split(" "))
                .map(Integer::parseInt).collect(Collectors.toList());

        int answer = 0;
        for (int i = 0; i < e; i++) {
            int[] data = Arrays.stream(br.readLine().split(" "))
                    .mapToInt(Integer::parseInt).toArray();
            int a = data[0];
            int b = data[1];
            int w = data[2];
            graph[a][b] = w;
            graph[b][a] = w;
        }

        for (int teammateNode : teammateNodes) {
            answer += dijkstra(v, teammateNode, kistNode, crFoodNode);
        }

        System.out.println(answer);
    }

    private static int dijkstra(int v, int teamHomeNode, int kist, int food) {
        int result = 0;

        PriorityQueue<Node> pq = new PriorityQueue<>(
                (Node a, Node b) -> Integer.compare(a.weight, b.weight));
        pq.offer(new Node(teamHomeNode, 0));
        int[] dis = new int[v+1];
        Arrays.fill(dis, Integer.MAX_VALUE);
        dis[teamHomeNode] = 0;

        while (!pq.isEmpty()) {
            Node curNode = pq.poll();

            if (curNode.weight > dis[curNode.id]) continue;

            for (int nextNodeId = 1; nextNodeId <= v; nextNodeId++) {
                int weight = graph[curNode.id][nextNodeId];
                if (weight == 0) continue;

                int newWeight = weight + curNode.weight;
                if (newWeight < dis[nextNodeId]) {
                    dis[nextNodeId] = newWeight;
                    pq.offer(new Node(nextNodeId, newWeight));
                }
            }
        }

        if (dis[food] == Integer.MAX_VALUE) result += -1;
        else result += dis[food];

        if (dis[kist] == Integer.MAX_VALUE) result += -1;
        else result += dis[kist];

        return result;
    }
}

class Node {
    int id;
    int weight;

    public Node(int id, int weight) {
        this.id = id;
        this.weight = weight;
    }
}

출력결과

[백준][Java] 13904번 과제

개발자 성현 — Sun, 31 Aug 2025 03:19:43 +0900

문제

풀이

백트래킹으로 풀어야하는가? 아니면 그리디로 풀 수 있는가? 2개의 고민부터 시작했다.

항상 시작은 완전탐색으로 생각해본다. 과제를 백트래킹으로 골라서 풀 수 있지않을까? 라는 생각이 들었지만 뚜렷하게 몇 개를 선택해야하는지를 알 수 없어서 그리디 풀이로 가야한다는 것으 느꼈다.(문제 제출 의도를 파악하려고 하는 편입니다. 운이 좋아서 떄려 맞춘걸수도.)

그리디로 풀게된다면 어떤 것이 주안점일까? 빠른 날짜와 큰 점수 중에서 고민이 되었다. 하지만 문제에서는 가장 큰 점수를 얻는 경우를 찾는 것이기 때문에 점수가 큰 과제들부터 먼저 해치우는걸로 생각을 바꾸었다. 그래서 가장 큰 점수의 문제부터 가능하다면 먼저 제출하는 쪽으로 코드를 작성했고, 아래의 코드가 만들어졌다.

코드

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

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

        // 시간복잡도면에서 그렇게 불리해보이지는 않는다.
        // 백트래킹이 맞는가? 안어룰리는 근거는?
        // 점수가 최댓값이어야하니 이 값들을 우선적으로 정렬해서 우겨넣어봐야한다.
        List<int[]> assignments = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            int[] assignmentData = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
            assignments.add(assignmentData);
        }

        assignments.sort(Comparator.comparing((int[] data) -> (data[1])).reversed());

        int answer = 0;
        boolean[] visited = new boolean[1001];

        for (int i = 0; i < n; i++) {
            int d = assignments.get(i)[0];
            int w = assignments.get(i)[1];

            int idx = d;
            while(idx > 0) {
                if (!visited[idx]) {
                    visited[idx] = true;
                    answer += w;
                    break;
                }
                idx--;
            }
        }
        System.out.println(answer);
    }
}

출력결과

[Java] Volatile: 메모리 가시성과 멀티스레딩

개발자 성현 — Wed, 13 Aug 2025 17:11:44 +0900

Java의 Volatile 키워드: 메모리 가시성과 멀티스레딩

백엔드 개발자로서 멀티스레드 환경을 다루다 보면, 데이터의 일관성과 가시성 문제가 자주 발생합니다.

특히 Java 개발자라면 Volatile 키워드가 왜 중요한지, 그리고 이를 어떻게 활용할지 이해하는 것이 핵심입니다.

이 글에서는 Volatile의 기본 개념부터 Java Memory Model(JMM)까지 단계적으로 설명하겠습니다. 실제 코드 예시를 통해 개념을 구체화하고, 나중에 다시 읽을 때 도움이 되도록 깊이 있게 다루겠습니다.

메모리 가시성(Memory Visibility)

멀티스레드 환경에서 한 스레드가 변경한 값이 다른 스레드에서 언제 보이는지에 대한 문제를 메모리 가시성(Memory Visibility)이라고 합니다. 이름 그대로 메모리에 변경한 값이 보이는가, 보이지 않는가에 대한 문제입니다.

스레드의 유휴 상태에 따른 컨텍스트 스위칭이 발생하면 캐시의 데이터가 메인 메모리의 데이터를 반영할 수 있지만, 컨텍스트 스위칭이 메인 메모리의 데이터를 반영을 보장하지 않습니다. 이는 상황과 하드웨어 설계에 의존하기 때문입니다.

이 문제를 더 구체적으로 이해하기 위해 예를 들어 보겠습니다. 두 스레드가 공유 변수를 사용하는 상황을 가정하겠습니다.

public class VisibilityExample {
    private boolean flag = false;

    public void writer() {
        flag = true;  *// 스레드 1에서 변경*
    }

    public void reader() {
        while (!flag) {
            *// 스레드 2에서 flag가 true가 될 때까지 대기*
        }
        System.out.println("Flag is now true");
    }
}

여기서 스레드 1이 flag를 true로 변경해도, 스레드 2가 이를 즉시 보지 못할 수 있습니다. 이는 각 스레드가 로컬 캐시를 사용하기 때문입니다. Volatile을 사용하지 않으면, 변경 사항이 메인 메모리에 즉시 반영되지 않아 무한 루프가 발생할 위험이 있습니다.

L1, L2 캐시와 Volatile의 역할

전체적인 문제는 코어 당 메인 메모리에 접근하는 것이 아니라 L1, L2와 같은 캐시에 접근하기 때문입니다. 따라서 캐시라는 중간 매개체가 존재하기 때문에 데이터가 변경되더라도 스레드 별로 변경된 데이터를 인식하는 데 시간이 걸립니다.

아래 이미지에서 스레드가 메인 메모리가 아닌 캐시에 먼저 접근하는 것을 알 수 있습니다.

Volatile은 메인 메모리에 직접 접근하게 해 메모리 가시성 문제를 해소합니다. 그래서 Volatile은 항상 메인 메모리에 접근하도록 합니다. 캐시를 사용하지 않습니다.

더 정확히 말하면, Volatile 변수는 읽기/쓰기 연산 시 캐시를 무시하고 메인 메모리와 직접 동기화됩니다. 이는 CPU 캐시 코히어런시 프로토콜(예: MESI 프로토콜)을 통해 보장되지만, Volatile 자체는 캐시를 완전히 배제하는 것이 아니라 가시성을 강제합니다.

예시를 확장해 Volatile을 적용해 보겠습니다.

public class VolatileExample {
    private volatile boolean flag = false;

    public void writer() {
        flag = true;  *// 메인 메모리에 즉시 반영*
    }

    public void reader() {
        while (!flag) {
            *// Volatile 덕분에 변경이 보임*
        }
        System.out.println("Flag is now true");
    }
}

Volatile을 추가하면, flag의 변경이 다른 스레드에게 보장되며 무한 루프를 피할 수 있습니다.
이는 JMM에서 Volatile이 happens-before 관계를 제공하기 때문입니다(아래에서 자세히 설명).

Volatile의 성능 영향

이럴 거면 캐시가 왜 굳이 존재하는가? 라는 생각이 당연히 들 것입니다. 우리는 캐시를 이용해서 빠른 데이터 접근을 할 수 있습니다.

그렇기에 메인 메모리에 비해 캐시가 가격이 비싸기도 합니다.

그래서 Volatile을 사용할 경우 데이터 접근이 모두 메인 메모리에서 이루어지기 때문에 성능이 캐시보다 좋지 않습니다.

주의할 점은 Volatile은 가시성을 보장하지만, 원자성을 보장하지 않습니다.

예를 들어, volatile int counter에 대한 counter++ 연산은 여전히 race condition이 발생할 수 있습니다.

성능 측면에서 Volatile은 캐시 미스를 유발할 수 있지만, 현대 JVM과 하드웨어 최적화로 인해 오버헤드가 크지 않습니다.

다만, 불필요한 Volatile 사용은 피해야합니다. 특히 공유 변수가 정말 가시성 문제가 있을 때만 적용하는 것이 좋습니다.

Java Memory Model(JMM)과 Happens-Before

Java Memory Model(JMM)은 멀티스레드 프로그램의 동작을 정의합니다. JMM은 스레드 간 작업의 순서를 보장하는 'happens-before' 관계를 중심으로 합니다. 이는 한 작업이 다른 작업 전에 '발생'했다고 보는 규칙입니다.

Volatile과 관련된 happens-before 규칙은 다음과 같습니다.

Volatile 변수에 쓰기 작업이 일어나면, 그 이후의 해당 변수 읽기 작업은 쓰기 결과를 봅니다.
Volatile 쓰기 전에 일어난 모든 작업은, 그 Volatile 읽기 후에 보입니다.

아래 예시를 보겠습니다.

public class HappensBeforeExample {
    private int value = 0;
    private volatile boolean ready = false;

    public void producer() {
        value = 42;
        ready = true;  *// Volatile 쓰기: value 설정이 보장됨*
    }

    public void consumer() {
        if (ready) {  *// Volatile 읽기*
            System.out.println(value);  *// 42 출력 보장*
        }
    }
}

여기서 ready의 Volatile 쓰기는 value 설정이 consumer에게 보이도록 합니다. 이는 JMM의 강력한 보장으로, 동기화 없이 안전한 publikation을 가능하게 합니다.

[백준][Python] 20006번 랭킹전 대기열

개발자 성현 — Tue, 5 Aug 2025 13:38:32 +0900

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

문제

코드

def solution():
    p, m = map(int, input().split())
    # 방의 레벨 제한 키: 순서, [레벨, 인원 수]
    room_info = dict()
    # 방에 누가 있는지 키: 순서, 누가있는지
    room_players = dict()
    idx = 0
    # 방은 생성순, 플레이어는 사전순
    for _ in range(p):
        level, name = input().split()
        level = int(level)
        is_join = False
        for key in room_info.keys():
            limit_level = room_info[key][0]
            room_player_numb = room_info[key][1]
            if room_player_numb == m:
                continue
            if limit_level - 10 <= level <= limit_level + 10:
                room_info[key][1] += 1
                room_players[key].append([level, name])
                is_join = True
                break
        if not is_join:
            idx += 1
            room_info[idx] = [level, 1]
            room_players[idx] = []
            room_players[idx].append([level, name])

    keys = sorted(list(room_info.keys()))
    for key in keys:
        _, player_num = room_info[key]
        if player_num == m:
            print("Started!")
        else:
            print("Waiting!")
        for player_info in sorted(room_players[key], key=lambda x : x[1]):
            print(*player_info)
    
solution()

풀이

구현 문제입니다. 그래서 어떻게 데이터를 저장해야 답을 표현할 수 있을지부터 생각했습니다.

2개의 딕셔너리를 사용하기로 했습니다.

room_info는 방의 입장하기 위한 기준 레벨과 입장한 인원 수를 관리합니다.

room_players는 특정 방의 입장한 사용자들의 정보를 저장하고 있습니다.

이 2개의 딕셔너리는 모두 방이 생성된 순서를 key를 기준으로 저장되어있습니다.

출력결과

[백준][Python] 1863번 스카이라인 쉬운거

개발자 성현 — Sat, 2 Aug 2025 01:37:22 +0900

문제

풀이

주어지는 n이 최대 50,000 이고 x 좌표의 범위는 1,000,000,0 이고 y좌표의 범위는 500,000이기에 이차원 리스트로 풀어볼 생각은 버리게 되었습니다.

일차원 리스트로 좌표의 높이를 나타내야겠다라는 생각이 들었습니다. 현재 주어진 좌표를 기준으로 이전 좌표들 중에서 더 높은 좌표들을 빌딩으로 치환합니다. 스택으로 문제를 풀어도 되고 저는 중복된 수를 처리하기 위해서 딕셔너리로 처리했습니다.

코드

from collections import defaultdict

def solution():
    n = int(input())

    heights_set = defaultdict(int)
    answer = 0

    for _ in range(n):
        x, y = map(int, input().split())
        for ex_h in heights_set.keys():
            if ex_h > y and heights_set[ex_h] > 0:
                answer += 1
                heights_set[ex_h] = 0
        if y != 0:
            heights_set[y] = 1

    for ex_h in heights_set.keys():
        if heights_set[ex_h] > 0:
            answer += 1

    print(answer)

solution()

출력결과

[백준][Python] 30970번 선택의 기로

개발자 성현 — Sat, 2 Aug 2025 00:51:06 +0900

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

문제

풀이

리스트 안에 입력값을 집어넣은 다음에 람다로 정렬을 수행하면 풀 수 있습니다.

품질과 가격 순서로 고가치 고가성비 촉석루 미니어처를 고른다면 key: lambda x: x[0], -x[1]과 같이 정렬을 손쉽게 할 수 있습니다.

코드

import sys

def solution():
    n = int(input())
    rocks = []
    for _ in range(n):
        rock_info = list(map(int, sys.stdin.readline().strip().split()))
        rocks.append(rock_info)

    prefer_quality_rocks = sorted(rocks, key = lambda x: (x[0], -x[1]), reverse = True)
    prefer_price_rocks = sorted(rocks, key = lambda x: (-x[1], x[0]), reverse = True)

    print(*prefer_quality_rocks[0], *prefer_quality_rocks[1])
    print(*prefer_price_rocks[0], *prefer_price_rocks[1])

solution()

출력결과

[백준][Python] 13748번 Periodic Strings

개발자 성현 — Sat, 2 Aug 2025 00:30:31 +0900

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

문제

"k-주기 문자열"을 다음과 같이 정의합니다. 문자열 s가 k-주기(k-periodic)라는 것은, 문자열의 길이 |s|가 k의 배수이고, 문자열을 길이 k의 부분 문자열들(|s|/k개)로 잘랐을 때, 각 부분 문자열(첫 번째 제외)이 바로 이전 부분 문자열의 마지막 문자를 맨 앞으로 이동시킨 것과 같은 경우를 말합니다. 예를 들어, abccabbcaabc는 3-주기 문자열입니다. 이 문자열은 abc, cab, bca, abc로 나뉘며, 각 부분 문자열은 이전 부분 문자열의 회전 형태입니다(abc → cab, cab → bca, bca → abc). 주어진 문자열에 대해, 그 문자열이 k-주기가 되는 가장 작은 k값을 찾으세요.

입력

입력은 한 줄이며, 소문자로만 구성된 문자열 s를 포함합니다 (문자열 길이: 1 이상 100 이하).

출력

입력된 문자열이 k-주기가 되는 가장 작은 k값을 나타내는 정수 하나를 출력합니다.

풀이

항상 첫 풀이의 시작은 완전탐색으로 생각했습니다. 입력 값의 범위도 크지않아서 부담스럽지않았습니다.

K 길이의 문자를 잘라서 주기 별로 뒷 문자를 앞 문자로 옮겨서 같은지 비교하는 방식으로 문제를 풀었습니다.

코드

def solution():
    answer = 1
    word = list(input())
    word_length = len(word)
    for k in range(1, word_length + 1):
        if word_length % k == 0:
            # 마지막 문자를 맨 앞으로 옮긴 것과 같아야함
            if compareTwoWord(k, word_length, word):
                answer = k
                break
    print(answer)

def compareTwoWord(k, word_length, word):
    idx = k
    k_word = word[:k]
    while idx - 1 + k  < word_length:
        temp = k_word.pop()
        k_word.insert(0, temp)

        for i in range(k):
            if k_word[i] != word[idx + i]:
                return False

        idx += k

    return True

solution()