오늘은 여기까지

최소 신장 트리 (MST) - 크루스칼 알고리즘, 프림 알고리즘

dev-99 — Thu, 16 Jan 2025 10:30:38 +0900

1. 신장 트리 (Spanning Tree)

그래프 내 모든 정점을 포함하는 트리다. 그래프의 최소 연결 부분이다.

모든 정점이 연결되어 있음
사이클이 존재하지 않음
간선의 개수 = 정점의 개수 - 1

DFS, BFS를 이용하여 그래프에서 Spanning Tree를 찾을 수 있다. 탐색 도중 사용한 간선만 모으면 된다.

하나의 그래프는 여러 개의 Spanning Tree를 가질 수 있다.

2. 최소 신장 트리, (Minimum Spanning Tree)

Spanning Tree 중에서 사용된 간선들의 가중치 합이 최소인 트리

모든 정점이 연결되어 있음
사이클이 존재하지 않음
간선의 개수 = 정점의 개수 - 1
간선들의 가중치 합이 최소

그리디 알고리즘을 사용하는 대표적인 트리 형태의 자료구조

3. MST 구현 방법

3.1 크루스칼 알고리즘

1. 동작 원리

간선들을 가중치의 오름차순으로 정렬
가장 작은 가중치부터 시작하여 사이클을 형성하지 않는 간선을 선택
Union-Find 자료구조를 활용하여 사이클 여부 판단

2. 구현 시 포인트

Union-Find 자료구조 구현
간선 정렬
사이클 검사

3. 구현

class Edge implements Comparable<Edge> {
    int src, dest, weight;
    
    Edge(int src, int dest, int weight) {
        this.src = src;
        this.dest = dest;
        this.weight = weight;
    }
    
    @Override
    public int compareTo(Edge other) {
        return this.weight - other.weight;
    }
}

class KruskalMST {
    private int[] parent;
    private int[] rank;
    
    private int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }
    
    private void union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        
        if (rank[rootX] < rank[rootY]) {
            parent[rootX] = rootY;
        } else if (rank[rootX] > rank[rootY]) {
            parent[rootY] = rootX;
        } else {
            parent[rootY] = rootX;
            rank[rootX]++;
        }
    }
    
    public List<Edge> kruskal(List<Edge> edges, int V) {
        List<Edge> result = new ArrayList<>();
        parent = new int[V];
        rank = new int[V];
        
        // 초기화
        for (int i = 0; i < V; i++) {
            parent[i] = i;
            rank[i] = 0;
        }
        
        // 간선을 가중치 기준으로 정렬
        Collections.sort(edges);
        
        int edgeCount = 0;
        int index = 0;
        
        while (edgeCount < V - 1 && index < edges.size()) {
            Edge edge = edges.get(index++);
            
            int x = find(edge.src);
            int y = find(edge.dest);
            
            if (x != y) {
                result.add(edge);
                union(x, y);
                edgeCount++;
            }
        }
        
        return result;
    }
}

3.2 프림 알고리즘

1. 동작 원리

임의의 정점에서 시작
현재 트리와 연결된 간선 중 가장 가중치가 작은 간선을 선택 (사이클 형성X)
새로운 정점을 트리에 추가

2. 구현 시 포인트

우선순위 큐 활용
방문 체크 배열
최소 가중치 갱신

3.3 알고리즘 비교

	크루스칼 (Kruskal)	프림 (Prim)
시간 복잡도	O(E log E) (E는 간선의 개수)	O(E log V) (우선순위 큐 사용 시)
탐색 방법	최소 가중치를 갖는 간선부터 하나씩 추가	임의 정점에서 최소 인접 가중치를 갖는 정점을 추가
상황	간선이 적은 그래프에 적합	간선이 많은 그래프에 적합

[백준/2870] 수학숙제 - 자바 Java

dev-99 — Thu, 16 Jan 2025 10:30:24 +0900

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

출처: COCI 2010/2011 Contest #2

문제

숫자와 알파벳 소문자로 되어있는 글자가 N줄있다. 상근이는 여기서 숫자를 모두 찾은 뒤, 이 숫자를 비내림차순으로 정리해야한다. 숫자의 앞에 0이 있는 경우에는 정리하면서 생략할 수 있다.
글자를 살펴보다가 숫자가 나오는 경우에는, 가능한 가장 큰 숫자를 찾아야 한다. 즉, 모든 숫자의 앞과 뒤에 문자가 있거나, 줄의 시작 또는 끝이어야 한다.
예를 들어, 01a2b3456cde478에서 숫자를 찾으면 1, 2, 3456, 478이다.

첫째 줄에 종이의 줄의 개수 N이 주어진다. (1 ≤ N ≤ 100)

다음 N개의 줄에는 각 줄의 내용이 주어진다. 각 줄은 최대 100글자이고, 항상 알파벳 소문자와 숫자로만 이루어져 있다.

종이에서 찾은 숫자의 개수를 M이라고 하면, 출력은 M줄로 이루어져야 한다. 각 줄에는 종이에서 찾은 숫자를 하나씩 출력해야 한다. 이때, 비내림차순으로 출력해야 한다. 비내림차순은 내림차순의 반대인 경우인데, 다음 수가 앞의 수보다 크거나 같은 경우를 말한다.

풀이

최대 100글자까지의 입력이 들어오기 때문에 int, long이 아닌 BigInteger 객체를 사용해야 한다.
자바에서 문자열을 정수로 파싱할 때 자동으로 숫자의 앞에 오는 0은 무시된다.

import java.io.*;
import java.math.BigInteger;
import java.util.*;

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

        for (int i = 0; i < n; i++) {
            String input = br.readLine();
            boolean cont = false;

            for (int j = 0; j < input.length(); j++) {
                char c = input.charAt(j);

                if (Character.isDigit(c)) {
                    sb.append(c);
                    cont = true;
                } else if (Character.isLetter(c)) {
                    cont = false;
                }

                if (!cont && sb.length() > 0) { // 숫자 입력이 끝난 경우
                    answer.add(new BigInteger(sb.toString()));
                    sb.setLength(0);
                }

                if (j == input.length() - 1 && sb.length() > 0) { // 마지막 입력인 경우
                    answer.add(new BigInteger(sb.toString()));
                }
            }
        }

        Collections.sort(answer);
        for (BigInteger l : answer) {
            System.out.println(l);
        }
    }
}

그리디 알고리즘

dev-99 — Thu, 16 Jan 2025 10:00:13 +0900

그리디 알고리즘

문제 해결 과정에서 단계마다 눈앞에 최선의 선택을 하고, 선택은 번복하지 않는다.

그리디 알고리즘이 최적해를 보장하려면?

최적 부분 구조: 부분해를 푸는 과정이 최적해를 구하는 과정과 일치
그리디 선택 속성: 선택 과정이 다른 과정에 영향을 주지 않음

배낭 문제

부분 배낭 문제

짐을 쪼갤 수 있는 배낭 문제를 가정하자.

배낭에 담을 수 있는 최대 무게가 존재하고, 무게와 가치가 다른 짐들이 있다. 이 짐들을 조합해서 배낭의 무게를 초과하지 않으면서 담은 가치를 최대로 하는 문제를 배낭 문제라고 한다.

부분 배낭 문제는 무게당 가치가 높은 짐을 최대한 많이 넣는 그리디 알고리즘을 사용하면 된다.

짐별로 무게당 가치를 구한다
무게당 가치가 높은 짐부터 넣을 수 있는 만큼 배낭에 넣는다
1. 배낭 용량이 짐 무게보다 크면 짐을 쪼개서 넣는다.
배낭이 허용하는 용량이 0이 될 때까지 수행한다.

무게당 가치가 제일 높은 짐은 A이므로 먼저 10kg을 배낭에 넣는다.

그 다음으로 가치가 높은 짐 C를 5kg만 넣는다.

0/1 배낭 문제

짐을 쪼갤 수 없는 배낭 문제를 가정하자.

더 이상 짐을 쪼갤 수 없기 때문에 지금 선택한 짐이 다음 짐 선택에 영향을 미친다.

따라서 그리디 알고리즘을 적용하면 최적의 해를 구할 수 없다.

최적의 해를 구하려면 dp로 접근해야 한다.

위와 같은 문제로 예를 들면, 무게당 가치가 높은 짐부터 넣을 시 A를 먼저 10kg 넣게 된다. 가용 용량은 5kg이 남고, 배낭에 넣은 짐의 가치는 19이다.

하지만 B, C를 넣었다면 더 높은 가치인 20으로 짐 13kg을 넣을 수 있다.

이처럼 그리디 알고리즘으로 구한 해가 최적의 해임을 보장하기 위해서는 현재 선택이 다음 선택에 영향을 미치지 않아야 한다.

그리디 vs 동적 프로그래밍

	그리디	동적 프로그래밍
문제 해결 방식	각 단계에서 현재 최적의 선택만 수행	부분 문제의 해를 저장하고 재활용하여 전체 문제 해결
최적해 보장	일부 문제에서만 최적해 보장	항상 최적해 보장
실행 속도	일반적으로 매우 빠름 O(n) 또는 O(n log n)	일반적으로 그리디보다 느림 O(n²) 이상
메모리 사용	매우 적음	중간~많음 (메모이제이션 테이블 필요)
적용 가능한 예시	• 거스름돈 문제 • 회의실 배정 • 크루스칼 알고리즘 • Fractional Knapsack	• 0/1 Knapsack • 최장 증가 수열(LIS) • 행렬 곱셈
성립 조건	• 최적 부분 구조를 가짐 (부분적인 최적해가 전체 최적해로 이어짐) • 이전 선택이 이후 선택에 영향을 주지 않음	• 최적 부분 구조를 가짐 • 중복되는 부분 문제가 존재
중복 부분 문제	중복 부분 문제를 해결하지 않음	중복 부분 문제를 해결할 수 있음
시간 복잡도 개선 가능성	제한적	메모이제이션으로 크게 개선 가능

[백준/2876] 그래픽스 퀴즈 - Java 자바

dev-99 — Sat, 11 Jan 2025 10:30:40 +0900

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

문제 출처: COCI 2010/2011, Contest #1

문제

교실에는 N개의 책상이 일렬로 놓여있고, 한 책상에 학생 2명이 앉는다.

교수는 퀴즈를 채점할때 점수 등급마다 다른 색상의 연필로 채점한다.

오늘 교수는 한 가지 색연필만 가져왔기 때문에 아래와 같은 방법으로 채점하려고 한다.

책상 2개를 선택하여 해당 범위 내 책상마다 한 명의 학생을 선택한다. 이때 양끝의 책상 또한 포함한다.
한 가지 색연필만 가져왔기 때문에 고른 학생들 모두 같은 점수를 가져야 한다.

교수가 한 가지 색만을 이용해 채점할 수 있는 최대 학생 수와 그때의 점수 등급을 출력한다.

만약 답이 여러 가지라면, 가장 작은 점수 등급을 출력한다.

입력의 첫 번째 줄에는 정수 N이 주어진다(1 ≤ N ≤ 100,000).
다음 N개의 줄에는 i번째 책상에 앉은 두 학생이 받아야 할 그레이드 Ai와 Bi(1 ≤ Ai, Bi ≤ 5)가 주어진다.

입출력 예시

입력	출력
3 3 5 4 5 1 3	2 5
4 2 1 3 2 5 3 2 5	2 2

풀이

모든 경우의 수를 탐색하기에는 N이 너무 크기 때문에 교수가 점수 등급 1을 줄때, 2를 줄때, .... 가정한다.

책상에 앉아있는 학생들을 순회하며 점수 등급과 같은 점수를 가진 학생이 연달아 몇명 있는지 확인한다.

해당 점수 등급을 가진 학생들이 최대로 연속으로 앉아있는 경우의 수를 출력한다.

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

public class Main {
    static int max = 100001;
    static int n, numOfStudents, grade;
    static int[] A = new int[max];
    static int[] B = new int[max];

    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());
        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(br.readLine());
            A[i] = Integer.parseInt(st.nextToken());
            B[i] = Integer.parseInt(st.nextToken());
        }

        for (int score = 1; score <= 5; score++) {
            int count = 0;
            for (int i = 0; i < n; i++) {
                if (A[i] == score || B[i] == score) count++;
                else count = 0;
                if (numOfStudents < count) {
                    numOfStudents = count;
                    grade = score;   
                }
            }
        }

        System.out.println(numOfStudents + " " + grade);
    }
}

[백준/1010] 다리 놓기 - Java 자바

dev-99 — Fri, 10 Jan 2025 10:30:10 +0900

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

개념: dp, 조합

문제

재원이는 한 도시의 시장이 되었다. 이 도시에는 도시를 동쪽과 서쪽으로 나누는 큰 일직선 모양의 강이 흐르고 있다. 하지만 재원이는 다리가 없어서 시민들이 강을 건너는데 큰 불편을 겪고 있음을 알고 다리를 짓기로 결심하였다. 강 주변에서 다리를 짓기에 적합한 곳을 사이트라고 한다. 재원이는 강 주변을 면밀히 조사해 본 결과 강의 서쪽에는 N개의 사이트가 있고 동쪽에는 M개의 사이트가 있다는 것을 알았다. (N ≤ M)

재원이는 서쪽의 사이트와 동쪽의 사이트를 다리로 연결하려고 한다. (이때 한 사이트에는 최대 한 개의 다리만 연결될 수 있다.) 재원이는 다리를 최대한 많이 지으려고 하기 때문에 서쪽의 사이트 개수만큼 (N개) 다리를 지으려고 한다. 다리끼리는 서로 겹쳐질 수 없다고 할 때 다리를 지을 수 있는 경우의 수를 구하는 프로그램을 작성하라.

입력의 첫 줄에는 테스트 케이스의 개수 T가 주어진다. 그 다음 줄부터 각각의 테스트케이스에 대해 강의 서쪽과 동쪽에 있는 사이트의 개수 정수 N, M (0 < N ≤ M < 30)이 주어진다.

각 테스트 케이스에 대해 주어진 조건하에 다리를 지을 수 있는 경우의 수를 출력한다.

풀이

nCr 조합을 구하는 문제다. 고등학교 졸업한지가 오래 전이라 nCr = n-1Cr-1 + n-1Cr 수학식이 가물가물하다.

재귀로 풀었더니 제대로 못 푼건지 시간 초과가 떠서 bottom up 방식으로 풀었다.

미리 dp 조합 값들을 계산해두고 테스트 케이스마다 `mCn` 값인 `dp[m][n]`을 출력해준다.

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));
        int t = Integer.parseInt(br.readLine());
        
        // 미리 조합 값을 계산해두기
        int[][] dp = new int[31][31];
        dp[0][0] = 1;
        
        for(int i = 1; i <= 30; i++) {
            dp[i][0] = 1;  // nC0 = 1
            for(int j = 1; j <= i; j++) {
                dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
            }
        }
        
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < t; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            int m = Integer.parseInt(st.nextToken());
            sb.append(dp[m][n]).append('\n');
        }
        System.out.print(sb);
    }
}

[백준/2839] 설탕 배달 - Java 자바

dev-99 — Tue, 7 Jan 2025 11:30:22 +0900

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

출처: COCI 2010/2011 Contest #7

문제

상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨져 있다. 봉지는 3킬로그램 봉지와 5킬로그램 봉지가 있다.

상근이는 귀찮기 때문에, 최대한 적은 봉지를 들고 가려고 한다. 예를 들어, 18킬로그램 설탕을 배달해야 할 때, 3킬로그램 봉지 6개를 가져가도 되지만, 5킬로그램 3개와 3킬로그램 1개를 배달하면, 더 적은 개수의 봉지를 배달할 수 있다.

상근이가 설탕을 정확하게 N킬로그램 배달해야 할 때, 봉지 몇 개를 가져가면 되는지 그 수를 구하는 프로그램을 작성하시오.

첫째 줄에 N이 주어진다. (3 ≤ N ≤ 5000)

상근이가 배달하는 봉지의 최소 개수를 출력한다. 만약, 정확하게 N킬로그램을 만들 수 없다면 -1을 출력한다.

입력	결과
18	4
4	-1
6	2
9	3
11	3

풀이

dp 문제를 풀고 싶어서 문제집에서 선택했는데 그냥 수학적으로 접근하는게 빠른거 같다. N도 작은 편이다.

public class Main {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        while (n % 5 != 0) {
            n -= 3;
            count++;
        }
        if (n < 0) count = -1;
        else count += n / 5;
        System.out.println(count);
    }
}

N이 5로 나누어지면 5키로 봉지를 드는게 맞다.

5로 나누어지지 않는다면 3키로 봉지를 적어도 1개 사용해야 한다.

→ 따라서 5로 나누어질 때까지 3키로 봉지를 사용한다. 이후 5키로 봉지를 사용한다.

→ `N < 0` 인 경우(정확하게 N키로를 만들 수 없는 경우) -1을 출력한다.

[프로그래머스] 주문량이 많은 아이스크림들 조회하기 - MySQL

dev-99 — Sat, 4 Jan 2025 22:00:37 +0900

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

프로그래머스

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

programmers.co.kr

문제

다음은 아이스크림 가게의 상반기 주문 정보를 담은 FIRST_HALF 테이블과 7월의 아이스크림 주문 정보를 담은 JULY 테이블입니다.

FIRST_HALF

NAME	TYPE	NULLABLE
SHIPMENT_ID	INT(N)	FALSE
FLAVOR	VARCHAR(N)	FALSE
TOTAL_ORDER	INT(N)	FALSE

