마트철수

<1> 뭘 할까 하다가 알고리즘 복습: '프로그래머스 거스름돈'

마트스 — Sat, 3 May 2025 13:46:10 +0900

1일차

시험 대비에 급하게 문제를 풀었었지만,
한 문제를 며칠씩 잡고서라도 끝까지 고민해보고 싶었다.

그리고 새롭게 배운 개념은
내가 진짜 이해했을 때 글로 정리해서 포스팅하는 방식도 해보고 싶다.

내가 [93]까지 정리해둔 알고리즘 문제들을 다시 복습해보고,
예전에 진행했던 프로젝트의 리팩토링도 함께 진행할 예정이다.

또, 소장하고 있는 유료 강의들도 다시 천천히 돌려보면서
올해 ~2025년 4월까지의 나의 성장 기록을 되돌아보려 한다.

나중에 사이드 프로젝트를 진행하게 될 그날을 위해,
지금의 준비도 소중한 기반이 될 것이라 생각한다.

알고리즘

프로그래머스 거스름돈 JAVA 풀이

이전 포스팅: https://martt.tistory.com/275

풀이:

dp[i] = i원을 만들 수 있는 경우의 수

그렇다면 dp[0] = 1로 시작해야 누적시킬 수 있음

money의 값들로 for문을 돌리자

코드:

import java.util.*;

class Solution {
    public int solution(int n, int[] money) {
        int[] dp = new int[n+1];
        dp[0] = 1;
        
        for(int i : money) {
            for(int j=i; j<=n; j++) {
                dp[j] = dp[j] + dp[j-i];
            }
        }
        
        return dp[n]%1000000007;
    }
}

[93] 코딩테스트: 거스름돈 자바 풀이 | DP

마트스 — Fri, 11 Apr 2025 16:10:55 +0900

코딩테스트 준비 93일차

오늘 풀 문제는 거스름이다.

사실 DP를 처음부터 생각하기엔 난 아직 부족하다고 생각한다.

DP와 관련된 여러 문제를 풀어보면서 쌓아나가려고 한다.

▼ 주말에 풀어볼 문제 ▼

프로그래머스

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

programmers.co.kr

거스름돈

DP
- 가능한 수를 누적
- dp[j] += dp[j - i]
  - j는 현재 인덱스, i는 현재 선택한 money 종류

출처: 프로그래머스 거스름돈 자바 풀이

프로그래머스

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

programmers.co.kr

실패 풀이
count 메서드가 구현 실패 .. DP로 생각 넓히기가 어려움..

import java.util.*;

class Solution {
    public int solution(int n, int[] money) {
        int answer = 0;
        Arrays.sort(money);
        
        for(int i=1; i<money.length; i++) {
            answer += count(money, i, n)%1000000007;
        }
    }
    
    //돈 종류, 사용할 종류 개수, 목표 돈
    private int count(int[] money, int len, int n) {
        
        
    }
}

1. DP
dp[i]는 금액 i를 만들 수 있는 방법의 수

초기값 dp[0] = 1으로 설정 => 아무 동전도 사용하지 않는 방법

2. 점화식 구조
각 동전 i에 대해 j = i부터 n까지 반복하면서 dp[j] += dp[j - i] 수행.

(=이 아닌 +=로 누적해줌)

3. 이차원 DP vs 일차원 DP
dp[동전개수][금액] 형태의 2차원 배열을 생각했으나,
각 동전별로 순차적으로 누적하는 방식이기 때문에 1차원 DP로도 충분하다고 판단

4. for문 순서? 중복 제거를 위해서
동전 순서를 바꾼 경우를 동일한 방법으로 간주하기 위해 동전부터 반복

정답 코드

class Solution {
    public int solution(int n, int[] money) {
        int[] dp = new int[n+1];
        dp[0] = 1;
        
        for(int i : money) {
            for(int j=i; j<=n; j++) {
                dp[j] += dp[j-i];
            }
        }
        
        return dp[n];
    }
}