JULY

NAME	TYPE	NULLABLE
SHIPMENT_ID	INT(N)	FALSE
FLAVOR	VARCHAR(N)	FALSE
TOTAL_ORDER	INT(N)	FALSE

7월에는 아이스크림 주문량이 많아 같은 아이스크림에 대하여 서로 다른 두 공장에서 아이스크림 가게로 출하를 진행하는 경우가 있습니다. 이 경우 같은 맛의 아이스크림이라도 다른 출하 번호를 갖게 됩니다.

7월 아이스크림 총 주문량과 상반기의 아이스크림 총 주문량을 더한 값이 큰 순서대로 상위 3개의 맛을 조회하는 SQL 문을 작성해주세요.

풀이

SELECT A.FLAVOR
FROM (
    SELECT * FROM FIRST_HALF
    UNION
    SELECT * FROM JULY
) AS A
GROUP BY A.FLAVOR
ORDER BY SUM(A.TOTAL_ORDER) DESC
LIMIT 3

MySQL은 full outer join을 지원하지 않는다는 사실을 새로 알게 됐다,,

UNION이나 서브쿼리 없이도 풀 수 있다.

SELECT A.FLAVOR
FROM FIRST_HALF A
JOIN JULY B
ON A.FLAVOR = B.FLAVOR
GROUP BY A.FLAVOR
ORDER BY A.TOTAL_ORDER + SUM(B.TOTAL_ORDER) DESC
LIMIT 3

[프로그래머스] 징검다리 건너기 - 자바 Java

dev-99 — Sat, 21 Dec 2024 09:00:27 +0900

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

프로그래머스

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

programmers.co.kr

개념: 이분탐색

문제 설명

디딤돌의 숫자는 한 번 밟을 때마다 1씩 줄어든다.
디딤돌의 숫자가 0이 되면 더 이상 밟을 수 없고, 이때는 그 다음 디딤돌로 한번에 여러 칸을 건너 뛸 수 있다.
무조건 가장 가까운 디딤돌로만 건너뛴다.
한 번에 한 명씩 징검다리를 건너야 하며, 한 명이 징검다리를 모두 건넌 후에 그 다음 사람이 건너기 시작한다.
징검다리를 건너야 하는 사람들의 수는 무제한이라고 간주한다.

디딤돌에 적힌 숫자가 순서대로 담긴 배열 `stones`와 한 번에 건너뛸 수 있는 디딤돌의 최대 칸수 `k`가 매개변수로 주어질 때, 최대 몇 명까지 징검다리를 건널 수 있는지 return 하도록 solution 함수를 완성해주세요.

`stones` 배열 각 원소들의 값은 1 이상 200,000,000 이하인 자연수다.

입출력 예시

stones	k	result
[2, 4, 5, 3, 2, 1, 4, 2, 5, 1]	3	3

4번째 사람은 다리를 건널 수 없다

풀이

사람 0번, 1번, 2번, … 이렇게 지나간다고 가정할 때,
- (디딤돌 수) - (사람 번호) < 0 인 경우가 연속으로 k번 이상이면 못 건넌다
  - 가능한 답인 0~200,000,000 중에서 못 건너게 되는 지점을 이분탐색을 통해 찾는다

import java.util.*;

class Solution {
    static int[] Stones;

    public static int binarySearch(int left, int right, int k) {
        if (left <= right) {
            int mid = (left + right) / 2;

            if (checkCross(mid, k)) {
                return binarySearch(mid + 1, right, k);
            } else {
                return binarySearch(left, mid - 1, k);
            }
        }

        return left;
    }

    public static boolean checkCross(int M, int k) {
        int zero = 0;
        for (int i = 0; i < Stones.length; i++) {
            if (Stones[i] - M <= 0) {
                zero++;
                if (zero >= k) {
                    return false;
                }
            } else {
                zero = 0;
            }
        }
        return true;
    }

    public int solution(int[] stones, int k) {
        Stones = stones;
        int answer = binarySearch(0, 200000001, k);
        return answer;
    }
}

[프로그래머스] 호텔 방 배정 - 자바 Java

dev-99 — Fri, 20 Dec 2024 09:00:01 +0900

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

프로그래머스

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

programmers.co.kr

문제

호텔에 투숙하려는 고객들에게 방을 배정하려 합니다. 호텔에는 방이 총 k개 있으며, 각각의 방은 1번부터 k번까지 번호로 구분하고 있습니다. 처음에는 모든 방이 비어 있으며 다음과 같은 규칙에 따라 고객에게 방을 배정하려고 합니다.

한 번에 한 명씩 신청한 순서대로 방을 배정합니다.
고객은 투숙하기 원하는 방 번호를 제출합니다.
고객이 원하는 방이 비어 있다면 즉시 배정합니다.
고객이 원하는 방이 이미 배정되어 있으면 원하는 방보다 번호가 크면서 비어있는 방 중 가장 번호가 작은 방을 배정합니다.

전체 방 개수 k와 고객들이 원하는 방 번호가 순서대로 들어있는 배열 room_number가 매개변수로 주어질 때, 각 고객에게 배정되는 방 번호를 순서대로 배열에 담아 return 하도록 solution 함수를 완성해주세요.

입출력

k	room_number	result
10	[1,3,4,1,3,1]	[1,3,4,2,5,6]

풀이

원하는 방이 이미 배정되었을 때, 그 방보다 큰 첫 번째 가능한 방을 찾아야 한다. 따라서 HashMap을 사용하여 각 방 번호에 대해 다음으로 사용 가능한 방 번호를 저장한다. `roomMap.put(예약된 방, 다음으로 예약 가능한 방)`

전체코드

import java.util.*;

class Solution {
    public long[] solution(long k, long[] room_number) {
        HashMap<Long, Long> roomMap = new HashMap<>();  // 다음 사용 가능한 방 번호를 저장
        int n = room_number.length;
        long[] answer = new long[n];
        
        for (int i = 0; i < n; i++) {
            answer[i] = findEmptyRoom(room_number[i], roomMap);
        }
        
        return answer;
    }
    
    public long findEmptyRoom(long want, HashMap<Long, Long> roomMap) {
        // 원하는 방이 비어있으면 바로 배정
        if (!roomMap.containsKey(want)) {
            roomMap.put(want, want + 1);  // 다음 사용 가능한 방을 want + 1로 설정
            return want;
        }
        
        // 이미 배정된 방이면 재귀적으로 다음 방 찾기
        long nextRoom = findEmptyRoom(roomMap.get(want), roomMap);
        roomMap.put(want, nextRoom + 1);  // 현재 방의 다음 가능한 방 업데이트
        return nextRoom;
    }
}

1단계) room_number[0] = 1 요청 결과 roomMap에는 `{1 → 2}`이 저장되어 있다.

2단계) room_number[1] = 3 요청 결과: `{1 → 2, 3 → 4}`

3단계) room_number[2] = 4 요청 결과: `{1 → 2, 3 → 4, 4 → 5}`

4단계) room_number[3] = 1 요청 결과: `{1 → 3, 2 → 3, 3 → 4, 4 → 5}`

1은 이미 사용 중이다. 1 → 2를 통해 확인할 수 있다.
2번 방을 배정한다. (2 → 3 추가)
1의 다음 방을 3으로 업데이트한다. (1 → 3)

5단계) room_number[4] = 3 요청 결과: `{1 → 3, 2 → 3, 3 → 6, 4 → 6, 5 → 6}`

3은 이미 사용 중이다. 3 → 4를 통해 확인
4도 이미 사용 중이다. 4 → 5를 통해 확인
그 다음 큰 방인 5번 방을 배정한다. (5 → 6 추가)
4 → 6으로 업데이트
3 → 6으로 업데이트

...

[프로그래머스] 지형 이동 - 자바 Java

dev-99 — Wed, 18 Dec 2024 10:00:25 +0900

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

프로그래머스

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

programmers.co.kr

개념: bfs, 정렬

문제 설명

N x N 크기인 정사각 격자 형태의 지형이 있습니다. 각 격자 칸은 1 x 1 크기이며, 숫자가 하나씩 적혀있습니다. 격자 칸에 적힌 숫자는 그 칸의 높이를 나타냅니다.

이 지형의 아무 칸에서나 출발해 모든 칸을 방문하는 탐험을 떠나려 합니다. 칸을 이동할 때는 상, 하, 좌, 우로 한 칸씩 이동할 수 있는데, 현재 칸과 이동하려는 칸의 높이 차가 height 이하여야 합니다. 높이 차가 height 보다 많이 나는 경우에는 사다리를 설치해서 이동할 수 있습니다. 이때, 사다리를 설치하는데 두 격자 칸의 높이차만큼 비용이 듭니다. 따라서, 최대한 적은 비용이 들도록 사다리를 설치해서 모든 칸으로 이동 가능하도록 해야 합니다. 설치할 수 있는 사다리 개수에 제한은 없으며, 설치한 사다리는 철거하지 않습니다.

각 격자칸의 높이가 담긴 2차원 배열 land와 이동 가능한 최대 높이차 height가 매개변수로 주어질 때, 모든 칸을 방문하기 위해 필요한 사다리 설치 비용의 최솟값을 return 하도록 solution 함수를 완성해주세요.

입출력 예

land	height	result
[[1, 4, 8, 10], [5, 5, 5, 5], [10, 10, 10, 10], [10, 10, 10, 20]]	3	15
[[10, 11, 10, 11], [2, 21, 20, 10], [1, 20, 21, 11], [2, 1, 2, 1]]	1	18

풀이

우선순위 큐를 통해 이동할 수 있는 다음 칸 중 비용이 가장 적은 칸부터 접근하도록 구현한다.

전체코드

import java.util.*;

class Solution {
    static int N, answer;
    static int[] dx = {1, -1, 0, 0};
    static int[] dy = {0, 0, 1, -1};
    static boolean[][] visited;
    static PriorityQueue<Node> pq = new PriorityQueue<>();

    static class Node implements Comparable<Node> {
        int x, y, cost;
        
        public Node(int x, int y, int cost) {
            this.x = x;
            this.y = y;
            this.cost = cost;
        }

        // 비용 오름차순 정렬
        @Override
        public int compareTo(Node other) {
            return Integer.compare(this.cost, other.cost);
        }
    }

    public int solution(int[][] land, int height) {
        N = land.length;
        answer = 0;
        visited = new boolean[N][N];

        pq.offer(new Node(0, 0, 0));

        while (!pq.isEmpty()) {
            Node curr = pq.poll();  // 다음 칸 중 비용이 최소인 칸을 선택

            if (visited[curr.x][curr.y]) {
                continue;
            }

            visited[curr.x][curr.y] = true;
            answer += curr.cost;

            for (int i = 0; i < 4; i++) {
                int nx = curr.x + dx[i];
                int ny = curr.y + dy[i];

                if (0 <= nx && nx < N && 0 <= ny && ny < N) {
                    // 비용 처리
                    int heightDiff = Math.abs(land[nx][ny] - land[curr.x][curr.y]);
                    int newCost = heightDiff > height ? heightDiff : 0;
                    pq.offer(new Node(nx, ny, newCost));
                }
            }
        }
        
        return answer;
    }
}

[Spring] Spring MVC 프레임워크

dev-99 — Tue, 17 Dec 2024 05:21:07 +0900

Spring MVC란?

Spring MVC는 웹 애플리케이션 개발을 위한 Java 기반의 프레임워크이다. MVC 패턴을 기반으로 하여 웹 애플리케이션을 구조적으로 개발할 수 있게 해준다.

주요 특징

유연하고 확장 가능한 웹 애플리케이션 개발 가능
DI(Dependency Injection)와 IoC(Inversion of Control) 지원
RESTful 웹 서비스 구현 용이
다양한 뷰 기술 지원 (JSP, Thymeleaf 등)

핵심 컴포넌트 (DispatchServlet, Model, View, Controller)

1. DispatchServlet ✔️

프론트 컨트롤러 역할

모든 웹 요청의 진입점
요청을 적절한 핸들러에게 전달하고 응답을 관리

2. Controller

비즈니스 로직을 처리
요청을 처리하고 모델을 업데이트
적절한 뷰를 선택하여 반환

3. Model

데이터와 비즈니스 로직을 포함
컨트롤러와 뷰 사이의 데이터 전달 역할

4. View

모델 데이터를 표시
다양한 뷰 기술 활용 가능 (JSP, Thymeleaf 등)

✔️ 동작 원리

클라이언트 요청
- 클라이언트가 서버에 HTTP 요청을 보냄
- 모든 요청은 DispatcherServlet이 먼저 받음 (프론트컨트롤러 역할)
핸들러 매핑과 핸들러 조회
- DispatcherServlet이 HandlerMapping을 통해 요청 URL에 매핑된 핸들러(컨트롤러)를 조회한다.
- HandlerAdapter 목록에서 해당 핸들러를 처리할 수 있는 어댑터를 찾는다.
핸들러 어댑터 실행
- 찾은 HandlerAdapter를 통해 핸들러를 실행한다.
- 핸들러의 실행 결과로 ModelAndView를 반환한다.
ViewResolver ✔️ 실행
- DispatcherServlet은 ViewResolver를 호출하여 ModelAndView의 논리적인 뷰 이름을 실제 View 객체로 변환한다.
- ViewResolver는 뷰의 경로와 실제 리소스를 찾아 View 객체를 반환한다
뷰 렌더링과 응답
- DispatcherServlet은 View 객체에 Model 데이터를 전달하며 렌더링을 요청한다.
- View는 Model 데이터를 사용하여 클라이언트에게 보낼 HTML을 생성한다.
- 최종적으로 생성된 HTML이 HTTP 응답으로 클라이언트에게 전송된다.

주요 애노테이션

컨트롤러 관련

` @Controller ` : 클래스를 컨트롤러로 지정 (뷰 이름을 반환)
` @RestController ` : REST API용 컨트롤러 (@Controller + @ResponseBody. 객체를 JSON으로 반환)
✔️ 둘의 차이?

// @Controller: 뷰 반환이 기본
@Controller
public class ViewController {
    @GetMapping("/view")
    public String view() {
        return "view";  // 뷰 이름 반환
    }
}

// @RestController: @Controller + @ResponseBody
@RestController
public class RestApiController {
    @GetMapping("/api")
    public User api() {
        return new User();  // 객체를 JSON으로 반환
    }
}

` @RequestMapping ` : 요청 정보를 매핑한다. 메소드 레벨과 클래스 레벨 모두에서 사용 가능. PathVariable, HTTP 메소드 등 다양한 속성 지정 가능.
- ` @GetMapping ` , ` @PostMapping ` 등: HTTP 메소드 지정하여 매핑

요청 처리 관련

` @RequestParam ` : 요청 파라미터를 메소드의 매개변수로 바인딩
` @PathVariable ` : URL 경로 변수 바인딩
` @RequestBody ` : HTTP 요청 본문 바인딩
` @ResponseBody ` : HTTP 응답 본문 생성

[Spring] Bean Scope / 싱글톤, 프로토타입 등

dev-99 — Sun, 15 Dec 2024 10:00:38 +0900

빈 스코프란?

Bean은 스프링에서 사용하는 객체다. 그리고 Scope를 설정해서 Bean의 사용 범위를 개발자가 설정할 수 있다.

따로 설정을 해주지 않으면, Spring에서 Bean은 Singleton으로 생성된다. 싱글톤 패턴처럼 특정 타입의 Bean을 하나만 만들고 모두 공유해서 사용하기 위함이다. 하지만 요구사항이나 구현에 따라 Bean을 하나만 만들어 사용하지 않을 수도 있다.

따라서 Bean Scope는 싱글톤 말고도 여러가지를 지원해준다.

싱글톤: default, 스프링 컨테이너의 시작부터 종료까지 유지되는 가장 넓은 범위의 스코프
프로토타입: 스프링 컨테이너는 빈의 생성과 의존성 주입까지만 관여하고, 더 이상 관리하지 않는 짧은 범위의 스코프
웹 관련 스코프: request, session, application 등 여러 스코프가 존재한다.

싱글톤 빈 스코프

Spring 컨테이너당 하나의 인스턴스만 생성된다.
모든 요청이 같은 인스턴스를 공유한다.
장점: 메모리 사용을 줄일 수 있다.
주의점: 상태를 가지면 안되며, 반드시 Thread-safe하게 구현해야 한다.

상태를 갖는 경우?

// 문제가 될 수 있는 코드
@Component
public class UserService {
    private String lastUsername; // 상태를 가지는 필드

    public void setLastUsername(String username) {
        this.lastUsername = username;
    }

    public String getLastUsername() {
        return lastUsername;
    }
}

UserService는 싱글톤이므로 모든 사용자가 같은 인스턴스를 공유한다.
사용자A가 setLastUsername("A")를 호출하고, 곧이어 사용자B가 setLastUsername("B")를 호출하면
사용자A가 getLastUsername()을 호출했을 때 "A"가 아닌 "B"를 받게 된다.

해결:
- 상태를 제거하고 무상태(stateless)로 설계하거나, 스레드별로 독립적인 상태를 가지도록 ThreadLocal 사용한다.

// 상태를 제거하고 무상태(stateless)로 설계
@Component
public class UserService {
    public String processUsername(String username) {
        // 필드 대신 메소드 파라미터와 로컬 변수만 사용
        return username.toUpperCase();
    }
}

// 스레드별로 독립적인 상태를 가지도록 ThreadLocal 사용
@Component
public class UserService {
    private ThreadLocal<String> lastUsername = new ThreadLocal<>();