효율성 테스트.. 완전탐색으론 불가

[92] 코딩테스트: [1차] 셔틀버스 자바 풀이 | 카카오 인턴십

마트스 — Thu, 10 Apr 2025 10:27:44 +0900

코딩테스트 준비 92일차

오늘 풀 문제는 [1차]셔틀 버스이다.

해당 문제는 당연히 그리디지만 어려운 그리디..

[1차] 셔틀 버스

Greedy
- 셔틀에 타기 위해 도착해야 할 가장 늦은 시간
모든 도착 시간을 분 단위로 변환해 오름차순 정렬 => PriorityQueue
셔틀을 1대씩 시뮬레이션 -> 마지막 셔틀에 콘이 탈 수 있는지 판단
- 만약 마지막 셔틀이 자리가 남았다면, 콘은 그 시간에 도착
- 만약 자리가 없다면, 마지막으로 탄 사람보다 1분 일찍 도착

출처: 프로그래머스 셔틀버스 자바 풀이 카카오 인턴십

프로그래머스

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

programmers.co.kr

if(i==n-1) {
        if(index == 0) {
            answer += "09:00";
        } else if(index < m) {
            answer += check2(list.get(index));
        }
    }
    for(int j=0; j<=index; j++) {
        list.remove(j);
    }
}

정답 코드

import java.util.*;

class Solution {
    PriorityQueue<Integer> pq = new PriorityQueue<>();
    
    public String solution(int n, int t, int m, String[] timetable) {
        String answer = "";
        
        for(int i=0; i<timetable.length; i++) {
            pq.add(check(timetable[i]));
        }
        
        int last = 0;
        int index = 0;
        for(int i=0; i<n; i++) {
            int curTime =540 + t*i;
            index = 0;
            
            while(!pq.isEmpty() && pq.peek()<=curTime && index<m) {
                last = pq.poll();
                index++;
            }
            
            if(i == n-1) {
                if(index < m) {
                    last = curTime;
                } else {
                    last -= 1;
                }
            }
        }

        return check2(last);
    }
    
    private int check(String t) {
        String[] time = t.split(":");
        return Integer.valueOf(time[0])*60+Integer.valueOf(time[1]);
    }
    
    private String check2(int t) {
        String a = String.valueOf(t/60);
        if(a.length() == 1) {
            a = "0"+a;
        }
        
        String b = String.valueOf(t%60);
        if(b.length() == 1) {
            b = "0"+b;
        }
        
        return a+":"+b;
    }
}

<JAVA TIL20> 코트타카 모음집 | dfs 문제 3개

마트스 — Tue, 8 Apr 2025 10:10:54 +0900

내일배움캠프 4/8 TIL

<JAVA TIL20> 코트타카 모음집 ❘ dfs 문제 3개

코드타카

어쩌다 보니 밀린 코트타카 문제들을 모아서 올리게 되었다

주말 복습 아자아자

[행렬 테두리 회전하기]

import java.util.*;

class Solution {
    int[][] map;
    ArrayList<Integer> list = new ArrayList<>();
    
    public int[] solution(int rows, int columns, int[][] queries) {
        map = new int[rows][columns];
        int index = 1;
        for(int i=0; i<rows; i++) {
            for(int j=0; j<columns; j++) {
                map[i][j] = index++;
            }
        }
        
        for(int i=0; i<queries.length; i++) {
            int sx = queries[i][0]-1;
            int ex = queries[i][2]-1;
            
            int sy = queries[i][1]-1;
            int ey = queries[i][3]-1;
            
            dfs(sx, ex, sy, ey);
        }
        
        int[] answer = new int[list.size()];
        for(int i=0; i<list.size(); i++) {
            answer[i] = list.get(i);
        }

        return answer;
    }
    