    public void setLastUsername(String username) {
        lastUsername.set(username);
    }

    public String getLastUsername() {
        return lastUsername.get();
    }
}

Thread-safe하지 않은 경우?

@Component
public class CounterService {
    private int count = 0;  // 상태를 가지는 필드

    public void increment() {
        count++;  // 스레드 안전하지 않은 연산
    }

    public int getCount() {
        return count;
    }
}

여러 스레드가 동시에 increment()를 호출할 경우
count++ 연산이 원자적이지 않아 경쟁 상태(race condition)가 발생할 수 있다.

해결: 동기화를 사용하여 Thread-safe하게 구현

@Component
public class CounterService {
    private AtomicInteger count = new AtomicInteger(0);  // 스레드 안전한 카운터

    public void increment() {
        count.incrementAndGet();  // 원자적 연산
    }

    public int getCount() {
        return count.get();
    }
}

프로토타입 빈 스코프

요청할 때마다 새로운 인스턴스가 생성된다.
Spring은 생성과 의존관계 주입까지만 관여하고, 이후 관리하지 않는다.
- 따라서 빈 반환 후에 @PreDestroy가 호출되지 않고, 필요시에 클라이언트가 직접 빈을 종료시켜야 한다.
사용 예: 상태를 가지는 빈이 필요한 경우

웹 관련 스코프

request: HTTP 요청마다 새로운 인스턴스가 생성, 종료된다.
session: HTTP Session마다 새로운 인스턴스가 생성된다.
application: ServletContext 생명주기 동안 하나의 인스턴스가 유지된다.
websocket: WebSocket 생명주기 동안 하나의 인스턴스가 유지된다.

빈 스코프 설정 방법

Bean 등록하는 부분에서 @Scope 어노테이션을 사용해서 설정할 수 있다.

XML 설정을 통해 정의할 수도 있다.

// 어노테이션 사용
@Scope("prototype")
@Component
public class PrototypeBean {
    // ...
}

// 또는 XML 설정
<bean id="prototypeBean" class="com.example.PrototypeBean" scope="prototype"/>

프로토타입 빈 의존성 주입 문제

싱글톤과 프로토타입 빈을 함께 사용할 때 문제점?

싱글톤 빈이 프로토타입 빈을 주입받아 사용할 때, 프로토타입 빈이 싱글톤처럼 동작하는 문제가 발생할 수 있다.

이는 싱글톤 빈이 생성 시점에 프로토타입 빈을 주입받기 때문이다. 싱글톤 빈에 프로토타입 빈이 주입되고, 이후 이 프로토타입빈 인스턴스는 계속 유지된다.

해결방법: OjbectProvider, Provider, proxyMode 설정 등을 사용.

ObjectProvider

@Component
public class SingletonBean {
    @Autowired
    private ObjectProvider<PrototypeBean> prototypeBeanProvider;

    public void logic() {
        PrototypeBean prototypeBean = prototypeBeanProvider.getObject();
        prototypeBean.addCount();
    }
}

ObjectFactory를 상속한 인터페이스
getObject()를 호출하면 스프링 컨테이너에서 해당 빈을 찾아서 반환한다. 이 과정을 Dependency Lookup (DL : 의존관계 조회 또는 탐색) 이라고 한다.
` stream() ` 또는 Optional 지원 등 추가 기능 제공
스프링에 의존적

Provider

@Component
public class SingletonBean {
    @Autowired
    private Provider<PrototypeBean> provider;

    public void logic() {
        PrototypeBean prototypeBean = provider.get();
        prototypeBean.addCount();
    }
}

자바 표준(JSR-330)
스프링이 아닌 다른 컨테이너에서도 사용 가능
별도의 라이브러리 추가 필요 ` javax.inject:javax.inject:1 `
` get() ` 메소드 하나로 매우 단순

proxyMode

@Component
@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class PrototypeBean {
    // ...
}

프록시를 통해 실제 빈을 감싸는 방식
코드를 수정하지 않고도 문제 해결 가능

[백준/1987] 알파벳 - Java 자바

dev-99 — Sat, 14 Dec 2024 02:04:04 +0900

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

개념: dfs, 백트래킹

문제

세로 R칸, 가로 C칸으로 된 표 모양의 보드가 있다. 보드의 각 칸에는 대문자 알파벳이 하나씩 적혀 있고, 좌측 상단 칸 (1행, 1열) 에는 말이 놓여 있다.

말은 상하좌우로 인접한 네 칸 중의 한 칸으로 이동할 수 있는데, 새로 이동한 칸에 적혀 있는 알파벳은 지금까지 지나온 모든 칸에 적혀 있는 알파벳과는 달라야 한다. 즉, 같은 알파벳이 적힌 칸을 두 번 지날 수 없다.

좌측 상단에서 시작해서, 말이 최대한 몇 칸을 지날 수 있는지를 구하는 프로그램을 작성하시오. 말이 지나는 칸은 좌측 상단의 칸도 포함된다.

풀이

처음에는 그래프를 String으로 입력 받아서 푸느라 Set을 사용했다. 통과는 하지만 효율성이 썩 좋지 못하다.. dfs나 백트래킹에 맞는 풀이도 아닌거 같고?

그래프를 int로 입력 받았더니 효율성이 개선됐다. `graph[i][j] = str.charAt(j)-'A';`

전체코드

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

public class Main {
	static int R,C;
	static int[][] graph;
	static boolean[] checked;
	static int answer;
	static int[] dx = {1,-1,0,0};
	static int[] dy = {0,0,1,-1};

	public static void main(String[] args) throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		R = Integer.parseInt(st.nextToken());
		C = Integer.parseInt(st.nextToken());
		
		graph = new int[R][C];
		checked = new boolean[26];

		for(int i = 0; i < R; i++) {
			String str = br.readLine();
			for(int j = 0; j < C; j++) {
				graph[i][j] = str.charAt(j)-'A';
			}
		}

		dfs(0,0,0);
		System.out.println(answer);
	}
	
	static void dfs(int x, int y, int cnt) {
        checked[graph[x][y]] = true;
        answer = Math.max(answer, cnt + 1);  // 현재 위치도 포함해서 카운트
        
        for(int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            
            if(nx < 0 || ny < 0 || nx >= R || ny >= C) continue;

            if(!checked[graph[nx][ny]]) {  // 방문하지 않은 알파벳인 경우에만 진행
                dfs(nx, ny, cnt + 1);
            }
        }
        
        checked[graph[x][y]] = false;
    }
}

이전코드

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

public class Main {
    static int R, C, answer;
    static String[][] graph;
    static boolean[][] visited;
    static int[] dx = {1, -1, 0, 0};
    static int[] dy = {0, 0, 1, -1};
    static HashSet<String> set = new HashSet<>();
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        
        R = Integer.parseInt(st.nextToken());
        C = Integer.parseInt(st.nextToken());
        graph = new String[R][C];
        visited = new boolean[R][C];

        for (int i = 0; i < R; i++) {
            String str = br.readLine();
            for (int j = 0; j < C; j++) {
                graph[i][j] = String.valueOf(str.charAt(j));
            }
        }

        set.add(graph[0][0]);
        dfs(0, 0, 1);
        System.out.println(answer);
    }

    public static void dfs(int x, int y, int count) {
        answer = Math.max(count, answer);

        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];

            if (0 <= nx && nx < R && 0 <= ny && ny < C && !visited[nx][ny]) {
                if (!set.contains(graph[nx][ny])) {
                    visited[nx][ny] = true;
                    set.add(graph[nx][ny]);
                    dfs(nx, ny, count + 1);
                    visited[nx][ny] = false;
                    set.remove(graph[nx][ny]);
                }
            }
        }
    }
}

[백준/7576] 토마토 - Java 자바

dev-99 — Fri, 13 Dec 2024 10:00:48 +0900

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

개념: bfs, 그래프 탐색

문제

철수의 토마토 농장에서는 토마토를 보관하는 큰 창고를 가지고 있다. 토마토는 아래의 그림과 같이 격자 모양 상자의 칸에 하나씩 넣어서 창고에 보관한다.

보관 후 하루가 지나면, 익은 토마토들의 인접한 곳에 있는 익지 않은 토마토들은 익은 토마토의 영향을 받아 익게 된다. 대각선 방향에 있는 토마토들에게는 영향을 주지 못하며, 토마토가 혼자 저절로 익는 경우는 없다고 가정한다. 며칠이 지나면 토마토들이 모두 익는지, 그 최소 일수를 구하는 프로그램을 작성하라. 단, 상자의 일부 칸에는 토마토가 들어있지 않을 수도 있다.

입출력

첫 줄에는 상자의 크기를 나타내는 두 정수 M,N이 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M,N ≤ 1,000 이다. 둘째 줄부터는 하나의 상자에 저장된 토마토들의 정보가 주어진다. 정수 1은 익은 토마토, 정수 0은 익지 않은 토마토, 정수 -1은 토마토가 들어있지 않은 칸을 나타낸다.

여러분은 토마토가 모두 익을 때까지의 최소 날짜를 출력해야 한다. 만약, 저장될 때부터 모든 토마토가 익어있는 상태이면 0을 출력해야 하고, 토마토가 모두 익지는 못하는 상황이면 -1을 출력해야 한다.

풀이

전체코드

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

public class Main {
    static int M, N, answer;
    static int[][] graph;
    static Queue<int[]> queue = new LinkedList<>();;
    static int[] dx = {1, -1, 0, 0};
    static int[] dy = {0, 0, 1, -1};

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        
        M = Integer.parseInt(st.nextToken());
        N = Integer.parseInt(st.nextToken());
        graph = new int[N][M];

        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine(), " ");
            for (int j = 0; j < M; j++) {
                graph[i][j] = Integer.parseInt(st.nextToken());
                if (graph[i][j] == 1) {
                    queue.add(new int[]{i, j});
                }
            }
        }

        bfs();
        answer = 0;
        boolean checkTomato = false;

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (graph[i][j] == 0) {
                    checkTomato = true;
                    break;
                } 
                answer = Math.max(answer, graph[i][j]);
            }
            if (checkTomato) break;
        }
        if (checkTomato) System.out.println(-1);
        else System.out.println(answer - 1);
    }

    public static void bfs() {
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int x = cur[0]; int y = cur[1];

            for (int i = 0; i < 4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];

                if (0 <= nx && nx < N && 0 <= ny && ny < M) {
                    if (graph[nx][ny] == 0) {
                        graph[nx][ny] = graph[x][y] + 1;
                        queue.add(new int[]{nx, ny});
                    }
                }
            }
        }
    }
}

Promotion and Casting (자바의 타입변환)

dev-99 — Fri, 29 Nov 2024 15:15:41 +0900

타입변환

서로 다른 데이터 타입끼리의 연산이 필요할 때, 변수의 데이터 타입을 바꿔주는 작업을 데이터 타입의 형변환(타입변환)이라고 한다.

형변환에는 자동 형변환(Promotion) 과 강제 형변환(Casting) 이 있다. 다른말로 자동 형변환은 묵시적 타입 변환, 강제 형변환은 명시적 타입 변환이라고도 한다.

1. Promotion (자동 형변환)

프로그램 실행 도중에 자동적으로 형변환(타입변환)이 일어나는 것을 말한다
작은 데이터 타입에서 큰 데이터 타입으로 자동으로 변환
데이터 손실의 위험이 없기 때문에 자동으로 수행된다
변환 순서: byte → short → int → long → float → double

byte byteValue = 10; 
int intValue = byteValue; // 자동으로 int로 변환 
long longValue = intValue; // 자동으로 long으로 변환 
float floatValue = longValue; // 자동으로 float으로 변환

2. Casting (강제 형변환)

특정 조건을 갖추지 못했지만, 형변환을 하고 싶을때 사용
큰 데이터 타입에서 작은 데이터 타입으로 강제로 변환하는 것
변환하고자 하는 타입을 괄호()로 명시한다
데이터 손실의 가능성이 있다

double doubleValue = 3.14;
int intValue = (int)doubleValue;    // 3.14 → 3 으로 소수점 손실

강제 형변환 시 주의할 점

정수형 연산
- 나눗셈 연산 결과를 강제 형변환해도 원하는 결과가 나오지 않음. 따라서 정확한 실수 계산이 필요한 경우에는 계산 전에 피연산자 중 하나를 실수형으로 먼저 변환해야 한다.
- 오버플로우와 언더플로우: 예를 들어 byte 타입의 범위는 -128에서 127까지인데, 128을 저장하려고 하면 오버플로우가 발생하여 -128이 저장된다.
```
int a = 10;
int b = 4;
double result = a / b;         // 2.0 (int 연산 후 double로 변환)
double correct = (double)a / b; // 2.5 (double로 변환 후 연산)
```
객체 형변환
- 다운캐스팅 시 부모 타입의 참조변수가 실제로 참조하는 객체가 어떤 타입인지 확인해야 함.
- ` instanceof ` 검사 없이 다운캐스팅을 시도하면, 실제 객체 타입이 변환하려는 타입과 호환되지 않는 ` ClassCastException `이 발생할 수 있다.
```
// 업캐스팅 (자동 형변환)
Parent parent = new Child();

// 다운캐스팅 (명시적 형변환)
Child child = (Child)parent;

// instanceof 연산자로 안전한 형변환
if (parent instanceof Child) {
    Child safeChild = (Child)parent;
}
```

[프로그래머스] 전력망을 둘로 나누기 - Java 자바

dev-99 — Wed, 27 Nov 2024 09:30:35 +0900

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

프로그래머스

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

programmers.co.kr

개념: dfs, 완전탐색

문제

n개의 송전탑이 전선을 통해 하나의 트리 형태로 연결되어 있습니다. 당신은 이 전선들 중 하나를 끊어서 현재의 전력망 네트워크를 2개로 분할하려고 합니다. 이때, 두 전력망이 갖게 되는 송전탑의 개수를 최대한 비슷하게 맞추고자 합니다.

송전탑의 개수 n, 그리고 전선 정보 wires가 매개변수로 주어집니다. 전선들 중 하나를 끊어서 송전탑 개수가 가능한 비슷하도록 두 전력망으로 나누었을 때, 두 전력망이 가지고 있는 송전탑 개수의 차이(절대값)를 return 하도록 solution 함수를 완성해주세요.

입력

n	wires	result
9	[[1,3],[2,3],[3,4],[4,5],[4,6],[4,7],[7,8],[7,9]]	3
4	[[1,2],[2,3],[3,4]]	0
7	[[1,2],[2,7],[3,7],[3,4],[4,5],[6,7]]	1

풀이

전체코드

import java.util.*;

class Solution {
    static int answer, N;
    static ArrayList<Integer>[] graph; // ArrayList<Integer>를 자료형으로 하는 배열
    static boolean[] visited;

    public static int dfs(int v) {
        visited[v] = true;
        int cnt = 1;

        for (int next : graph[v]) {
            if (!visited[next]) {
                cnt += dfs(next);
            }
        }
        return cnt;
    }

    public int solution(int n, int[][] wires) {
        N = n;
        answer = Integer.MAX_VALUE;
        graph = new ArrayList[N + 1];

        for (int i = 0; i <= N; i++) {
            graph[i] = new ArrayList<>();
        }

        for (int[] wire : wires) {
            graph[wire[0]].add(wire[1]);
            graph[wire[1]].add(wire[0]);
        }

        for (int[] wire : wires) {
            graph[wire[0]].remove(Integer.valueOf(wire[1]));
            graph[wire[1]].remove(Integer.valueOf(wire[0]));

            visited = new boolean[N + 1];

            int cnt = dfs(1);
            int diff = Math.abs(cnt - (N - cnt));
            answer = Math.min(answer, diff);

            graph[wire[0]].add(wire[1]);
            graph[wire[1]].add(wire[0]);
        }
        return answer;
    }
}

Garbage Collection 개념 및 동작 원리

dev-99 — Wed, 27 Nov 2024 08:30:09 +0900

C/C++에서는 개발자가 직접 사용하지 않는 객체의 메모리를 해제해주어야 한다. 하지만 JAVA에서는 JVM이 구성된 JRE가 제공되며, 그 구성 요소 중 하나인 Garbage Collection이 자동으로 사용하지 않는 객체를 파괴한다.

GC를 해도 더이상 사용 가능한 메모리 영역이 없는데 계속 메모리를 할당하려고 하면, OutOfMemoryError가 발생하여 WAS가 다운될 수도 있다. 따라서 규모 있는 JAVA 애플리케이션을 효율적으로 개발하기 위해서는 GC에 대해 잘 알아야 한다.

Garbage Collection

JVM의 메모리는 총 5가지 영역(class, stack, heap, native method, PC)으로 나뉘는데, GC는 힙 영역만 다룬다.

GC는 객체의 접근 가능성(Reachability)를 기준으로 동작한다. 객체가 GC Root에서 참조될 수 없으면 “사용되지 않는 객체”로 간주한다.

일반적으로 아래와 같은 경우에 GC의 대상이 된다.

객체가 NULL인 경우
블럭 실행 종료 후, 블럭 안에서 생성된 객체
부모 객체가 NULL인 경우, 포함하는 자식 객체

GC는 `Weak Generational Hypothesis`에 기반한다.

1. Weak Generational Hypothesis

JVM의 Heap 영역은 처음 설계될 때 다음과 같은 2가지 전제로 설계되었다.

대부분의 객체는 금방 접근 불가능한 상태(Unreachable)가 된다.
오래된 객체에서 새로운 객체로의 참조는 매우 적게 존재한다.