    private void dfs(int sx, int ex, int sy, int ey) {
        int cur = map[sx][sy];
        int min = cur;
        
        for(int i=sx; i<ex; i++) {
            map[i][sy] = map[i+1][sy];
            min = Math.min(min, map[i][sy]);
        }
        
        for(int i=sy; i<ey; i++) {
            map[ex][i] = map[ex][i+1];
            min = Math.min(min, map[ex][i]);
        }
        
        for(int i=ex; i>sx; i--) {
            map[i][ey] = map[i-1][ey];
            min = Math.min(min, map[i][ey]);
        }
        
        for(int i=ey; i>sy; i--) {
            map[sx][i] = map[sx][i-1];
            min = Math.min(min, map[sx][i]);
        }
        
        map[sx][sy+1] = cur;
        list.add(min);
    }
}

프로그래머스

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

programmers.co.kr

[전력망을 둘로 나누기]

완전 탐색

1. 좌표를 나눠서 끊어주는 방법

for(int[] w : wires) {
    int a = w[0];
    int b = w[1];

    list[a].remove(Integer.valueOf(b)); //좌표를 삭제하되, 인덱스를 지우지 않도록 형태 변환
    list[b].remove(Integer.valueOf(a));

    visited = new boolean[n+1]; //visited 배열 초기화
    int size1 = count(a); //덩어리 하나의 크기를 확인
    int size2 = n-size1;
    answer = Math.min(answer, Math.abs(size1-size2)); //작은 값이면서, 절대값

    list[a].add(b); //원상복귀
    list[b].add(a);
}

2. 크기 확인 방법

private int count(int a) { //리턴은 숫자로
    visited[a] = true; //방문 처리
    int c = 1; //하나의 dfs당 1씩 리턴

    for(int i : list[a]) {
        if(!visited[i]) {
            c += count(i); //값들을 누적해줌
        }
    }

    return c;
}

프로그래머스

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

programmers.co.kr

[배달]

Graph + BFS
- Arrays.fill을 사용해서 visited배열에 최대값을 넣어준다
- BFS를 돌면서, Math.min()을 사용해서 최소값이 들어가도록 해준다

import java.util.*;

class Solution {
    ArrayList<int[]>[] graph;
    int[] visited;
    
    public int solution(int N, int[][] road, int K) {
        graph = new ArrayList[N+1];
        visited = new int[N+1];
        int answer = 0;
        Arrays.fill(visited, Integer.MAX_VALUE);
        
        for(int i=1; i<=N; i++) {
            graph[i] = new ArrayList<>();
        }
        
        for(int i=0; i<road.length; i++) {
            int a = road[i][0];
            int b = road[i][1];
            int c = road[i][2];
            
            graph[a].add(new int[]{b, c});
            graph[b].add(new int[]{a, c});
        }
        
        visited[1] = 0;
        Queue<Integer> q = new LinkedList<>();
        for(int[] g : graph[1]) {
            int a = g[0];
            int b = g[1];
            visited[a] = Math.min(visited[a], b);
            q.add(a);
        }
        
        while(!q.isEmpty()) {
            int cur = q.poll();
            for(int[] c : graph[cur]) {
                int a = c[0];
                int b = c[1];
                
                if(visited[a] > visited[cur]+b) {
                    visited[a] = visited[cur]+b;
                    q.add(a);
                }
            }
        }
        
        for(int i=0; i<visited.length; i++) {
            if(visited[i] <= K) {
                answer++;
            }
        }
        
        return answer;
    }
}

프로그래머스

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

programmers.co.kr

[91] 코딩테스트: 가장 긴 팰린드롬 자바 풀이

마트스 — Tue, 8 Apr 2025 10:07:16 +0900

코딩테스트 준비 91일차

오늘 풀 문제는 가장 긴 팰린드이다.

우선 모든 경우의 수를 탐색해야한다고 생각했고,

이분탐색을 고민하다가 for문 2개를 사용해서 풀이했다.

가장 큰 팰린드롬

브루트포스
- 가능한 모든 경우의 수를 전부 탐색해서 정답을 찾는 방식
- 문자열의 모든 부분 문자열 확인
  - for (int i = 0; i < s.length(); i++)
  - for (int j = i; j < s.length(); j++)
- 팰린드롬체크
  - check(s, i, j)
  - 팰린드롬이면 그 길이를 저장하고 가장 긴 길이를 구함 => 정답

출처: 프로그래머스 가장 큰 팰린드롬 자바 풀이

프로그래머스

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

programmers.co.kr

정답 코드

class Solution {
    public int solution(String s) {
        int max = 1; //최소값을 1임

        for (int i=0; i<s.length(); i++) { //시작점은 0부터
            for (int j=i; j<s.length(); j++) { //끝점은 i부터
                if (check(s, i, j)) {
                    max = Math.max(max, j - i + 1); //끝점-시작점+1 (4~6 = 3)
                }
            }
        }

        return max;
    }

    private boolean check(String s, int str, int end) {
        while (str <= end) { //같은 위치때까지 확인해야함
            if (s.charAt(str) != s.charAt(end)) {
                return false;
            }
            str++;
            end--;
        }
        return true;
    }
}

[90] 코딩테스트: 부대복귀 자바 풀이 | Graph + visited 배열

마트스 — Mon, 7 Apr 2025 10:26:17 +0900

코딩테스트 준비 90일차

오늘 풀 문제는 부대복귀이다.

그래프로 우선 값을 저장하고,

BFS로 길이를 탐색했다.

제일 마지막에 참고하면 좋을 풀이도 함께 작성해두었다.

▼ 내일 풀 문제 ▼

현재 고민중..

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

프로그래머스

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

programmers.co.kr

부대복귀

Graph, BFS

출처: 프로그래머스 부대복귀 자바 풀이 그래프

프로그래머스

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

programmers.co.kr

실패

BFS 도중 목적지를 찾았을 때 루프를 제대로 종료하지 않음
- if(i==end)에서 answer[idx] = len+1; 하고 그냥 continue 처리
  - 최단 거리라고 보장할 수 없음
목적지를 찾지 못한 경우 처리 없음
- 목적지를 찾지 못한 경우는 answer[idx] = -1 처리
  - list[s].size() == 0일 때만 실행
- 노드가 연결은 돼 있지만, 목적지로 가는 경로가 없을 때 -1 처리를 하지 못함!!

private void check(int str, int end, int idx) {
    Queue<int[]> q = new LinkedList<>();
    visited[str] = true;
    q.add(new int[]{str, 0});

    while(!q.isEmpty()) {
        int[] a = q.poll();
        int s = a[0];
        int len = a[1];

        if(list[s].size() == 0) { //해당 조건은 while문 밖으로..
            answer[idx] = -1;
            break;
        }

        for(int i : list[s]) {
            if(!visited[i]) {
                if(i==end) { //for문 들어오기 전 예외 처리로..
                    answer[idx] = len+1;
                    break;
                } else {
                    visited[i] = true;
                    q.add(new int[]{i, len+1});
                }
            }
        }
    }
}

수정 코드 → 시간 초과

private void check(int str, int end, int idx) {
    Queue<int[]> q = new LinkedList<>();
    visited[str] = true;
    q.add(new int[]{str, 0});

    while(!q.isEmpty()) {
        int[] a = q.poll();
        int s = a[0];
        int len = a[1];

        if(s == end) {
            answer[idx] = len;
            return;
        }

        for(int i : list[s]) {
            if(!visited[i]) {
                visited[i] = true;
                q.add(new int[]{i, len+1});
            }
        }
    }

    answer[idx] = -1;
}

정답 코드

visited 배열을 방문 처리 + 길이 2가지 저장으로 사용
- 단순히 boolean으로 선언한다는 생각은.. 접어두기..