이 가설에 기반하여 JAVA는 객체의 생존 기간에 따라 물리적인 Heap 영역을 나누게 되었다. Young 영역과 Old 영역으로 메모리를 분할하고, 신규로 생성되는 객체는 Young 영역에, 오랫동안 살아남은 객체는 Old 영역에 보관한다.

2. Generational Garbage Collection

Young 영역 (Young Generation)
- 새롭게 생성된 객체가 할당되는 영역
- 대부분의 객체가 금방 Unreachable 상태가 되므로, 많은 객체가 Young 영역에 생성되었다가 사라진다.
- Young 영역에 대한 GC를 Minor GC라고 부른다.
Old 영역 (Old Generation)
- Young 영역에서 Reachable 상태를 유지하여 살아남은 객체가 복사되는 영역
- Young 영역보다 크게 할당되고, 영역의 크기가 큰 만큼 가비지는 적게 발생한다.
- Old 영역에 대한 GC를 Major GC라고 부른다.
Permanent 영역: Java8부터 Metaspace로 교체되며 제거되었다.
- JVM이 클래스들과 메소드들을 설명하기 위해 필요한 메타데이터를 저장

예외적으로 Old 영역에 있는 객체가 Young 영역의 객체를 참조하는 경우도 존재한다. 이러한 경우를 대비해 Old 영역에는 카드 테이블(Card Table)이 존재한다.

카드 테이블에는 Old 영역에 있는 객체가 Young 영역의 객체를 참조할 때마다 그에 대한 정보가 표시된다. 따라서 Young 영역에서 Minor GC가 실행될 때 모든 Old 영역 객체를 검사하지 않고, 카드 테이블만 조회하여 GC의 대상인지 식별할 수 있다.

Generational Garbage Collection 과정을 보기 전에, GC의 메모리 해제 과정을 먼저 살펴본다.

3. GC의 메모리 해제 과정

Marking
- 참조 가능한 객체를 탐색하고 식별하는 과정이다. 모든 객체를 스캔해야 하므로 많은 시간을 소모한다.
- 참조되는 객체는 파란색, 참조되지 않는 객체는 주황색이다.
Normal Deletion
- 참조되지 않는 객체를 제거하고 메모리를 반환한다. 메모리 Allocator는 새로운 객체 생성을 대비해 반환되어 빈 블록의 참조 위치를 저장해둔다.
Compacting
- 성능 향상을 위해 참조되지 않는 객체를 제거한 후 남은 객체들을 묶는다.

4. Generational Garbage Collection 과정

객체 할당 - 새로운 객체가 들어오면 Eden Space에 할당한다.
Eden space가 가득차면, Minor GC이 트리거된다.
Copying Referenced Objects
- 마킹 이후 참조 객체들은 첫 번째 survivor space(S0)로 이동되고, 비 참조 객체는 Eden space가 clear 될 때 반환된다.
Object Aging
- 다음 Minor GC 때, Eden space에서는 같은 일이 일어난다. Eden space의 비 참조 객체는 삭제되고 참조 객체는 survivor space로 이동한다. 지난 Minor GC 때 S0으로 이동한 객체들의 경우, 나이를 increment하고 S1으로 이동한다.같은 survivor space에 나이가 다른 객체들이 존재하게 된다.
- 모든 참조 객체가 S1으로 이동한 후, S0와 Eden space는 clear 된다.
Additional Aging
- 그 다음 Minor GC 때, 같은 과정이 반복된다. 하지만 이번에는 survivor space가 switch 된다. S1에 있던 참조 객체는 나이를 먹으며 S0으로 이동한다. Eden space의 참조 객체도 S0으로 이동한다.
- 모든 참조 객체가 S0으로 이동한 후, Eden space와 S1은 clear 된다.
Promotion
- Minor GC 이후 특정 나이 threshold (그림 예시에서는 8)에 도달하면 Young 영역에서 Old 영역으로 promotion된다.
Minor GC가 계속됨에 따라 객체들이 Old 영역으로 이동한다.
지속된 Promotion으로 Old 영역이 꽉 차게 되면, Major GC가 수행되어 Old 영역을 clear한다.

Young 영역은 일반적으로 Old 영역보다 크키가 작기 때문에 GC가 보통 0.5초에서 1초 사이에 끝난다. 그렇기 때문에 Minor GC는 애플리케이션에 크게 영향을 주지 않는다. 하지만 Old 영역은 Young 영역보다 크며 Young 영역을 참조할 수도 있다. 그렇기 때문에 Major GC는 일반적으로 Minor GC보다 시간이 오래걸리며, 10배 이상의 시간을 사용한다. 참고로 Young 영역과 Old 영역을 동시하 처리하는 GC는 Full GC라고 한다.

5. GC의 주요 알고리즘 정리

Mark and Sweep
- Mark: 참조 가능한 객체를 탐색하고 식별한다.
- Sweep: 참조되지 않은 객체를 메모리에서 제거한다.
Generational Garbage Collection
Stop-the-World
- GC를 실행하기 위해 JVM이 애플리케이션 실행을 잠시 멈춘 상태를 말한다. GC가 메모리 관리를 수행하는 동안 GC를 실행하는 스레드를 제외한 모든 스레드들이 중단된다. GC가 안전하게 작업을 완료할 수 있도록 보장힌다. 어떤 GC 알고리즘을 사용하더라도 발생하게 된다. GC 튜닝은 보통 이 Stop-the-World 시간을 줄이는 성능 개선을 뜻한다.

참조

https://d2.naver.com/helloworld/1329

https://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html

[프로그래머스] 경주로 건설 - Java 자바

dev-99 — Sun, 24 Nov 2024 09:03:45 +0900

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

프로그래머스

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

programmers.co.kr

개념: bfs, 그래프 탐색

문제

제공된 경주로 설계 도면에 따르면 경주로 부지는 `N x N` 크기의 정사각형 격자 형태이며 각 격자는 `1 x 1` 크기입니다.
설계 도면에는 각 격자의 칸은 `0` 또는 `1` 로 채워져 있으며, `0`은 칸이 비어 있음을 `1`은 해당 칸이 벽으로 채워져 있음을 나타냅니다.
경주로의 출발점은 (0, 0) 칸(좌측 상단)이며, 도착점은 (N-1, N-1) 칸(우측 하단)입니다. 죠르디는 출발점인 (0, 0) 칸에서 출발한 자동차가 도착점인 (N-1, N-1) 칸까지 무사히 도달할 수 있게 중간에 끊기지 않도록 경주로를 건설해야 합니다.
경주로는 상, 하, 좌, 우로 인접한 두 빈 칸을 연결하여 건설할 수 있으며, 벽이 있는 칸에는 경주로를 건설할 수 없습니다.
이때, 인접한 두 빈 칸을 상하 또는 좌우로 연결한 경주로를 `직선 도로` 라고 합니다.
또한 두 `직선 도로`가 서로 직각으로 만나는 지점을 `코너` 라고 부릅니다.
건설 비용을 계산해 보니 `직선 도로` 하나를 만들 때는 100원이 소요되며, `코너`를 하나 만들 때는 500원이 추가로 듭니다.
죠르디는 견적서 작성을 위해 경주로를 건설하는 데 필요한 최소 비용을 계산해야 합니다.

예시

예를 들어, 그림은 직선 도로 6개와 코너 4개로 구성된 임의의 경주로 예시이며, 건설 비용은 6 x 100 + 4 x 500 = 2600원 입니다.

풀이

전체코드

import java.util.*;

class Solution {
    static int n, answer;
    static int[] dx = {1, -1, 0, 0};
    static int[] dy = {0, 0, 1, -1};
    static int[][][] visited;  // [x][y][방향]

    static class Car implements Comparable<Car> {
        int x;
        int y;
        int cost;
        int dir;

        public Car(int x, int y, int cost, int dir) {
            this.x = x;
            this.y = y;
            this.cost = cost;
            this.dir = dir;
        }

        @Override
        public int compareTo(Car other) {
            return this.cost - other.cost;
        }
    }
    
    public static void bfs(int[][] board) {
        PriorityQueue<Car> pq = new PriorityQueue<>();
        pq.add(new Car(0, 0, 0, -1)); // 초기 방향 -1
        
        // 모든 위치의 모든 방향에 대해 최대값으로 초기화
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                for(int k = 0; k < 4; k++) {
                    visited[i][j][k] = Integer.MAX_VALUE;
                }
            }
        }

        while (!pq.isEmpty()) {
            Car current = pq.poll();

            if (current.x == n - 1 && current.y == n - 1) {
                answer = Math.min(answer, current.cost);
                continue;
            }

            for (int i = 0; i < 4; i++) {
                int nx = current.x + dx[i];
                int ny = current.y + dy[i];

                if (nx < 0 || ny < 0 || nx >= n || ny >= n || board[nx][ny] == 1) {
                    continue;
                }

                // 비용 계산
                int newCost = current.cost;
                if (current.dir == -1) {  // 시작점
                    newCost += 100;
                } else if (current.dir == i) {  // 직진
                    newCost += 100;
                } else {  // 코너
                    newCost += 600;
                }

                // 같은 위치, 같은 방향으로 도착했을 때 비용이 더 작은 경우에만 갱신
                if (visited[nx][ny][i] > newCost) {
                    visited[nx][ny][i] = newCost;
                    pq.add(new Car(nx, ny, newCost, i));
                }
            }
        }
    }
    
    public int solution(int[][] board) {
        answer = Integer.MAX_VALUE;
        n = board.length;
        visited = new int[n][n][4];  // 3차원 배열
        bfs(board);
        return answer;
    }
}

`visited` 배열에서도 방향을 고려해야 하는 이유:

같은 위치라도 도착하는 방향에 따라 이후의 최소 비용이 달라질 수 있기 때문
Car 객체의 `dir` 외 별개로, 각 위치에 각 방향으로 도착했을 때의 최소 비용을 따로 관리한다.

[프로그래머스] 미로 탈출 - Java 자바

dev-99 — Fri, 22 Nov 2024 05:04:07 +0900

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

프로그래머스

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

programmers.co.kr

개념: bfs, 그래프 탐색

문제

1 x 1 크기의 칸들로 이루어진 직사각형 격자 형태의 미로에서 탈출하려고 합니다. 각 칸은 통로 또는 벽으로 구성되어 있으며, 벽으로 된 칸은 지나갈 수 없고 통로로 된 칸으로만 이동할 수 있습니다. 통로들 중 한 칸에는 미로를 빠져나가는 문이 있는데, 이 문은 레버를 당겨서만 열 수 있습니다. 레버 또한 통로들 중 한 칸에 있습니다. 따라서, 출발 지점에서 먼저 레버가 있는 칸으로 이동하여 레버를 당긴 후 미로를 빠져나가는 문이 있는 칸으로 이동하면 됩니다. 이때 아직 레버를 당기지 않았더라도 출구가 있는 칸을 지나갈 수 있습니다. 미로에서 한 칸을 이동하는데 1초가 걸린다고 할 때, 최대한 빠르게 미로를 빠져나가는데 걸리는 시간을 구하려 합니다.

미로를 나타낸 문자열 배열 maps가 매개변수로 주어질 때, 미로를 탈출하는데 필요한 최소 시간을 return 하는 solution 함수를 완성해주세요. 만약, 탈출할 수 없다면 -1을 return 해주세요.

미로 예시

풀이

시작점에서 레버까지 이동한 후, 레버에서 출구까지 이동해야 한다.

따라서 각각 최소 시간을 구하여 더해준다.

import java.util.ArrayDeque;

class Solution {
    static int n, m;
    static int[] start, end, lever;
    static char[][] map;
    static int[][] dist;
    static int[] dx = {1, -1, 0, 0};
    static int[] dy = {0, 0, 1, -1};
    
    public int solution(String[] maps) {
        n = maps.length;
        m = maps[0].length();       
        map = new char[n][m];
        for (int i = 0; i < n; i++) {
            map[i] = maps[i].toCharArray();
        }

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (map[i][j] == 'S') {
                    start = new int[] {i, j};
                } else if (map[i][j] == 'E') {
                    end = new int[] {i, j};
                } else if (map[i][j] == 'L') {
                    lever = new int[] {i, j};
                }
            }
        }

        int startToLever = bfs(start, lever);
        int leverToEnd = bfs(lever, end);

        if (startToLever == -1 || leverToEnd == -1) {
            return -1;
        } else {
            return startToLever + leverToEnd;
        }
    }

    public static int bfs(int[] start, int[] end) {
        dist = new int[n][m];
        ArrayDeque<int[]> q = new ArrayDeque<>();
        dist[start[0]][start[1]] = 1;
        q.add(start);

        while (!q.isEmpty()) {
            int[] cur = q.poll();
            int x = cur[0]; int y = cur[1];

            for (int i = 0; i < 4; i++) {
                int nx = x + dx[i];
                int ny = y + dy[i];

                // 범위 벗어난 경우
                if (nx < 0 || ny < 0 || nx >= n || ny >= m) {
                    continue;
                }

                // 이미 방문한 경우
                if (dist[nx][ny] > 0) {
                    continue;
                }

                // 벽인 경우
                if (map[nx][ny] == 'X') {
                    continue;
                }

                dist[nx][ny] = dist[x][y] + 1;
                q.add(new int[]{nx, ny});

                // end 지점에 도달
                if (nx == end[0] && ny == end[1]) {
                    return dist[nx][ny] - 1;
                }
            }
        }

        return -1;
    }
}

[백준/12851] 숨바꼭질 2 - Java 자바

dev-99 — Thu, 21 Nov 2024 06:12:14 +0900

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

개념: 그래프 탐색, bfs

문제

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일 때 걷는다면 1초 후에 X-1 또는 X+1로 이동하게 된다. 순간이동을 하는 경우에는 1초 후에 2*X의 위치로 이동하게 된다.

수빈이와 동생의 위치가 주어졌을 때, 수빈이가 동생을 찾을 수 있는 가장 빠른 시간이 몇 초 후인지 그리고, 가장 빠른 시간으로 찾는 방법이 몇 가지 인지 구하는 프로그램을 작성하시오.

풀이

이전 문제 숨바꼭질3 과 유사하다. 최소 시간과 더불어 최소 시간으로 방문하는 경로의 수를 함께 구해야 한다는 점이 차이점이다.

전체 코드

import java.util.*;

public class Main {
    static int N, K, count;
    static int max = 100000;
    static int[] time;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt();
        K = sc.nextInt();
        time = new int[max + 1];
        Arrays.fill(time, Integer.MAX_VALUE);

        bfs();
        System.out.println(time[K]);
        System.out.println(count);
    }

    public static void bfs() {
        Deque<Integer> q = new ArrayDeque<>();
        q.offer(N);
        time[N] = 0; // 시작점의 시간은 0

        while (!q.isEmpty()) {
            int current = q.poll();

            if (current == K) {
                count++;
                continue; // 다른 경로도 확인
            }

            int[] nextPositions = {current * 2, current + 1, current - 1};
            for (int next : nextPositions) {
                // next가 범위 밖이거나, 이미 방문한 위치인데 기존보다 더 오래 걸리는 경로라면 큐에 추가X
                if (next < 0 || next > max || (time[next] < time[current] + 1)) continue;
                time[next] = time[current] + 1;
                q.add(next);
            }
        }
    }
}

[swea/4008] 숫자 만들기 - Java 자바

dev-99 — Tue, 19 Nov 2024 23:19:59 +0900

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWIeRZV6kBUDFAVH

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

개념: 완전탐색, dfs

문제 설명

선표는 게임을 통해 사칙 연산을 공부하고 있다.

N개의 숫자가 적혀 있는 게임 판이 있고, +, -, x, / 의 연산자 카드를 숫자 사이에 끼워 넣어 다양한 결과 값을 구해보기로 했다.

수식을 계산할 때 연산자의 우선 순위는 고려하지 않고 왼쪽에서 오른쪽으로 차례대로 계산한다.

예를 들어 1, 2, 3 이 적힌 게임 판에 +와 x를 넣어 1 + 2 * 3을 만들면 1 + 2를 먼저 계산하고 그 뒤에 * 를 계산한다.

즉 1+2*3의 결과는 9이다.

주어진 연산자 카드를 사용하여 수식을 계산했을 때 그 결과가 최대가 되는 수식과 최소가 되는 수식을 찾고, 두 값의 차이를 출력하시오.

풀이

연산자 개수를 int[] operator에 입력 받고, 숫자는 int[] number에 입력 받는다.

완전탐색을 통해 구한다. dfs로 구현한다.

전체 코드

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

public class Main {
    static int[] number, operator;
    static int N, minVal, maxVal;

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

        int T = Integer.parseInt(st.nextToken());
        for (int t = 1; t <= T; t++) {
            st = new StringTokenizer(br.readLine());
            N = Integer.parseInt(st.nextToken());
            number = new int[N];
            operator = new int[4];

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

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

            minVal = Integer.MAX_VALUE;
            maxVal = Integer.MIN_VALUE;

            dfs(1, number[0]); // 이미 첫번째 숫자는 처리했으니까 depth = 1

            System.out.println("#" + t + " " + (maxVal - minVal));
        }
    }

    public static void dfs(int depth, int sum) {
        if (depth == N) {
            minVal = Math.min(minVal, sum);
            maxVal = Math.max(maxVal, sum);
            return;
        }

        for (int i = 0; i < 4; i++) {
            if (operator[i] == 0) {
                continue;
            }
            operator[i]--;
            if (i == 0) {
                dfs(depth + 1, sum + number[depth]);
            } else if (i == 1) {
                dfs(depth + 1, sum - number[depth]);
            } else if (i == 2) {
                dfs(depth + 1, sum * number[depth]);
            } else {
                dfs(depth + 1, sum / number[depth]);
            }
            operator[i]++;
        }
    }
}

[백준/13549] 숨바꼭질 3 - Java 자바

dev-99 — Tue, 19 Nov 2024 06:21:21 +0900

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

개념: 그래프 탐색, bfs, 다익스트라, ...

문제

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일 때 걷는다면 1초 후에 X-1 또는 X+1로 이동하게 된다. 순간이동을 하는 경우에는 0초 후에 2*X의 위치로 이동하게 된다.

수빈이와 동생의 위치가 주어졌을 때, 수빈이가 동생을 찾을 수 있는 가장 빠른 시간이 몇 초 후인지 구하는 프로그램을 작성하시오.

입력

첫 번째 줄에 수빈이가 있는 위치 N과 동생이 있는 위치 K가 주어진다. N과 K는 정수이다.

출력

수빈이가 동생을 찾는 가장 빠른 시간을 출력한다.

풀이

전체코드

import java.util.*;

public class Main {
    static int N, K;
    static int max = 100000;
    static int[] time;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt();
        K = sc.nextInt();
        time = new int[max + 1];
        Arrays.fill(time, Integer.MAX_VALUE);

        bfs();
        System.out.println(time[K]);
    }

    public static void bfs() {
        Deque<Integer> q = new ArrayDeque<>();
        q.offer(N);
        time[N] = 0; // 시작점의 시간은 0

        while (!q.isEmpty()) {
            int current = q.poll();

            // 3가지 이동 방식 확인
            int[] nextPositions = {current * 2, current + 1, current - 1};
            for (int i = 0; i < 3; i++) {
                int next = nextPositions[i];

                if (next >= 0 && next <= max) {
                    if (i == 0) { // 순간이동 (0초)
                        if (time[next] > time[current]) {
                            time[next] = time[current];
                            q.offerFirst(next); // 순간이동은 우선 처리
                        }
                    } else { // 걷기 (+1초)
                        if (time[next] > time[current] + 1) {
                            time[next] = time[current] + 1;
                            q.offer(next); // 걷기는 뒤에 처리
                        }
                    }
                }
            }
        }
    }
}

bfs를 사용해서 풀었다.

1. `boolean[] visited` 대신 `int[] time` 배열로 방문 여부와 최단 시간을 함께 관리한다.

BFS 특성상 같은 노드를 여러 경로로 방문할 수 있다. 그러므로 `visited`는 단순히 방문했는지만 체크하고, 노드를 더 빠르게 방문할 가능성을 차단한다.
`time[next] > time[current] + 비용` 조건을 통해 더 나은 경로가 있으면 갱신하고 재방문합니다.

2. `Deque` 를 사용한 이유?

양쪽에서 삽입과 삭제가 가능한 자료구조가 필요하다. 2*X 위치로 이동하는 작업이 우선순위가 높기 때문이다.
`Deque`의 `offerFirst()` 메서드는 요소를 큐의 앞쪽에 삽입한다.

3. 귀찮다면 그냥 Node를 구현해서 time을 관리해도 된다. 메모리가 조금 더 소모된다.

[swea/20019] 회문의 회문 - Java 자바

dev-99 — Sun, 17 Nov 2024 20:57:29 +0900

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AY2hjCWKbykDFATh

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

전체코드

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());
        
        for (int tc = 1; tc <= T; tc++) {
            String str = br.readLine();
            System.out.println("#" + tc + " " + (isPalindromeOfPalindrome(str) ? "YES" : "NO"));
        }
    }
    
    public static boolean isPalindromeOfPalindrome(String str) {
        int N = str.length();
                
        // 전체 문자열이 회문인지 확인
        if (!isPalindrome(str, 0, N - 1)) {
            return false;
        }
        
        // 앞쪽 (N-1)/2 글자가 회문인지 확인
        if (!isPalindrome(str, 0, (N-1)/2 - 1)) {
            return false;
        }
        
        // 뒤쪽 (N-1)/2 글자가 회문인지 확인
        if (!isPalindrome(str, N - (N-1)/2, N - 1)) {
            return false;
        }
        
        return true;
    }
    
    public static boolean isPalindrome(String str, int start, int end) {
        while (start < end) {
            if (str.charAt(start) != str.charAt(end)) {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }
}

[swea/4012] 요리사 - Java 자바

dev-99 — Sat, 16 Nov 2024 23:25:43 +0900

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWIeUtVakTMDFAVH

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

문제 설명

두 명의 손님에게 음식을 제공하려고 한다.

두 명의 손님은 식성이 비슷하기 때문에, 최대한 비슷한 맛의 음식을 만들어 내야 한다.

N개의 식재료가 있다.

식재료들을 각각 N / 2개씩 나누어 두 개의 요리를 하려고 한다. (N은 짝수이다.)

이때, 각각의 음식을 A음식, B음식이라고 하자.

비슷한 맛의 음식을 만들기 위해서는 A음식과 B음식의 맛의 차이가 최소가 되도록 재료를 배분해야 한다.

음식의 맛은 음식을 구성하는 식재료들의 조합에 따라 다르게 된다.

식재료 i는 식재료 j와 같이 요리하게 되면 궁합이 잘 맞아 시너지 Sij가 발생한다. (1 ≤ i ≤ N, 1 ≤ j ≤ N, i ≠ j)

각 음식의 맛은 음식을 구성하는 식재료들로부터 발생하는 시너지 Sij들의 합이다.

식재료 i를 식재료 j와 같이 요리하게 되면 발생하는 시너지 Sij의 정보가 주어지고, 가지고 있는 식재료를 이용해 A음식과 B음식을 만들 때, 두 음식 간의 맛의 차이가 최소가 되는 경우를 찾고 그 최솟값을 정답으로 출력하는 프로그램을 작성하라.

N = 4인 예를 생각해보자. 시너지 Sij는 [Table 1]과 같이 주어진다.

식재료 1과 식재료 2를 A음식으로 만들고 식재료 3과 식재료 4를 B음식으로 만드는 경우를 생각하자.

1) 식재료 1을 식재료 2와 같이 요리했을 때 발생하는 시너지 S12는 5이다.

2) 식재료 2를 식재료 1과 같이 요리했을 때 발생하는 시너지 S21는 4이다.

3) A음식의 맛은 5 + 4 = 9가 된다.

4) 식재료 3을 식재료 4와 같이 요리했을 때 발생하는 시너지 S34는 3이다.

5) 식재료 4를 식재료 3과 같이 요리했을 때 발생하는 시너지 S43은 3이다.

6) B음식의 맛은 3 + 3 = 6이 된다.

따라서, 두 음식 간의 맛의 차이는 |9 – 6| = 3이 된다.

식재료 2와 식재료 4를 A음식으로 만들고 식재료 1과 식재료 3을 B음식으로 만드는 경우를 생각하자.

두 음식간의 맛의 차이는 |3 – 5| = 2가 된다.

이 경우가 A음식과 B음식 간의 맛의 차이가 최소인 경우이다.

다른 경우에서는 맛의 차이가 2보다 작을 수 없다.

따라서, 본 예의 정답은 2가 된다.

입력

입력의 맨 첫 줄에는 총 테스트 케이스의 개수 T가 주어지고,

그 다음 줄부터 T개의 테스트 케이스가 주어진다.

각 테스트 케이스의 첫 번째 줄에는 식재료의 수 N이 주어진다.

다음 N개의 줄에는 N * N개의 시너지 Sij값들이 주어진다. i와 j가 서로 같은 경우는 0으로 주어진다.

출력

테스트 케이스 개수만큼 T개의 줄에 각각의 테스트 케이스에 대한 답을 출력한다.

각 줄은 "#t"로 시작하고 공백을 하나 둔 다음 정답을 출력한다. (t 는 1부터 시작하는 테스트 케이스의 번호이다.)

정답은 두 음식 간의 맛의 차이가 최소가 되도록 A음식과 B음식을 만들었을 때 그 차이 값이다.

풀이

예시가 N = 4일때로 주어져서 처음에 조금 헤맸는데, N = 6인 경우를 생각해보자.

A음식은 1, 2, 4를 선택, B음식은 3, 5, 6을 선택하면 `syn[1][2] + syn[1][4] + syn[2][4] + syn[2][1] + syn[4][1] + syn[4][2]`와 ` syn[3][5] + syn[3][6] + syn[5][6] + syn[5][3] + syn[6][3] + syn[6][5]`의 차이의 절대값을 구한다. 이렇게 모든 조합에 대한 시너지를 계산해서 최소값을 구한다.

숫자를 돌면서 A음식 조합을 고른다 visited는 A음식, not visited는 B음식으로 가정한다.

A음식을 고르면 나머지는 자동으로 B음식이므로 n/2개의 재료로 음식을 만든다.

전체코드

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

public class Main {
    static int[][] syn;
    static boolean[] visited;
    static int N;
    static int answer;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine());
        for (int t = 1; t <= T; t++) {
            N = Integer.parseInt(br.readLine());
            syn = new int[N][N];
            visited = new boolean[N];
            answer = Integer.MAX_VALUE;

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

            dfs(0, 0);
            System.out.println("#" + t + " " + answer);
        }
    }

    public static void combination(int idx, int cnt) {
        if (cnt == N/2) {
            answer = Math.min(answer, diff());
            return;
        }

        for (int i = idx; i < N; i++) {
            visited[i] = true;
            combination(i + 1, cnt + 1);
            visited[i] = false;
        }
    }

    public static int diff() {
        int first = 0;
        int second = 0;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (i == j) continue;
                if (visited[i] && visited[j]) {
                    first += syn[i][j];
                }
                else if (!visited[i] && !visited[j]) {
                    second += syn[i][j];
                }
            }
        }
        return Math.abs(first - second);
    }
}

[프로그래머스] 조이스틱 - Java 자바

dev-99 — Fri, 15 Nov 2024 21:05:15 +0900

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

프로그래머스

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

programmers.co.kr

개념: 그리디

1. 조이스틱 상하 (알파벳 변경)

A에서 char로 변경하는게 빠른지, Z에서 char로 변경하는게 빠른지 구한다. char는 현재 포인터로 가르키고 있는 알파벳.
- `Math.min(name.charAt(i) - 'A', 'Z' - name.charAt(i) + 1)`

2. 조이스틱 좌우 (알파벳 간 이동)

처음 시작에서 i번째 알파벳까지 이동하다가, i+1번째부터 A가 나오면, 뒤로 이동하는 경우
- `Math.min(move, i * 2 + length - next)`
처음 시작부터 뒤로 이동하다가, A가 나오면 다시 앞으로 이동하는 경우
- `Math.min(move, (length - next) * 2 + i)`

전체코드

class Solution {
    public int solution(String name) {
        int answer = 0;
        int length = name.length();
        int move = length - 1;
        for (int i = 0; i < length; i++) {
            char c = name.charAt(i);
            answer += Math.min(c - 'A', 'Z' - c + 1);
            int next = i + 1;
            while (next < length && name.charAt(next) == 'A') {
                next++;
            }
            move = Math.min(move, i * 2 + length - next); // 처음에서 i번째까지 이동하고, 뒤로 이동하는 경우
            move = Math.min(move, (length - next) * 2 + i); // 처음부터 뒤로 이동하고, 다시 앞으로 오는 경우
        }
        return answer + move;
    }
}

[프로그래머스] 체육복 - Java 자바

dev-99 — Thu, 14 Nov 2024 23:51:05 +0900

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

프로그래머스

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

programmers.co.kr

개념: 그리디

작은 번호의 학생이 먼저 체육복을 빌리지 못할 수 있기 때문에 lost, reserve 정렬이 필요하다.

e.g. `lost = [4, 2]; reserve = [3, 5];`

전체코드

import java.util.*;

class Solution {
    public int solution(int n, int[] lost, int[] reserve) {
        int answer = 0;
        answer = n - lost.length;

        Arrays.sort(lost);
        Arrays.sort(reserve);
        
        // 여벌 체육복을 가진 학생이 도난 당했을 경우
        for (int i = 0; i < lost.length; i++) {
            for (int j = 0; j < reserve.length; j++) {
                if (lost[i] == reserve[j]) {
                    answer++;
                    lost[i] = -1;
                    reserve[j] = -1;
                    break;
                }
            }
        }
        
        // 다른 학생에게 여벌 체육복을 빌려주는 경우
        for (int i = 0; i < lost.length; i++) {
            for (int j = 0; j < reserve.length; j++) {
                if (lost[i] == reserve[j] - 1 || lost[i] == reserve[j] + 1) {
                    answer++;
                    reserve[j] = -1;
                    break;
                }
            }
        }
        return answer;
    }
}

[백준/2579] 계단 오르기 - Java 자바

dev-99 — Wed, 13 Nov 2024 01:19:14 +0900

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

개념: dp

문제

각각의 계단에는 일정한 점수가 쓰여 있는데 계단을 밟으면 그 계단에 쓰여 있는 점수를 얻게 된다.

<그림 2>에서 첫 번째, 두 번째, 네 번째, 여섯 번째 계단을 밟아 도착점에 도달하면 총 점수는 10 + 20 + 25 + 20 = 75점이 된다.

계단 오르는 데는 다음과 같은 규칙이 있다.

계단은 한 번에 한 계단씩 또는 두 계단씩 오를 수 있다. 즉, 한 계단을 밟으면서 이어서 다음 계단이나, 다음 다음 계단으로 오를 수 있다.
연속된 세 개의 계단을 모두 밟아서는 안 된다. 단, 시작점은 계단에 포함되지 않는다.
마지막 도착 계단은 반드시 밟아야 한다.

각 계단에 쓰여 있는 점수가 주어질 때 이 게임에서 얻을 수 있는 총 점수의 최댓값을 구하는 프로그램을 작성하시오.

입력

입력의 첫째 줄에 계단의 개수가 주어진다.

둘째 줄부터 한 줄에 하나씩 제일 아래에 놓인 계단부터 순서대로 각 계단에 쓰여 있는 점수가 주어진다. 계단의 개수는 300이하의 자연수이고, 계단에 쓰여 있는 점수는 10,000이하의 자연수이다.

풀이

k번째 계단까지 점수의 최대값을 구하려면 k-1번째 계단 & k-3번째 계단을 밟았을때, 그리고 k-2번째 계단을 밟았을때를 비교해 최대값을 구해야 한다.

따라서 점화식 `dp[k] = Math.max(dp[k-3] + stairs[k-1], dp[k-2]) + stairs[k]`을 구할 수 있다.

전체코드

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));
        int N = Integer.parseInt(br.readLine());
        int[] stairs = new int[N+5];
        int[] dp = new int[N+5];
        for (int i = 1; i <= N; i++) {
            int score = Integer.parseInt(br.readLine());
            stairs[i] = score;
        }
        dp[1] = stairs[1];
        dp[2] = stairs[1] + stairs[2];
        for (int i = 3; i <= N; i++) {
            dp[i] = Math.max(dp[i-3] + stairs[i-1], dp[i-2]) + stairs[i];
            // System.out.println(dp[i] + ": max(" + dp[i-3] + "+ " + stairs[i-1] + ", " + dp[i-2] + ") + " + stairs[i]);
        }
        System.out.println(dp[N]);
    }
}

[백준/9095] 1, 2, 3 더하기 - Java 자바

dev-99 — Tue, 12 Nov 2024 16:50:40 +0900

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

개념: dp

문제

정수 4를 1, 2, 3의 합으로 나타내는 방법은 총 7가지가 있다. 합을 나타낼 때는 수를 1개 이상 사용해야 한다.

1+1+1+1
1+1+2
1+2+1
2+1+1
2+2
1+3
3+1

정수 n이 주어졌을 때, n을 1, 2, 3의 합으로 나타내는 방법의 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있고, 정수 n이 주어진다. n은 양수이며 11보다 작다.

풀이

N = 4일때를 예시로 보면, `dp[N] = dp[N-1] + dp[N-2] + dp[N-3]`으로 나타낼 수 있음을 알 수 있다.

3+1, 2+1+1, 1+2+1, 1+1+1+1
2+2, 1+1+2
1+3

따라서 초기값은 dp[1], dp[2], dp[3]까지 설정해준다.

전체코드

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));
        int T = Integer.parseInt(br.readLine());
        int[] problem = new int[T];
        for (int t = 0; t < T; t++) {
            int N = Integer.parseInt(br.readLine());
            problem[t] = N;
        }
        for (int i = 0; i < T; i++) {
            int n = problem[i];
            int[] dp = new int[n+5];
            dp[1] = 1; dp[2] = 2; dp[3] = 4;
            for (int j = 4; j <= n; j++) {
                dp[j] = dp[j-1] + dp[j-2] + dp[j-3];
            }
            System.out.println(dp[n]);
        }
    }
}

[백준/1463] 1로 만들기 - Java 자바

dev-99 — Tue, 12 Nov 2024 16:04:31 +0900

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

개념: dp, bfs

문제

정수 X에 사용할 수 있는 연산은 다음과 같이 세 가지 이다.

X가 3으로 나누어 떨어지면, 3으로 나눈다.
X가 2로 나누어 떨어지면, 2로 나눈다.
1을 뺀다.

정수 N이 주어졌을 때, 위와 같은 연산 세 개를 적절히 사용해서 1을 만들려고 한다. 연산을 사용하는 횟수의 최솟값을 출력하시오.