import java.util.*;

class Solution {
    ArrayList<Integer>[] list;

    public int[] solution(int n, int[][] roads, int[] sources, int destination) {
        int[] answer = new int[sources.length];

        list = new ArrayList[n+1];
        for(int i = 1; i <= n; i++) {
            list[i] = new ArrayList<>();
        }
        for(int[] road : roads) {
            list[road[0]].add(road[1]);
            list[road[1]].add(road[0]);
        }

        // destination 기준으로 모든 노드까지의 거리 계산
        int[] distance = new int[n+1];
        Arrays.fill(distance, -1); // -1은 도달할 수 없음을 의미
        bfs(destination, distance);

        // 각 source에 대해 거리 기록
        for(int i = 0; i < sources.length; i++) {
            answer[i] = distance[sources[i]];
        }

        return answer;
    }

    private void bfs(int start, int[] distance) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(start);
        distance[start] = 0;

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

            for(int next : list[now]) {
                if(distance[next] == -1) {
                    distance[next] = distance[now] + 1;
                    queue.add(next);
                }
            }
        }
    }
}

[89] 코딩테스트: 여행경로 자바 풀이 | 백트래킹

마트스 — Fri, 4 Apr 2025 09:14:41 +0900

코딩테스트 준비 89일차

오늘 풀 문제는 여행경로이다.

처음에는 HashMap으로 접근해서,

String과 String 배열을 저장해주는 방식으로 고민했다.

근데 풀이의 답이 보이지 않고 가능한 범위라 생각해서

백트래킹으로 문제를 풀이하였다.

여행 경로

백트래킹
- 출발지와 루트의 정보는 "ICN"으로 시작
- Collections.sort로 답 하나를 리턴

출처: 프로그래머스 여행 경로 자바 풀이 백트래킹

프로그래머스

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

programmers.co.kr

[1회독: 풀이완료]
dfs("ICN", "ICN", tickets, 0)
1.시작점 2.경유지를 모두 더한 문자열 3.참고 문자열 4.index 카운트

백트래킹

조건: 방문하는 공항 경로를 배열에 담아서 return 합니다.

▶ 백트래킹으로 str부터 값을 담아서 진행한다.

for(int i=0; i<tickets.length; i++) {
    if(!visited[i] && tickets[i][0].equals(str)) {
        visited[i] = true;
        dfs(tickets[i][1], cur+" "+tickets[i][1], tickets, idx+1);
        visited[i] = false;
    }
}

조건: 만일 가능한 경로가 2개 이상일 경우 알파벳 순서가 앞서는 경로를 return 합니다.

▶ list를 오름차순으로 정렬해서 첫번째 값을 리턴한다.

Collections.sort(list);
String[] answer = list.get(0).split(" ");
return answer;

정답 코드

import java.util.*;

class Solution {
    ArrayList<String> list = new ArrayList<>();
    boolean[] visited;
    
    public String[] solution(String[][] tickets) {
        
        visited = new boolean[tickets.length];
        dfs("ICN", "ICN", tickets, 0);
        Collections.sort(list);
        String[] answer = list.get(0).split(" ");
        return answer;
        
    }
    
    private void dfs(String str, String cur, String[][] tickets, int idx) {
        
        if(idx == tickets.length) {
            list.add(cur);
            return;
        }
        
        //백트래킹
        for(int i=0; i<tickets.length; i++) {
            if(!visited[i] && tickets[i][0].equals(str)) {
                visited[i] = true;
                dfs(tickets[i][1], cur+" "+tickets[i][1], tickets, idx+1);
                visited[i] = false;
            }
        }
        
    }
}

<JAVA TIL19> 마지막 MSA 프로젝트 시작! | dfs 문제 참고 + 클래스로더

마트스 — Thu, 3 Apr 2025 20:24:53 +0900

내일배움캠프 4/3 TIL