입력

첫째 줄에 1보다 크거나 같고, 106보다 작거나 같은 정수 N이 주어진다.

1. dp로 푼 풀이

주어진 예시로 생각해보면 `dp[10] = min(dp[3] + 1, dp[5] + 1, dp[9] + 1)`이다.

d[n]을 구하고자 할때 n-1은 항상 가능하므로 dp[n] = dp[n-1] + 1을 구한다. 그리고 n이 3으로 나누어지면 min(dp[n], dp[n/3]+1)으로 값을 업데이트한다. n이 2로 나누어질 때도 마찬가지다.

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

public class baekjoon {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        int[] dp = new int[N+1];
        dp[1] = 0;
        for (int i = 2; i <= N; i++) {
            dp[i] = dp[i-1] + 1;
            if (i % 2 == 0) {
                dp[i] = Math.min(dp[i], dp[i/2] + 1);
            }
            if (i % 3 == 0) {
                dp[i] = Math.min(dp[i], dp[i/3] + 1);
            }
        }
        System.out.println(dp[N]);
    }
}

2. bfs로 푼 풀이

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));
        int N = Integer.parseInt(br.readLine());
        
        Queue<Integer> queue = new LinkedList<>();
        int[] visited = new int[N+1];
        
        queue.add(N);
        visited[N] = 1;

        while (!queue.isEmpty()) {
            int current = queue.poll();

            if (current == 1) {
                System.out.println(visited[current] - 1);
                return;
            }

            if (current % 3 == 0 && visited[current / 3] == 0) {
                visited[current / 3] = visited[current] + 1;
                queue.add(current / 3);
            }

            if (current % 2 == 0 && visited[current / 2] == 0) {
                visited[current / 2] = visited[current] + 1;
                queue.add(current / 2);
            }

            if (current - 1 > 0 && visited[current - 1] == 0) {
                visited[current - 1] = visited[current] + 1;
                queue.add(current - 1);
            }
        }
    }
}

일단 dp가 구현이 더 쉽고, 메모리도 살짝 더 나은 편이다.

[백준/1541] 잃어버린 괄호 - Java 자바

dev-99 — Tue, 5 Nov 2024 23:15:22 +0900

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

개념: 그리디

문제

세준이는 양수와 +, -, 그리고 괄호를 가지고 식을 만들었다. 그리고 나서 세준이는 괄호를 모두 지웠다.

그리고 나서 세준이는 괄호를 적절히 쳐서 이 식의 값을 최소로 만들려고 한다.

괄호를 적절히 쳐서 이 식의 값을 최소로 만드는 프로그램을 작성하시오.

입력

첫째 줄에 식이 주어진다. 식은 ‘0’~‘9’, ‘+’, 그리고 ‘-’만으로 이루어져 있고, 가장 처음과 마지막 문자는 숫자이다. 그리고 연속해서 두 개 이상의 연산자가 나타나지 않고, 5자리보다 많이 연속되는 숫자는 없다. 수는 0으로 시작할 수 있다. 입력으로 주어지는 식의 길이는 50보다 작거나 같다.

출력

첫째 줄에 정답을 출력한다.

예시

55-50+40
>> 55-(50+40) = -35

10+20+30+40
>> 10+20+30+40 = 100

00009-00009
>> 00009-00009 = 0

접근방법

적절히(?) 괄호를 쳐서 식의 결과값이 최소가 되도록 하랜다..

우선 마이너스 기호가 중요한거 같으니 입력을 - 기호를 기준으로 split 한다.

- 기호를 기준으로 분리한 문자열 안에 정수들끼리 더해준다.

그리고 분리된 문자열들을 뺄셈해준다.

가장 처음과 마지막은 숫자라고 했기 때문에, 첫 번째 수가 음수인 경우는 없다고 판단했다.

전체코드

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 answer = Integer.MAX_VALUE;
        String input = br.readLine();
        
        String[] subtract = input.split("-");
        for (int i = 0; i < subtract.length; i++) {
            int temp = 0;
            
            // -를 기준으로 나눈 문자열끼리 더해준다.
            String[] addition = subtract[i].split("\\+");
            for (int j = 0; j < addition.length; j++) {
                temp += Integer.parseInt(addition[j]);
            }
            
            // 첫 번째 숫자인지 판별한다. 아니라면 뺄셈을 한다.
            if (answer == Integer.MAX_VALUE) {
                answer = temp;
            } else {
                answer -= temp;
            }
        }
        System.out.println(answer);
    }
}

subtract[i].split("\\+"): 특수문자 이스케이프 처리할 것

[백준/1931] 회의실 배정 - Java 자바

dev-99 — Tue, 5 Nov 2024 22:20:05 +0900

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

개념: 그리디

문제

한 개의 회의실이 있는데 이를 사용하고자 하는 N개의 회의에 대하여 회의실 사용표를 만들려고 한다. 각 회의 I에 대해 시작시간과 끝나는 시간이 주어져 있고, 각 회의가 겹치지 않게 하면서 회의실을 사용할 수 있는 회의의 최대 개수를 찾아보자. 단, 회의는 한번 시작하면 중간에 중단될 수 없으며 한 회의가 끝나는 것과 동시에 다음 회의가 시작될 수 있다. 회의의 시작시간과 끝나는 시간이 같을 수도 있다. 이 경우에는 시작하자마자 끝나는 것으로 생각하면 된다.

입력

첫째 줄에 회의의 수 N(1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N+1 줄까지 각 회의의 정보가 주어지는데 이것은 공백을 사이에 두고 회의의 시작시간과 끝나는 시간이 주어진다. 시작 시간과 끝나는 시간은 231-1보다 작거나 같은 자연수 또는 0이다.

출력

첫째 줄에 최대 사용할 수 있는 회의의 최대 개수를 출력한다.

접근방법

주어진 회의 시간을 어떤 기준으로 정렬할 것인지?

→ 회의가 끝나는 시간을 빠른 순으로 정렬한다. 만약 끝나는 시간이 같다면 시작 시간이 빠른 순으로 정렬한다.

입력 전체를 돌면서 이전 회의가 끝나는 시간과 겹치지 않도록 다음 회의를 선택한다.

전체코드

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());
        int[][] time = new int[N][2];
        StringTokenizer st;
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            time[i][0] = Integer.parseInt(st.nextToken());
            time[i][1] = Integer.parseInt(st.nextToken());
        }
        
        Arrays.sort(time, (o1, o2) -> {
            if (o1[1] == o2[1]) { // 종료시간이 같은 경우 시작 시간이 빠른 순
                return o1[0] - o2[0];
            }
            return o1[1] - o2[1]; // 종료시간이 빠른 순
        });

        int cnt = 0;
        int end = 0;

        for (int i = 0; i < N; i++) {
            if (end <= time[i][0]) {
                end = time[i][1];
                cnt++;
            }
        }
        System.out.println(cnt);
    }
}

[백준/18230] 2xN 예쁜 타일링 - Java 자바

dev-99 — Tue, 5 Nov 2024 09:30:43 +0900

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

개념: 그리디

접근

N이 홀수라면 2x1 타일 하나를 우선 선택한다.
N/2번 동안 for문을 돌면서
- 2x2 타일 1개 vs 2x1 타일 2개 값을 비교한다. 값이 더 큰 경우를 선택한다.

전체코드

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

public class Main
{        
    static int N, A, B;
    static ArrayList<Integer> twoByOne;
    static ArrayList<Integer> twoByTwo;

    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());
        A = Integer.parseInt(st.nextToken());
        B = Integer.parseInt(st.nextToken());

        twoByOne = new ArrayList<>();
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < A; i++) {
            twoByOne.add(Integer.parseInt(st.nextToken()));
        }

        twoByTwo = new ArrayList<>();
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < B; i++) {
            twoByTwo.add(Integer.parseInt(st.nextToken()));
        }

        twoByOne.sort(Comparator.reverseOrder());
        twoByTwo.sort(Comparator.reverseOrder());

        int answer = 0;

        if (N % 2 == 1) {
            answer += twoByOne.get(0);
            twoByOne.remove(0);
        }

        for (int i = 0; i < N/2; i++) {
            int case1 = 0;
            int case2 = 0;
            if (twoByOne.size() >= 2) {
                case1 = twoByOne.get(0) + twoByOne.get(1);
            }
            if (twoByTwo.size() >= 1) {
                case2 = twoByTwo.get(0);
            }

            if (case1 > case2) {
                answer += case1;
                twoByOne.remove(0);
                twoByOne.remove(0);
            } else {
                answer += case2;
                twoByTwo.remove(0);
            }
        }

        System.out.println(answer);
    }
}

[프로그래머스] 메뉴 리뉴얼 - Python 파이썬

dev-99 — Thu, 31 Oct 2024 20:42:00 +0900

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

프로그래머스

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

programmers.co.kr

접근방법

1. 코스의 요리 개수를 기준으로 가능한 조합을 구한다.

2. 주문내역을 돌면서 가능한 조합을 구한다.

3. 각 조합의 주문 횟수를 센다.

4. 가장 많이 주문된 조합을 정답에 추가한다.

2개의 요리로 만들 수 있는 조합을 구하기로 한다.

- 주문내역에서 2개를 선택한 조합을 구한다.

- 각 조합이 몇 번 주문됐는지 센다.

- 최대 주문 횟수만큼 주문된 조합을 정답에 추가한다.

3개의 요리로 만들 수 있는 조합을 구한다.

... (반복)

전체코드

from itertools import combinations
from collections import Counter

def solution(orders, course):
    answer = []
    
    for length in course:
        candidates = []
        for order in orders:
            order = sorted(order) # 주문을 정렬하여 'AB'와 'BA'를 같은 것으로 처리
            combi = combinations(order, length)
            candidates.extend(''.join(c) for c in combi)
        
        # 각 조합이 몇 번 등장했는지 세기
        menu_count = {}
        for candidate in candidates:
            if candidate in menu_count:
                menu_count[candidate] += 1
            else:
                menu_count[candidate] = 1
        
        # menu_count가 비어있지 않고, 가장 많이 등장한 횟수가 2 이상인 경우
        if menu_count and max(menu_count.values()) >= 2:
            max_count = max(menu_count.values())
            for menu, count in menu_count.items():
                if count == max_count:
                    answer.extend([menu])
    
    return sorted(answer)

해설을 찾아봤는데 파이썬의 Counter 클래스를 활용해 주문 횟수를 세는 풀이도 있더라. 파이썬 라이브러리를 잘 활용하자

Counter를 사용한 코드

from itertools import combinations
from collections import Counter

def solution(orders, course):
    answer = []
    
    for length in course:
        candidates = []
        for order in orders:
            order = sorted(order)
            combi = combinations(order, length)
            candidates.extend(''.join(c) for c in combi)
        
        # 조합별 등장 횟수 계산
        counter = Counter(candidates)
        
        # 조합이 있고, 최소 2번 이상 주문된 경우
        if counter and max(counter.values()) >= 2:
            max_count = max(counter.values())
            answer.extend([menu for menu, count in counter.items() 
                         if count == max_count])
    
    return sorted(answer)

Counter 사용 예시

자동으로 요소의 개수를 세어준다.

counter = Counter(['AB', 'AC', 'BC', 'AB', 'AC', 'CD'])
print(counter)  
# Counter({'AB': 2, 'AC': 2, 'BC': 1, 'CD': 1})

딕셔너리처럼 접근할 수 있다.
values(), items() 등 딕셔너리 메서드를 사용할 수 있다.
most_common()이라는 메서드도 제공한다.

# counter.items()는 (메뉴, 등장횟수) 튜플을 반환
for menu, count in counter.items():
    print(f"{menu}: {count}번 등장")
    
# 출력:
# AB: 2번 등장
# AC: 2번 등장
# BC: 1번 등장
# CD: 1번 등장

[프로그래머스] 신고 결과 받기 - Java 자바

dev-99 — Wed, 30 Oct 2024 17:38:12 +0900

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

사용개념: 해시

import java.util.*;

class Solution {
    public int[] solution(String[] id_list, String[] report, int k) {
        ArrayList<Integer> answer = new ArrayList<>();
        HashMap<String, Integer> reported = new HashMap<>(); // 유저별 신고 당한 횟수
        HashMap<String, HashSet<String>> reportByUser = new HashMap<>(); // 유저별 신고한 id 저장
        
        for (String id : id_list) {
            reportByUser.put(id, new HashSet<>());
        }
        
        for (String r : report) {
            String[] split_report = r.split(" ");
            if (!reportByUser.get(split_report[0]).contains(split_report[1])) {
                reportByUser.get(split_report[0]).add(split_report[1]);
                reported.put(split_report[1], reported.getOrDefault(split_report[1], 0) + 1);
            }
        }

        for (String id : id_list) {
            int count = 0;
            for (String p : reportByUser.get(id)) {
                if (reported.get(p) != null && reported.get(p) >= k) {
                    count++;
                }
            }
            answer.add(count);
        }
        return answer.stream().mapToInt(i->i).toArray();
    }
}

[프로그래머스] 베스트 앨범 - Java 자바

dev-99 — Tue, 29 Oct 2024 09:30:53 +0900

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

프로그래머스

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

programmers.co.kr

사용개념: 해시

1. 노래 정보를 하나의 객체로 관리한다.

class Song {
	int id;
    int plays;
        
    Song(int id, int plays) {
    	this.id = id;
        this.plays = plays;
    }
}

2. 데이터 정리

장르별 총 재생횟수를 저장할 맵 하나, 장르별 노래 정보 (고유번호, 재생횟수) 저장할 맵 하나가 필요하다.

전체를 순회하면서 데이터를 정리한다.

HashMap<String, Integer> playByGenre = new HashMap<>(); // 장르별 총 재생횟수
HashMap<String, ArrayList<Song>> playlist = new HashMap<>(); // 장르별 노래 목록
int num = genres.length; // 전체 노래 개수

for (int i=0; i < num; i++) {
	String genre = genres[i];
    int play = plays[i];
            
	// 장르별 재생횟수 누적합 저장
    playByGenre.put(genre, playByGenre.getOrDefault(genre, 0) + play);
            
	// 장르별 노래 정보 저장
	if (!playlist.containsKey(genre)) {
		playlist.put(genre, new ArrayList<>());
	}
    playlist.get(genre).add(new Song(i, play));
}

3. 장르를 총 재생횟수를 기준으로 정렬한다.

List<String> sortedGenres = new ArrayList<>(playByGenre.keySet());
sortedGenres.sort((g1, g2) -> playByGenre.get(g2).compareTo(playByGenre.get(g1)));
// Integer 객체 비교라 compareTo 사용

4. 장르 내 노래를 재생횟수(내림차순), 고유번호(오름차순)을 기준으로 정렬한다.

for (String genre : sortedGenres) {
	ArrayList<Song> songs = playlist.get(genre);

	songs.sort((s1, s2) -> {
		if (s1.plays != s2.plays) {
			return s2.plays - s1.plays; // 정수 비교라 오버플로우 걱정 없어서 빼기 연산 사용
		}
		return s1.id - s2.id;
	});

	for (int i=0; i < Math.min(2, songs.size()); i++) {
		answer.add(songs.get(i).id);
	}
}

전체코드

import java.util.*;

class Solution {
    class Song {
        int id;
        int plays;
        
        Song(int id, int plays) {
            this.id = id;
            this.plays = plays;
        }
    }
    
    public int[] solution(String[] genres, int[] plays) {
        HashMap<String, Integer> playByGenre = new HashMap<>(); // 장르별 총 재생횟수
        HashMap<String, ArrayList<Song>> playlist = new HashMap<>(); // 장르별 노래 목록
        int num = genres.length; // 전체 노래 개수

        for (int i=0; i < num; i++) {
            String genre = genres[i];
            int play = plays[i];
            
            // 장르별 재생횟수 누적합 저장
            playByGenre.put(genre, playByGenre.getOrDefault(genre, 0) + play);
            
            // 장르별 노래 정보 저장
            if (!playlist.containsKey(genre)) {
                playlist.put(genre, new ArrayList<>());
            }
            playlist.get(genre).add(new Song(i, play));
        }

        // 장르를 총 재생횟수를 기준으로 정렬
        List<String> sortedGenres = new ArrayList<>(playByGenre.keySet());
        sortedGenres.sort((g1, g2) -> playByGenre.get(g2).compareTo(playByGenre.get(g1)));

        ArrayList<Integer> answer = new ArrayList<>();

        // 장르 내 노래를 재생횟수(내림차순), 고유번호(오름차순) 기준으로 정렬
        for (String genre : sortedGenres) {
            ArrayList<Song> songs = playlist.get(genre);

            songs.sort((s1, s2) -> {
                if (s1.plays != s2.plays) {
                    return s2.plays - s1.plays; // 내림차순
                }
                return s1.id - s2.id; // 오름차순
            });

            for (int i=0; i < Math.min(2, songs.size()); i++) {
                answer.add(songs.get(i).id);
            }
        }

        return answer.stream().mapToInt(i->i).toArray();
    }
}

[프로그래머스] 할인 행사 - Java 자바

dev-99 — Fri, 25 Oct 2024 09:30:54 +0900

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

프로그래머스

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

programmers.co.kr

해시 연습문제~

해시맵 하나에는 원래 구매 품목이랑 개수 정보를 담고, 다른 하나는 탐색하면서 개수 조절하는 용도이다.

전체코드

import java.util.*;