<JAVA TIL19> 마지막 MSA 프로젝트 시작! ❘ dfs 문제 참고 + 클래스로더

코드타카

[무인도 여행]

DFS
- X가 아니면서, 방문하지 않은 좌표로 dfs 시작
- cur에는 누적으로 더해줄 것임 (숫자로 변환: box[a][b] -'0')
전역변수
- answer의 크기는 정해지지 않아서 List로 선언
- String 배열을 char 배열로 바꿔주기 위한 box
- 방문했는지 여부 visited
- 방향키 dx, dy
- 누적값 cur

ArrayList<Integer> answer = new ArrayList<>();
char[][] box;
boolean[][] visited;
int[] dx = {-1, 1, 0, 0};
int[] dy = {0, 0, -1, 1};
int cur = 0;

DFS

private void dfs(int a, int b) {
    visited[a][b] = true;
    cur += box[a][b] - '0';

    for (int i = 0; i < 4; i++) {
        int na = a + dx[i];
        int nb = b + dy[i];
        if (na >= 0 && na < box.length && nb >= 0 && nb < box[0].length) {
            if (!visited[na][nb] && box[na][nb] != 'X') {
                dfs(na, nb);
            }
        }
    }
}

프로그래머스

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

programmers.co.kr

질문 정리
클래스 로더

질문:
자바 어플리케이션 실행 과정은?

답변:
먼저 javac를 통해 자바 소스 파일(.java) 을 바이트코드(.class) 로 컴파일합니다.

이후 java 명령어를 통해 JVM이 실행되며,
클래스 로더가 클래스를 메모리에 로딩하고,
바이트코드 검증 및 링킹 과정을 거친 후 main 메서드를 포함한 클래스의 static 초기화가 실행됩니다.

마지막으로 JVM은 main() 메서드를 호출하면서 애플리케이션 실행이 시작됩니다.

질문:
클래스 로더 과정은?

답변:
로딩 → 링킹(검증, 준비, 분석) → 초기화
클래스 로딩 과정은 로딩, 링킹, 초기화 세 단계로 구성됩니다.

먼저 .class 파일을 JVM 메모리에 로딩합니다.

이어서 링킹 단계에서 바이트코드의 유효성을 검증하고,
static 변수 메모리를 준비하며 참조를 실제 메모리 주소로 분석합니다.

마지막으로 초기화 단계에서 static 변수들을 명시된 값으로 초기화하고
static 블록이 실행되며 클래스가 본격적으로 동작할 준비를 마칩니다.

질문:
클래스 로더 과정은?

답변:
캐시 → 상위 클래스 → 본인 클래스(하위)
우선 해당 클래스가 이미 로드되어 있는지 캐시를 확인합니다.
그 다음 상위 클래스, 하위 클래스, 본인 클래스 순으로 확인합니다.

아래 사진과 같이 클래스로더는 4가지의 위계 순서가 있습니다.
부트스트랩 → 확장 → 애플리케이션 클래스 로더 순서로 올라가며,
각 단계에서 클래스를 찾을 수 없을 경우 하위 로더가 로딩을 시도합니다.

이를 통해 클래스 중복 로딩을 방지하고 보안성을 높입니다.

출처: 위키백과 클래스 로더

[88] 코딩테스트: 가장 먼 노드 graph 자바 풀이

마트스 — Thu, 3 Apr 2025 09:44:11 +0900

코딩테스트 준비 88일차

오늘 풀 문제는 가장 먼 노드이다.

그래프로 푸는 문제는 초기 세팅은 거의 다 유사한데,

그 이후로 조건에 따로 작성해야 한다.

ArrayList<Integer>[] list = new ArrayList[n+1];

가장 먼 노드

graph
- bfs() 함수에 각 노드까지의 거리를 저장
- 최댓값 거리를 구한 후, 그 거리와 같은 노드의 개수를 세어서 answer++
distance라는 int 배열을 통해 거리를 따로 저장해준다는 생각 필요
- distance의 인덱스가 바로 노드의 값

출처: 프로그래머스 가장 먼 노드 자바 풀이

Graph

1. graph로 저장할 list
2. 방문 visited / 거리 distance
3. bfs를 돌려서 방문하지 않았다면 q에 넣고 → visited 처리 → distance 이전 거리+1

=> 최종적으로 distance에서 max 거리값 찾아서, 같으면 answer++

=> 그래프하면 ArrayList<Integer>[] list

최종 코드

import java.util.*;

class Solution {
    ArrayList<Integer>[] list;
    boolean[] visited;
    int[] distance;
    
    public int solution(int n, int[][] edge) {
        int answer = 0;
        list = new ArrayList[n+1];
        visited = new boolean[n+1];
        distance = new int[n+1];
        
        for(int i=1; i<=n; i++) {
            list[i] = new ArrayList<>();
        }
        
        for(int i=0; i<edge.length; i++) {
            list[edge[i][0]].add(edge[i][1]);
            list[edge[i][1]].add(edge[i][0]);
        }
        
        bfs();
        
        int max = 0;
        for(int i : distance) {
            max = Math.max(max, i);
        }
        
        for(int i: distance) {
            if(i == max) answer++; 
        }
        
        return answer;
    }
    
    private void bfs() {
        Queue<Integer> q = new ArrayDeque<>();
        q.add(1);
        visited[1] = true;
        distance[1] = 0;
        
        while(!q.isEmpty()) {
            int cur = q.poll();
            
            for(int i : list[cur]) {
                if(!visited[i]) {
                    visited[i] = true;
                    q.add(i);
                    distance[i] = distance[cur]+1;
                }
            }
        } 
    }
}

<JAVA TIL18> 게시판 만들기 | 자바 제네릭 질문

마트스 — Wed, 2 Apr 2025 14:24:06 +0900

내일배움캠프 4/2 TIL

<JAVA TIL18> 게시판 만들기 ❘ 자바 제네릭 질문

코드타카

[두 큐 합 같게 만들기]

ArrayDeque 다 똑같
- Queue<Integer> q1 = new LinkedList<>();
- Deque<Integer> q1 = new ArrayDeque<>();
- Queue<Integer> q1 = new ArrayDeque<>();
큐의 길이만큼 3배 돌려줌
- 합의 크기가 작은 쪽에 가장 앞의 숫자를 넘겨줌

while(count <= queue1.length*3) {
    if(s1 > s2) {
        int cur = q1.pop();
        s1 -= cur;
        s2 += cur;
        q2.add(cur);
        count++;
    } else if(s2 > s1) {
        int cur = q2.pop();
        s2 -= cur;
        s1 += cur;
        q1.add(cur);
        count++;
    } else {
        break;
    }
}

질문 정리

JAVA

제네릭 + 레퍼 클래스

질문:
제네릭이란?

답변:
클래스 내부에서 사용할 데이터 타입을
직접 사용할 때 설정하는 것이다.

내가 원하는 타입으로 만들어서 클래스를 사용할 수 있다!

※ 자료형은 기본형과 참조형이 있다.

질문:
wrapper 클래스란?

답변:
기본형을 객체로 다뤄야할 때가 있는데, 이때 사용된다.
(primary → reference / 감싸서 Object로 사용하기 위함)

2가지의 특징이 있다.
1. == 연산이 불가하다. → reference는 참조 주소를 비교하기 때문
2. Immutable으로 변경 불가하다. → 기존값 변경이 아닌 새로운 값이 활당됨

질문:
String 클래스란?

답변:
String 클래스 reference다.
== 연산이 불가할까 싶지만 가능하다.

리터럴로 생성하면, Heap 안의 String Pool에 저장해서 비교할 수 있다.
근데 new String으로 생성하면 Heap에 새로 생성하기에 == 연산자로 비교할 수 없다.