class Solution {
    public int solution(String[] want, int[] number, String[] discount) {
        int answer = 0;
        HashMap<String, Integer> map = new HashMap<>();
        for (int i = 0; i < want.length; i++) {
            map.put(want[i], number[i]);
        }
        
        for (int i = 0; i <= discount.length-10; i++) {
            HashMap<String, Integer> newMap = new HashMap<>();
            newMap.putAll(map);
            for (int j = i; j < i + 10; j++) {
                String product = discount[j];
                
                if (newMap.containsKey(product) && newMap.get(product) > 0) {
                    newMap.put(product, newMap.get(product) - 1);
                }
            }
            
            boolean flag = true;
            for (String key : newMap.keySet()) {
                if (newMap.get(key) != 0) flag = false;
            }
            if (flag) answer ++;
        }
        return answer;
    }
}

[백준] 파티 - Java 자바

dev-99 — Thu, 24 Oct 2024 07:35:11 +0900

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

사용개념: 다익스트라

문제 설명

1. N명의 학생이 각자의 마을에서 X번 마을로 가는 최단 시간

2. 파티가 끝난 후 다시 자신의 마을로 돌아가는 최단 시간

3. 이 왕복 시간이 가장 오래 걸리는 학생의 소요시간을 찾는 것

풀이

1. 다익스트라를 2번 사용한다

X로 가는 최단 시간 (마을 → X)
되돌아가는 최단 시간 (X → 마을)

2. 정방향 그래프, 역방향 그래프 활용

정방향 그래프로 각 정점에서 X까지 최단 시간을 구한다
역방향 그래프로 X에서 각 정점까지 최단 시간 구한다

3. 마지막으로 각 학생별로 두 거리의 합을 구한 뒤 최댓값을 찾는다

전체코드

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

public class Main {
    static int N, M, X;
    static ArrayList<ArrayList<Node>> graph;
    static ArrayList<ArrayList<Node>> reverseGraph;

    static class Node implements Comparable<Node> {
        int vertex, weight;

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

        @Override
        public int compareTo(Node other) {
            return Integer.compare(this.weight, other.weight);
        }
    }

    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());
        M = Integer.parseInt(st.nextToken());
        X = Integer.parseInt(st.nextToken());

        // 인접 리스트
        graph = new ArrayList<>();
        reverseGraph = new ArrayList<>();
        for (int i = 0; i <= N + 1; i++) {
            graph.add(new ArrayList<>());
            reverseGraph.add(new ArrayList<>());
        }

        for (int i = 0; i < M; i++) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            int w = Integer.parseInt(st.nextToken());
            
            graph.get(u).add(new Node(v, w));
            reverseGraph.get(v).add(new Node(u, w));
        }

        int[] toX = dijkstra(X, graph);
        int[] fromX = dijkstra(X, reverseGraph);

        int result = 0;
        for (int i = 1; i <= N; i++) {
            result = Math.max(result, toX[i] + fromX[i]);
        }
        
        System.out.println(result);
    }

    static int[] dijkstra(int start, ArrayList<ArrayList<Node>> graph) {
        // 최소 시간 배열
        int[] distance = new int[N+1];
        Arrays.fill(distance, Integer.MAX_VALUE);
        distance[start] = 0;

        // 우선순위 큐
        PriorityQueue<Node> q = new PriorityQueue<>();
        q.add(new Node(start, 0));

        while (!q.isEmpty()) {
            Node current = q.remove();

            if (current.weight > distance[current.vertex]) continue;

            for (Node next : graph.get(current.vertex)) {
                int cost = next.weight + distance[current.vertex];

                if (cost < distance[next.vertex]) {
                    distance[next.vertex] = cost;
                    q.add(new Node(next.vertex, cost)); 
                }
            }
        }

        return distance;
    }
}

[프로그래머스] 배달 - Java 자바

dev-99 — Wed, 23 Oct 2024 05:23:41 +0900

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

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

사용개념: 다익스트라

일반적인 다익스트라 문제다. 주의할 점이라면 무방향/양방향 그래프라는 점, 그리고 두 마을을 연결하는 도로가 여러 개일 수 있다는 점이다.

전체 코드

import java.util.*;

class Solution {
    static class Node implements Comparable<Node> {
        int vertex, weight;

        public Node(int vertex, int weight) {
            this.vertex = vertex;
            this.weight = weight;
        }
        
        @Override
        public int compareTo(Node other) {
            return Integer.compare(this.weight, other.weight);
        }
    }
    
    public int solution(int N, int[][] road, int K) {        
        // 인접 리스트
        ArrayList<ArrayList<Node>> graph = new ArrayList<>();
        for (int i = 0; i <= N; i++) {
            graph.add(new ArrayList<>());
        }
        
        // 간선 정보 입력
        for (int i = 0; i < road.length; i++) {
            int u = road[i][0];
            int v = road[i][1];
            int w = road[i][2];
            
            // 양방향으로 간선 추가
            graph.get(u).add(new Node(v, w));
            graph.get(v).add(new Node(u, w));
        }
        
        // 최단 시간 배열
        int[] dist = new int[N+1];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[1] = 0;
        
        // 우선순위 큐
        PriorityQueue<Node> q = new PriorityQueue<>();
        q.add(new Node(1, 0));
        
        while (!q.isEmpty()) {
            Node current = q.remove();
            
            if (current.weight > dist[current.vertex]) continue;
            
            for (Node next : graph.get(current.vertex)) {
                int cost = next.weight + dist[current.vertex];
                
                if (cost < dist[next.vertex]) {
                    dist[next.vertex] = cost;
                    q.add(new Node(next.vertex, cost));
                }
            }
        }

        // K 이하 시간 내 배달 가능한 마을 개수 리턴
        int answer = 0;
        for (int i = 1; i <= N; i++) {
            if (dist[i] <= K) answer++;
        }
        return answer;
    }
}

PCB와 컨텍스트 스위칭

dev-99 — Tue, 22 Oct 2024 22:21:00 +0900

PCB (Process Control Block)

운영체제가 프로세스를 관리하기 위해 사용하는 자료구조이다.

커널 주소 공간의 Data 영역 내 존재하며, 프로세스마다 1개씩 있다.

OS가 관리상 사용하는 정보
- Process state, Process ID, 우선순위, scheduling information
CPU 수행 관련 하드웨어 값
- Program counter, registers
메모리 관련
- Code, Data, Stack의 위치 정보
파일 관련

Program counter와 같은 context 정보는 CPU에 있는데 왜 PCB에 또 보관하는가? Context Switching을 위해

Context Switching

CPU를 한 프로세스에서 다른 프로세스로 넘겨주는 과정이다. 예를 들어, 프로세스 A에서 B로 CPU를 넘겨준다고 가정하자.

A 프로세스 상태를 A의 PCB에 저장한다.
B 프로세스 상태를 PCB에서 읽어온다. CPU의 레지스터 내에 해당 데이터를 복원 시킨다.

주의할 점?

시스템콜이나 인터럽트 발생시 반드시 context switch가 일어나는 것이 아니다.

1번은 문맥 교환이 아니다.

단순히 프로그램 A로부터 운영체제 커널로 CPU가 넘어갔다고 해서 문맥 교환에 해당하지 않는다. 시스템콜이나 인터럽트가 다른 프로그램 B로부터 발생했다고 하더라도, 결국 A로 다시 복귀했기 때문에 그렇다.

프로그램 A로부터 프로그램 B로 CPU가 넘어가야 문맥 교환이다.

1번의 경우에도 CPU 수행 정보 등 context의 일부를 PCB에 저장해야 한다. 하지만 문맥 교환을 하는 경우(e.g. cache memory flush)에 비하면 오버헤드가 매우 작은 편이다.

출처: 반효경 교수님 운영체제 3강 http://www.kocw.net/home/search/kemView.do?kemId=1226304

프로세스의 상태

dev-99 — Tue, 22 Oct 2024 21:56:46 +0900

프로세스의 문맥(context)

프로세스 상태에 대한 모든 정보를 뜻한다.

하드웨어 문맥
- Program Counter
- 각종 register
프로세스 주소 공간
- code, data, stack
프로세스 관련 커널 자료구조
- PCB
- Kernel stack

프로세스의 상태

Running

CPU를 잡고 instruction을 실행 중인 상태

Ready

CPU를 기다리는 상태 (나머지 조건을 모두 만족하고)

Blocked

CPU를 주어도 당장 instruction을 수행할 수 없는 상태
Process 자신이 요청한 event(e.g. IO)가 즉시 만족되지 않아 기다리는 상태

예를 들어, 키보드 입력을 기다려야 하는 프로세스가 있다고 하자. 해당 프로세스는 Blocked 상태이므로 CPU를 주지 않는다. Ready queue에 있는 다른 프로세스에게 CPU를 준다.

그러다가 입력이 해소가 되면? 키보드 컨트롤러가 CPU에 인터럽트를 발생 시켜 CPU 제어권이 운영체제에게 넘어간다. 해당 프로그램을 Blocked 상태가 아닌 Ready 상태로 바꾼다.

공유 데이터와 Resource queue

공유 데이터: 프로세스 간 함께 사용하는 데이터
프로세스 간 동시에 사용하지 않도록 Resource queue를 통해 Ready / Blocked 상태로 관리한다.

프로세스 상태 흐름

New

- Ready 직전 상태로 프로세스가 생성 중인 상태

Ready

- CPU만 주면 바로 실행될 수 있음. 따라서 프로세스가 메모리에 올라가 있음.

- CPU Scheduler가 프로세스에게 CPU를 주면 Running 상태가 된다.

Running

- 프로세스가 CPU에서 기계어를 실행하다가, CPU를 내놓는 경우는 대락 3가지가 있다.

타이머 인터럽트가 걸린 경우 (다시 ready queue 마지막에 들어감)
오래 걸리는 작업으로 인해 Blocked 상태가 되는 경우
작업을 전부 완료한 경우 Terminated 상태가 된다.

Terminated

- 프로세스가 종료 중인 상태

출처: 반효경 교수님 운영체제 3강 http://www.kocw.net/home/search/kemView.do?kemId=1226304

[백준] 최단경로 - Java 자바

dev-99 — Tue, 22 Oct 2024 06:09:18 +0900

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

사용개념: 다익스트라

다익스트라를 통해 한 노드에서 모든 노드로 가는 최단거리를 구할 수 있다.

최단거리를 저장하는 배열과 우선순위 큐를 이용해 구현한다.

전체 코드

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

public class Main {
    static class Node implements Comparable<Node> {
        int vertex, weight;

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

        @Override
        public int compareTo(Node other) {
            return weight - other.weight;
        }
    }

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

        int V = Integer.parseInt(st.nextToken());   // 정점 개수
        int E = Integer.parseInt(st.nextToken());   // 간선 개수
        int K = Integer.parseInt(br.readLine());    // 시작 정점

        // 인접 리스트 생성
        ArrayList<ArrayList<Node>> graph = new ArrayList<>();
        for (int i = 0; i <= V; i++) {
            graph.add(new ArrayList<>());
        }

        // 간선 정보 입력
        for (int i = 0; i < E; i++) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            int w = Integer.parseInt(st.nextToken());
            graph.get(u).add(new Node(v, w));
        }

        // 최단 거리 배열
        int[] distance = new int[V+1];
        Arrays.fill(distance, Integer.MAX_VALUE);
        distance[K] = 0;

        // 우선순위 큐
        PriorityQueue<Node> pq = new PriorityQueue<>();
        pq.add(new Node(K, 0));

        while (!pq.isEmpty()) {
            Node current = pq.remove();

            if (distance[current.vertex] < current.weight) continue;

            for (Node next : graph.get(current.vertex)) {
                int cost = distance[current.vertex] + next.weight;

                if (cost < distance[next.vertex]) {
                    distance[next.vertex] = cost;
                    pq.add(new Node(next.vertex, cost));
                }
            }
        }

        // 결과 출력
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= V; i++) {
            if (distance[i] == Integer.MAX_VALUE) {
                sb.append("INF\n");
            } else {
                sb.append(distance[i] + "\n");
            }
        }
        System.out.println(sb);
    }
}

Node 클래스

PriorityQueue 사용을 위해 Comparable 인터페이스 구현

PriorityQueue에서 노드들을 가중치 기준으로 정렬하기 위해 필요
Comparable 인터페이스를 구현하여 노드 간 비교 방법을 정의

// PriorityQueue 사용 예시
PriorityQueue<Node> pq = new PriorityQueue<>();
pq.offer(new Node(1, 4));
pq.offer(new Node(2, 3));
Node smallest = pq.poll();  // 가중치가 3인 노드가 먼저 나옴

다익스트라를 자바로 구현하는 연습도 필요할 것 같아서 풀어봤다.

[백준] 최소비용 구하기 - Python 파이썬

dev-99 — Mon, 21 Oct 2024 22:55:59 +0900

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

사용개념: 다익스트라

가중치를 갖는 그래프에서 최단 경로를 찾는 문제이므로 다익스트라 알고리즘을 사용해 해결한다.

그래프 입력 받기

graph = [[] for _ in range(N+1)]

for _ in range(M):
    start, end, cost = map(int, input().split())
    graph[start].append((end, cost))

입력 결과)

[[], [(2, 2), (3, 3), (4, 1), (5, 10)], [(4, 2)], [(4, 1), (5, 1)], [(5, 3)], []]

다익스트라 알고리즘

def dijkstra(graph, start):
    # 모든 노드의 거리를 무한대로 초기화
    distances = [float('infinity')] * (N+1)
    distances[start] = 0
    # 우선순위 큐
    queue = []
    # 시작 노드부터 탐색 시작
    heapq.heappush(queue, [distances[start], start])
    
    while queue:
        current_distance, current_node = heapq.heappop(queue)
        
        # 기존 거리보다 크면 무시
        if distances[current_node] < current_distance:
            continue
        
        # 인접 노드 탐색
        for adjacent, weight in graph[current_node]:
            distance = current_distance + weight
            
            # 더 짧은 경로 있으면 업데이트
            if distance < distances[adjacent]:
                distances[adjacent] = distance
                heapq.heappush(queue, [distance, adjacent])
    
    return distances

전체코드

import heapq

def dijkstra(graph, start):
    # 모든 노드의 거리를 무한대로 초기화
    distances = [float('infinity')] * (N+1)
    distances[start] = 0
    
    # 우선순위 큐
    queue = []
    
    # 시작 노드부터 탐색 시작작
    heapq.heappush(queue, [distances[start], start])
    
    while queue:
        current_distance, current_node = heapq.heappop(queue)
        
        # 기존 거리보다 크면 무시
        if distances[current_node] < current_distance:
            continue
        
        # 인접 노드 탐색
        for adjacent, weight in graph[current_node]:
            distance = current_distance + weight
            
            if distance < distances[adjacent]:
                distances[adjacent] = distance
                heapq.heappush(queue, [distance, adjacent])
    
    return distances

N = int(input())
M = int(input())
graph = [[] for _ in range(N+1)]
for _ in range(M):
    start, end, cost = map(int, input().split())
    graph[start].append((end, cost))
start, end = map(int, input().split())
dist_result = dijkstra(graph, start)
print(dist_result[end])

그래프 입력 받은게 영 지저분해서.. 쓸데없지만 딕셔너리로 입력 받을 수도 있다

입력 받기

graph = {i: {} for i in range(1, N + 1)}

for _ in range(M):
    a, b, w = map(int, input().split())
    graph[a][b] = w

결과)

{1: {2: 2, 3: 3, 4: 1, 5: 10}, 2: {4: 2}, 3: {4: 1, 5: 1}, 4: {5: 3}, 5: {}}

나머지 코드

import sys
import heapq
input = sys.stdin.readline

def dijkstra(graph, start, end):
    distances = {node: float('inf') for node in range(1, N + 1)}
    distances[start] = 0
    queue = []
    heapq.heappush(queue, [0, start])
    
    while queue:
        current_distance, current_node = heapq.heappop(queue)
        
        if current_node == end:
            return current_distance
            
        if distances[current_node] < current_distance:
            continue
            
        for next_node, weight in graph[current_node].items():
            distance = current_distance + weight
            
            if distance < distances[next_node]:
                distances[next_node] = distance
                heapq.heappush(queue, [distance, next_node])
                
    return distances[end]

N = int(input())  # 도시 개수
M = int(input())  # 버스 개수

graph = {i: {} for i in range(1, N + 1)}

for _ in range(M):
    a, b, w = map(int, input().split())
    graph[a][b] = w

start, end = map(int, input().split())
print(dijkstra(graph, start, end))

TCP의 흐름제어, 혼잡제어

dev-99 — Fri, 18 Oct 2024 09:30:56 +0900

TCP

인터넷 프로토콜 스위트의 핵심 프로토콜 중 하나로, 어플리케이션 간 reliable, ordered and error-checked 데이터의 전송을 보장한다.

연결 지향적: 통신 전에 연결을 설정하고 유지한다.
신뢰성: 데이터 전송의 신뢰성을 보장한다. 손실된 패킷은 재전송한다.
순서 보장: 데이터가 보낸 순서대로 수신된다.
양방향 통신: 양방향으로 동시에 데이터를 주고받을 수 있다.
바이트 스트림: 데이터를 연속된 바이트 스트림으로 처리한다.

TCP 작동 방식 간단히

sender, receiver 간 3-way handshake를 통해 연결을 설정한다.
데이터를 패킷 단위로 쪼갠다.
패킷에 순서를 부여한다.
오류 없이 패킷이 전달되도록 한다. 손실된 패킷은 재전송한다.
흐름제어를 통해 데이터 전송 속도를 조절한다.

흐름제어

발신자가 수신자의 처리 능력에 맞춰 데이터 전송 속도를 조절하는 것이다. 발신자와 수신자 두 노드 간 개념이라고 생각하면 된다.

종류는 크게 2가지, Stop-and-wait와 Sliding window가 있다.

0. 사전 지식

- send buffer, receive buffer

TCP는 보낼 데이터는 send buffer에, 받은 데이터는 receive buffer에 저장한다.
Application이 준비됐을때 receive buffer로부터 데이터를 읽는다.
따라서 흐름제어는 receive buffer가 받지 못할만큼의 데이터를 전송하지 않도록 데이터 흐름을 관리하는 것이다.

- receive window

이때, 수신자가 receive buffer에 남은 자리를 rwnd (Receive Window) 라는 개념으로 관리한다.
그래서 TCP는 패킷을 전송 받을 때마다, 이 정보를 ack 메세지에 담아 발신자에게 보낸다.

1. Stop and Wait

이를 응용한 것으로, 매번 전송한 패킷에 대한 확인 응답을 받아야 그 다음 패킷을 전송할 수 있는 방식이다.
오버플로우가 일어날 가능성은 없지만, 너무 느리다는 단점이 있다. 요즘에는 잘 사용하지 않는다.

2. Sliding Window

하나를 보내고 기다리는게 아니라, 여러 개를 동시에 보낼 수 있는 TCP 프로토콜이다. 이때 동시에 보낼 수 있는 사이즈가 정해져 있고, 이를 윈도우라고 한다.

위 그림은 윈도우 사이즈가 7이며, 7개 이하 데이터를 한번에 보낼 수 있는 경우이다.

0, 1을 보내면 윈도우 사이즈가 줄어든 것을 알 수 있다.
0과 1을 잘 받았다고 ACK2를 보내면 다시 윈도우가 2칸 늘어난다.
만약 윈도우 사이즈가 0이 되면, TCP는 데이터 전송을 멈추고 persist timer를 시작한다. 타이머가 시작되고 WindowProbe라는 작은 패킷을 계속 전송한다. receiver가 윈도우 사이즈에 여유가 생겼음을 알릴 수 있도록.
`LastByteSent - LastByteAcked ≤ ReceiveWindowAdvertised`
ACK 메세지도 데이터와 마찬가지로 한꺼번에 처리된다. (e.g. 데이터 3, 4, 5마다 ACK 4, 5, 6을 보내는 것이 아니라 6만 보낸다)
데이터와 ACK는 모두 양방향으로 전송되어야 한다.
- Two separate circuits: 둘이 전송되는 통로가 따로 존재하는 방식
- Piggybacking: 같이 보내는 방식

여전히 ACK를 받을 때까지 기다려야 한다는 점에서 비효율적이다. 그렇다고 윈도우를 무분별하게 늘리면 다시 흐름제어에 실패한다. 하지만 제일 범용적으로 사용되는 흐름제어 방식이다.

3. Rate Control / Policing

ACK 없이 트래픽이 유지되는 흐름제어 방식. 하지만 잘 사용되진 않는다.

혼잡제어

네트워크 전체의 혼잡을 조절하는 것이다. 네트워크 내 패킷 수가 과도하게 증가하는 현상을 혼잡이라고 하며, 혼잡제어는 어느 한 노드가 네트워크를 overload하지 않도록 제어하는 것이다.

Slow Start와 Congestion Avoidance가 있다.

1. 혼잡 윈도우 (Congestion Window, cwnd)

발신자는 자신의 윈도우 크기를 정할때, 수신자가 보내준 rwnd 와 자신이 네트워크 상황을 고려해 정한 cwnd 중 더 작은 값을 택한다.
마찬가지로 Sliding Window 방식을 사용한다.

2. 느린 시작 Slow Start

`cwnd = 1`
For each ACK, `cwnd ← cwnd + 1 [packets]`
발신자는 RTT 동안 cwnd 만큼의 패킷을 전송할 수 있으므로, 전송한 모든 패킷의 ACK를 받으면 cwnd는 RTT 마다 2배씩 증가한다.
Slow start는 2배씩 전송을 늘리다가 패킷 드랍으로 인해 RTO가 발생하면 종료된다.
- 이때 slow start를 종료하는 임계값인 ssthresh가 설정되고, cwnd 값은 다시 1로 리셋된다.
- For each RTO
  - `ssthresh ← cwnd/2 [packets]`
  - `cwnd ← 1 [packets]`
이후 slow start를 다시 수행하는데, cwnd 값이 ssthresh 값보다 커지면 네트워크 용량에 도달했다고 판단하고 slow start를 종료, congestion avoidance 단계로 넘어간다.

3. Congestion Avoidance (aka AIMD)

ACK을 수신하면 cwnd를 1/cwnd 씩 늘린다. 따라서 전송된 모든 패킷의 ACK를 수신하면, cwnd는 RTT마다 1씩 선형적으로 증가한다.
패킷 드랍이 일어나는 경우
1. RTO
  - RTO가 일어난 경우 slow start로 돌아가며 ssthresh를 cwnd/2로, cwnd를 1로 리셋한다. Slow start부터 다시 시작.
2. 3 duplicate ACK
  - 동일한 sequence number의 ACK을 3번이나 연속적으로 받으면 timeout이 일어나지 않아도 패킷 드랍이 일어났다고 판단하는 것을 의미한다.
  - 수신자 측에서 순서가 맞지 않는 패킷이 도착하면 이전 패킷(먼저 도착해야 할 패킷)의 ACK을 재전송하기 때문이다.
  - 이 경우 발신자는 fast restransmit (재전송)을 수행한다.
  - For each 3 dup-ACK, `cwnd ← cwnd/2`
  - RTO에 비해 심각한 상황이 아니므로 cwnd를 절반으로 줄여 전송량을 유지하고자 한다. 이를 fast recovery 상태에 돌입했다고 한다.

참고자료

https://www.brianstorti.com/tcp-flow-control/

https://ai-com.tistory.com/entry/네트워크-TCP-Congestion-Control-1-기본-원리

https://m.blog.naver.com/if_you-/220881729649

[프로그래머스] 표 편집 - Python 파이썬

dev-99 — Thu, 17 Oct 2024 15:53:20 +0900

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

프로그래머스

programmers.co.kr

효율성 테스트 통과X. linked list로 다시 풀어볼것~

def solution(n, k, cmd):
    table = list(range(n))
    deleted = ['O'] * n
    stack = []
    current = k

    for c in cmd:
        if c[0] == 'U':
            current -= int(c[2:])
        elif c[0] == 'D':
            current += int(c[2:])
        elif c[0] == 'C':
            deleted[table[current]] = 'X'
            stack.append(table[current])
            table.pop(current)
            if current == len(table):
                current -= 1
        elif c[0] == 'Z':
            restored = stack.pop()
            deleted[restored] = 'O'
            if restored < table[current]:
                current += 1
            insert_index = 0
            for i, value in enumerate(table):
                if value > restored:
                    insert_index = i
                    break
            else:
                insert_index = len(table)
            table.insert(insert_index, restored)

    return ''.join(deleted)

[백준] 지구 온난화 - Python 파이썬

dev-99 — Wed, 16 Oct 2024 18:03:31 +0900

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

원 지도는 탐색용으로 그대로 두고, 50년 후 지도를 그리기 위해 new_map을 deepcopy한다.
지도 전체를 돌면서 땅이 나오면 상,하,좌,우를 확인한다.
- 주변이 `"."` 이거나, 지도 범위를 벗어난 경우 모두 바다로 취급하여 cnt를 증가 시킨다.
- 주변의 세 칸 이상이 바다라면 땅이 잠긴다.
지도 크기를 최소화한다.
- 육지('X')를 포함하는 가장 작은 직사각형 영역만을 남기기 위해, 남아있는 땅의 가장 왼쪽, 오른쪽, 위, 아래 좌표를 찾는다.
해당 범위 내의 지도만을 결과로 출력한다.

전체 코드

import copy

def find_map(R, C, map):
    new_map = copy.deepcopy(map)
    dx = [1, -1, 0, 0]
    dy = [0, 0, 1, -1]
    
    for i in range(R):
        for j in range(C):
            if map[i][j] == "X":
                cnt = 0
                for dir in range(4):
                    nx = i + dx[dir]
                    ny = j + dy[dir]
                    
                    if nx<0 or nx>=R or ny<0 or ny>=C or map[nx][ny] == ".": 
                        cnt += 1
                
                if cnt >= 3: 
                    new_map[i][j] = "."
                    
    # 지도 크기 최소화
    min_x, max_x = C, -1
    min_y, max_y = R, -1
    
    for i in range(R):
        for j in range(C):
            if new_map[i][j] == "X":
                min_x = min(min_x, j)
                max_x = max(max_x, j)
                min_y = min(min_y, i)
                max_y = max(max_y, i)
    
    # 결과 출력
    result = []
    for i in range(min_y, max_y + 1):
        result.append(''.join(new_map[i][min_x:max_x + 1]))
    
    return result
    
R, C = map(int, input().split())
map = [list(input()) for _ in range(R)]
result = find_map(R, C, map)
for row in result:
    print(row)

[백준] 자리배정 - Python 파이썬

dev-99 — Tue, 15 Oct 2024 21:45:26 +0900

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

사용개념: 그리디

1. 시간복잡도

최악의 경우 모든 좌석을 방문해야 하므로 O(C*R)이다. 5 ≤ C, R ≤ 1,000 이므로 시간 내 계산 가능하다.

2. 풀이

2차원 배열에서 나선형 패턴으로 좌석을 배정한다.
방향 벡터를 사용하여 위, 오른쪽, 아래, 왼쪽 순서로 이동한다.
배열의 범위를 벗어나거나 이미 방문한 위치를 만나면 방향을 바꾼다.

def find_seat(C, R, K):
    if K > C * R: return 0
    
    dx = [0, 1, 0, -1]
    dy = [1, 0, -1, 0]
    
    seats = [[0] * C for _ in range(R)]
    x, y = 0, 0
    direction = 0
    
    for num in range(1, K + 1):
        if num == K:
            return x + 1, y + 1
        
        seats[y][x] = num
        nx, ny = x + dx[direction], y + dy[direction]
        
        if nx < 0 or nx >= C or ny < 0 or ny >= R or seats[ny][nx] != 0:
            direction = (direction + 1) % 4
            nx, ny = x + dx[direction], y + dy[direction]
        
        x, y = nx, ny
    
    return 0

C, R = map(int, input().split())
K = int(input())

result = find_seat(C, R, K)
if result == 0:
    print(0)
else:
    print(result[0], result[1])

3. (x, y) 좌표계 ⇔ 2차원 배열

일반적인 (x, y) 좌표계
- x: 열, y: 행

2차원 배열
- grid[행][열]

문제에서 R, C
- R: 행, C: 열

- 이미지 출처: https://good-potato.tistory.com/84

[백준/19941] 햄버거 분배 - Python 파이썬

dev-99 — Tue, 15 Oct 2024 00:07:40 +0900

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

사용개념: 그리디

1. 최적 해 구하는 법?

왼쪽 사람부터 좌,우에 존재하는 K거리 이내의 햄버거 중 가장 좌측의 것을 먹는것이 모든 사람이 가장 많은 햄버거를 먹을 수 있는 방법이다.

따라서 그리디 알고리즘을 사용한다.

2. 시간 복잡도

최대 N명의 사람마다 인접한 K개의 원소를 탐색해야 한다. 그러므로 시간복잡도는 O(N) * O(K)가 된다. N은 최대 20,000개, K는 최대 10개로 약 200,000개의 연산은 시간 내에 가능하다.

전체 코드

n, k = map(int, input().split())
positions = list(input())

answer = 0
for i in range(n):
    if positions[i] == "P":
        for j in range(i-k, i+k+1):
            if 0<=j<n and positions[j] == "H":
                positions[j] = "X"
                answer += 1
                break
print(answer)

[백준] 부등호 - Python 파이썬

dev-99 — Mon, 14 Oct 2024 17:10:17 +0900

사용개념: 브루트포스, 완전탐색

1. 완전 탐색이 가능한지?

K는 최대 9이므로 최악의 경우 숫자를 뽑는 경우의 수가 10!(=3628800)개 생긴다. 이는 시간 제한 안에 충분히 탐색 가능하다.

2. 전체 코드

from itertools import permutations

k = int(input())
signs = list(input().split())

number = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
numbers = list(permutations(number, k+1))

def check(num):
    flag = True
    for i in range(k):
        sign = signs.pop(0)
        if sign == "<":
            if num[i] > num[i+1]:
                flag = False
        else:
            if num[i] < num[i+1]:
                flag = False
        signs.append(sign)
    return flag    
        
for num in reversed(numbers):
    if check(num):
        print(''.join(map(str, num)))
        break

for num in numbers:
    if check(num):
        print(''.join(map(str, num)))
        break

3. DFS

10개의 숫자를 부등호 조건에 맞게 조합하는게 0~9를 방문처리하면서 dfs를 돌릴 수 있을 것 같았다.

`방문처리` → `재귀` → `방문처리 해제`를 해줄 것.

def check(a, b, sign):
    if sign == "<":
        if not a < b: return False
    if sign == ">":
        if not a > b: return False
    return True

def dfs(cnt, number):
    if cnt == k+1:
        answer.append(number)
        return
        
    for i in range(10):
        if visited[i]: continue
        
        if cnt == 0 or check(number[cnt-1], str(i), signs[cnt-1]):
            visited[i] = 1
            dfs(cnt+1, number+str(i))
            visited[i] = 0            
            
k = int(input())
signs = list(input().split())
visited = [0] * 10
answer = []
dfs(0, '')
answer.sort()
print(answer[-1])
print(answer[0])

[백준/14247] 나무 자르기 - Python 파이썬

dev-99 — Fri, 11 Oct 2024 23:27:06 +0900

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

사용개념: 그리디

1. 최적해 구하는 방법?

현재 키와 성장률을 기준으로 각각 생각해본다.

당장 제일 키가 큰 나무를 선택한다 (X)
성장률이 작은 나무부터 선택한다 (O)
- 모든 나무는 최대 n일 동안 성장할 수 있다. 따라서 나무마다 하루 성장하고 잘릴 수도, n일 동안 성장하고 잘릴 수도 있다.
- 그렇기 때문에 하루에 성장할 수 있는 길이가 가장 긴 나무를 제일 마지막에 자르는게 최대로 나무를 자를 수 있는 방법이다.
- 성장률이 제일 큰 나무만 계속 자르면 안되나?
  - 다른 나무들의 초기 길이를 자를 수 없다.

2. 나무를 성장률에 따라 정렬하기

# 나무를 성장률에 따라 정렬
trees = []
for i in range(n):
    trees.append([growth[i], height[i]])
trees.sort()

3. 성장률이 작은 나무부터 선택

# 성장률이 작은 나무부터 선택
answer = 0
for i in range(n):
    answer += trees[i][0] * i + trees[i][1]

초기 나무 길이 + i일까지 성장한 길이를 더해준다.

전체코드

n = int(input())
height = list(map(int, input().split()))
growth = list(map(int, input().split()))

# 나무를 성장률에 따라 정렬
trees = []
for i in range(n):
    trees.append([growth[i], height[i]])
trees.sort()

# 성장률이 작은 나무부터 선택
answer = 0
for i in range(n):
    answer += trees[i][0] * i + trees[i][1]
    
print(answer)

자바 코드

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));
        StringTokenizer st = new StringTokenizer(br.readLine());
        
        int n = Integer.parseInt(st.nextToken());
        Long answer = 0L;

        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < n; i++) {
            answer += Long.parseLong(st.nextToken());
        }

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

        Arrays.sort(growth);
        for (int i = 0; i < n; i++) {
            answer += growth[i] * i;
        }
        System.out.println(answer);
    }
}

[백준] 숫자판 점프 - 파이썬 Python

dev-99 — Wed, 9 Oct 2024 22:28:23 +0900

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

사용개념: 브루트포스, 그래프 탐색, dfs

재귀를 통해 dfs 그래프 탐색 구현

숫자의 길이가 6이 되면 리턴한다.
4가지 방향에 대해 그래프를 탐색한다.
- 다음 탐색 위치가 그래프 범위를 벗어나지 않는지 확인한다.
- 벗어나지 않는다면 재귀함수로 다시 호출한다. 이때까지 구한 숫자에 새로 탐색하여 얻은 수를 이어 붙인다.
결과를 set에 저장하여 중복을 피한다.
편의상 문자열로 숫자를 표현한다.

def dfs(x, y, number):
    if len(number) == 6:
        result.add(int(number))
        return
    
    for i in range(4):
        nx = x + dx[i]
        ny = y + dy[i]
        
        if(nx<0 or ny<0 or nx>4 or ny>4):
            continue
        
        else:
            dfs(nx, ny, number + board[nx][ny])

전체 코드

board = []
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]
result = set()

for _ in range(5):
    board.append(list(map(str, input().split())))

def dfs(x, y, number):
    if len(number) == 6:
        result.add(int(number))
        return
    
    for i in range(4):
        nx = x + dx[i]
        ny = y + dy[i]
        
        if(nx<0 or ny<0 or nx>4 or ny>4):
            continue
        
        else:
            dfs(nx, ny, number + board[nx][ny])

for i in range(5):
    for j in range(5):
        dfs(i, j, board[i][j])
        
print(len(result))