나 JAVA 봐라

[백준] 1987번 알파벳 (비트마스크로 풀기)

cool_code — Thu, 24 Apr 2025 18:07:28 +0900

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

문제는 그냥 평범한 dfs 문제임,, 그치만 메모리랑 시간이 오바라서 개선을 좀 해봤음

메모리 사용량이나 시간이나 많이 개선 되었음.

핵심은 비트 마스킹!!

원래 작성했던 코드이다.

문제에서는 이동했던 알파벳으로는 이동이 불가하다. 즉, 이동했던 경로에 있던 알파벳을 계속 기억하고 있어야한다.

이를 위해 해시셋을 사용하여서 거쳐왔던 알파벳 정보를 저장했다.

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

public class Main {

    public static int r,c;
    public static HashSet<Character> hs = new HashSet<>();
    public static char map[][];
    public static int dx[]= {0,0,-1,1};
    public static int dy[]= {-1,1,0,0};
    public static int max = 0;

    public static boolean inRange(int x, int y){
        return x >= 0 && y >= 0 && x < r && y <c;
    }

    public static void dfs(int x, int y, int depth){
        boolean moved = false;
        // 상하좌우 탐색 & 재귀
        for (int i = 0; i < 4; i++){
            int nx = x + dx[i];
            int ny = y + dy[i];

            if (inRange(nx,ny) && !hs.contains(map[nx][ny])){// 이동 가능하다면
                moved = true;
                hs.add(map[nx][ny]);
                dfs(nx,ny,depth+1);
                hs.remove(map[nx][ny]);
            }

            if(!moved){ // 더 이상 이동 불가한 경우, 해당 경로까지의 값을 기준으로 최댓값 업데이트
                max = Math.max(max, depth);
            }
        }

    }


    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());
        map = new char[r][c];

        for (int i = 0; i < r; i++){
            String str = br.readLine();
            for (int j = 0; j < c; j++){
                map[i][j] = str.charAt(j);
            }
        }

        hs.add(map[0][0]);
        dfs(0,0,1); // 상하좌우 탐색 시작.

        System.out.println(max);
    }
}

내 코드의 문제?

1. 해시셋의 경우 이론상 시간복잡도는 O(1)이다.

하지만 실제로는 해시값을 계산하는 시간 + 충돌 시 해결 시간(체이닝 or 리해싱) 등의 시간도 소요된다.

2. 또한 해시셋은 원시타입(primitive) 사용이 불가하다. 따라서 해시셋은 Character인 wrapper타입을 사용한다.

내 코드 상에서는 map에 있는 값은 char (원시타입), 해시셋에 알파벳을 add할 때에는 Character를 사용하므로 '오토박싱' 작업이 추가로 들어가서 그만큼의 시간도 소요된다.

3. 또한 메모리 관점에서도, 해시셋은 GC가 많이 발생한다.

해시셋은 배열 + 리스트/트리로 구성된다. (기존에는 배열이지만, 충돌 발생 시에 리스트/트리 사용함)

이런 구조에서 remove가 발생하면, 그만큼 GC로 삭제할 내용도 많아진다.

만약 DFS가 수천, 수만번,,, 그 이상으로 많이 수행되면 될수록 GC 실행될 것들이 많아지게 되고, 결국에는 메모리 정리를 위해 쓰레드가 잠시 멈출 수도 있다... -> 비효율!

반면 비트 마스킹은 int 하나로 상태 관리하고, 추가/삭제 등의 연산이 필요 없기에 메모리에 영향 주지도 않는다!!

수정한 코드)

import java.io.*;

public class Main {

    static int r, c, max = 0;
    static char[][] map;
    static int[] dx = {0, 0, -1, 1};
    static int[] dy = {-1, 1, 0, 0};

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

        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) {
                int ch = map[nx][ny] - 'A';
                if ((visited & (1 << ch)) == 0) {  // 방문하지 않은 알파벳이면
                    dfs(nx, ny, depth + 1, visited | (1 << ch));
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] rc = br.readLine().split(" ");
        r = Integer.parseInt(rc[0]);
        c = Integer.parseInt(rc[1]);

        map = new char[r][c];
        for (int i = 0; i < r; i++) {
            String line = br.readLine();
            for (int j = 0; j < c; j++) {
                map[i][j] = line.charAt(j);
            }
        }

        int firstCharBit = 1 << (map[0][0] - 'A');
        dfs(0, 0, 1, firstCharBit);

        System.out.println(max);
    }
}

비트 마스크 연산이 헷갈려서 GPT한테도 물어봤더니, 아래와 같은 답변을 줬다. 블로그에 나와있는 설명글보다 이 내용이 더 이해가 잘되어서 첨부함!

전제: 알파벳을 비트로 관리하자!

알파벳 A ~ Z 는 26개 → 비트 26개로 관리 가능
char - 'A' 를 하면 A는 0, B는 1, ..., Z는 25로 매핑됨
int는 32비트니까 충분히 26개 알파벳 상태를 표현 가능!

예제 코드 해설

코드 1

int visited = 0; // 아무 알파벳도 방문 안 함

visited는 현재 방문한 알파벳을 나타내는 비트마스크입니다.
초기값 0은 모든 비트가 꺼져 있음 = 아무것도 방문 안 한 상태

visited = 00000000 00000000 00000000 00000000

코드 2

visited |= (1 << 2);  // visited = 00000100

'C' - 'A' = 2 → C는 2번째 알파벳 (비트 위치 2번)
1 << 2 는 아래와 같이 2번째 비트만 켜진 값을 만듭니다:

1 = 00000000 00000000 00000000 00000001
1 << 2 = 00000000 00000000 00000000 00000100

visited |= (1 << 2) 는 visited의 2번째 비트를 켜는 연산입니다:

기존 visited: 00000000 00000000 00000000 00000000
(1 << 2)     : 00000000 00000000 00000000 00000100
-----------------------------------------------
결과 visited : 00000000 00000000 00000000 00000100  ✅

이제 visited는 "C"가 방문된 상태를 나타내요.

코드 3

if ((visited & (1 << 2)) != 0)

이건 2번 비트가 켜져 있는지 확인하는 조건입니다.
& 연산은 둘 다 1일 때만 1이 되는 논리곱이므로:

visited     : 00000000 00000000 00000000 00000100
(1 << 2)    : 00000000 00000000 00000000 00000100
& 결과     : 00000000 00000000 00000000 00000100 → 0이 아님

따라서 "C"는 이미 방문한 상태가 됩니다.

코드 4

visited &= ~(1 << 2); // visited = 00000000

이건 "C" 방문 해제, 즉 2번 비트를 끄는 연산입니다.

먼저 (1 << 2)로 2번 비트가 켜진 값을 만들고:

(1 << 2)  = 00000000 00000000 00000000 00000100

~(비트 NOT)를 하면:

~(1 << 2) = 11111111 11111111 11111111 11111011

그걸 &=로 적용하면:

visited    : 00000000 00000000 00000000 00000100
~(1<<2)    : 11111111 11111111 11111111 11111011
-----------------------------------------------
결과       : 00000000 00000000 00000000 00000000

이렇게 해서 "C"는 다시 방문 안 한 상태로 되돌아갑니다.

요약 정리

동작 코드 의미

방문 표시	`visited	= (1 << ch)`
방문 확인	(visited & (1 << ch)) != 0	ch번째 비트가 켜져 있는지 확인
방문 해제	visited &= ~(1 << ch)	ch번째 비트를 끈다

기억 팁!

|= → 켜기
& → 확인
&= ~ → 끄기
1 << ch → ch번째 비트를 "1"로 만든다.

[코드트리] 상한 귤

cool_code — Mon, 7 Apr 2025 17:16:35 +0900

https://www.codetree.ai/ko/trails/personalized/curated-cards/test-oranges-have-gone-bad/description

Codetree: Master Coding Interviews - Data Structures & Algorithms

Master algorithms, ace tech interviews, and elevate your coding skills with Codetree's systematic curriculum and expert-crafted problem sets.

www.codetree.ai

BFS 문제긴 한데, 시간을 고려해야하는 조건이 추가되어서 살짝 고민함.

처음에 for문으로 0초 ~ 끝까지 반복하면서 BFS 돌려야하나? 생각했는데... 멍청한 생각이었음

그냥 Pair 클래스 변수에 time 정보도 넣으면 쉽게 해결될 문제였음

BFS 자체가 Queue 사용하니까, 시간 순서대로 알아서 처리해줌

import java.util.*;

class Pair{
    int x,y,time;
    public Pair(int x, int y, int time){
        this.x = x;
        this.y = y;
        this.time = time;
    }
}

public class Main {

    static int n,k;
    static int grid[][];
    static int result[][];
    static boolean visit[][];
    static Queue<Pair> q = new LinkedList<>();
    static int dx[] = {0,0,-1,1};
    static int dy[] = {-1,1,0,0};

    public static boolean inRange(int x, int y){
        return x >= 0 && x < n && y >= 0 && y < n;
    }

    public static void bfs(){
        while(!q.isEmpty()){
            Pair p = q.poll();

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

                if (inRange(nx,ny) && !visit[nx][ny] && (grid[nx][ny] == 1)){
                    result[nx][ny] = p.time+1; 
                    visit[nx][ny] = true;
                    q.add(new Pair(nx,ny,p.time+1));
                }
            }
        }

    }

    public static void main(String[] args) {

        // 1. 변수 초기화 과정
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        k = sc.nextInt();
        grid = new int[n][n];
        result = new int[n][n];
        visit = new boolean[n][n];

        for (int i = 0; i < n; i++){
            for (int j = 0; j < n; j++){
                int value = sc.nextInt();
                grid[i][j] = value;
                if(value == 0){
                    visit[i][j] = true;
                    result[i][j] = -1;
                }
                else if(value == 2){
                    q.add(new Pair(i,j,0));
                    visit[i][j] = true; //result는 초기화되면 자동으로 0이니까 안해도 ㅇㅋ
                }
            }
        }

        // 2. 탐색 시작
        bfs();

        // 3. 예외 처리 (끝까지 상하지 않는 귤)
        for (int i = 0; i < n; i++){
            for (int j = 0; j < n; j++){
                if (!visit[i][j]) {
                    result[i][j] = -2;
                }
            }
        }

        for (int i = 0; i < n; i++){
            for (int j =0; j < n; j++){
                System.out.print(result[i][j] + " ");
            }
            System.out.println();
        }


            
    }
}

[코드트리] 마을 구분하기 문제

cool_code — Fri, 28 Feb 2025 22:53:58 +0900

카테고리는 DFS로 분류 되긴 했지만, DFS/BFS 둘다 가능할 것 같아서 두 방식으로 모두 풀어봤다.

https://www.codetree.ai/trails/complete/curated-cards/challenge-seperate-village/description?page=1&page_size=20

Code Tree | Learning to Code with Confidence

A super-comprehensive, meticulously arranged Coding Learning Curriculum engineered by Algorithm Experts composed of former International Olympiad in Informatics (IOI) medalists.

www.codetree.ai

DFS

// BFS, DFS 두 방식을 고민했음... -> 두 가지 다 풀어봐야겠다. 

import java.util.*;

public class Main {
    public static int n,people_cnt;
    public static int dx[] = {0,1,0,-1};
    public static int dy[] = {1,0,-1,0};
    public static int grid[][];
    public static boolean visit[][];

    public static ArrayList<Integer> cnt_list = new ArrayList<>();

    public static boolean inRange(int x, int y){
        return x >= 0 && x < n && y >= 0 && y <n;
    }

    public static boolean canGo(int x, int y){
        return inRange(x,y) && !visit[x][y] && (grid[x][y]==1);
    }

    public static void dfs(int x, int y){

        // 상하좌우 탐색하기
        for (int i =0; i < 4; i++){
            int nx = x + dx[i];
            int ny = y + dy[i];

            if (canGo(nx,ny)){
                people_cnt++;
                visit[nx][ny] = true;
                dfs(nx,ny);
            }
        }

    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        grid = new int[n][n];
        visit = new boolean[n][n];

        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                grid[i][j] = sc.nextInt();
                
        
        for (int i = 0; i < n; i++){
            for (int j = 0; j < n; j++){
                if (canGo(i,j)){
                    visit[i][j] = true;
                    people_cnt = 1;
                    dfs(i,j);
                    cnt_list.add(people_cnt);
                }
            }
        }

        Collections.sort(cnt_list);

        System.out.println(cnt_list.size());
        for (Integer value : cnt_list){
            System.out.println(value);
        }
    }
}

BFS

import java.util.*;

public class Main {
    public static int n, people_cnt;
    public static int dx[] = {0, 1, 0, -1};
    public static int dy[] = {1, 0, -1, 0};
    public static int grid[][];
    public static boolean visit[][];

    public static ArrayList<Integer> cnt_list = new ArrayList<>();

    public static boolean inRange(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < n;
    }

    public static boolean canGo(int x, int y) {
        return inRange(x, y) && !visit[x][y] && (grid[x][y] == 1);
    }

    public static void bfs(int x, int y) {
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{x, y});
        visit[x][y] = true;
        people_cnt = 1;

        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            int curX = current[0], curY = current[1];

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

                if (canGo(nx, ny)) {
                    queue.add(new int[]{nx, ny});
                    visit[nx][ny] = true;
                    people_cnt++;
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        grid = new int[n][n];
        visit = new boolean[n][n];

        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                grid[i][j] = sc.nextInt();

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (canGo(i, j)) {
                    bfs(i, j);
                    cnt_list.add(people_cnt);
                }
            }
        }

        Collections.sort(cnt_list);

        System.out.println(cnt_list.size());
        for (Integer value : cnt_list) {
            System.out.println(value);
        }
    }
}

[프로그래머스] 튜플

cool_code — Wed, 28 Aug 2024 15:33:51 +0900

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

프로그래머스

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

programmers.co.kr

문제 이해하는데 한참 걸림;;; ....

내가 생각한 풀이 순서는 아래와 같다.

1. String s를 substring, split 등을 통해 변환하여 ArrayList<int[]> 에 넣기

2. 변환한 list를 int[] 배열 크기 순서대로 정렬하기

3. 순서대로 수를 담아서 출력하기

이중 for문도 많고 코드 자체도 많이 더럽지만 일단 통과는 했다...

import java.util.*;

class Solution {
    public int[] solution(String s) {
        // 원소 하나만 있으면 0번째 인덱스 원소
        // 그 다음에 붙어있으면 다음 인덱스 원소.. -> 중복 x
        
        // 1. String 잘라서 ArrayList<int[]> 에 넣기
        String sub_s = s.substring(2,s.length()-2);
        String str[] = sub_s.split("\\},\\{"); // 중괄호는 이스케이프 두번 써줘야함... 
        
        ArrayList<int[]> list = new ArrayList<>();
        
        for (int i = 0; i < str.length; i++){
            String before_str[] = str[i].split(","); 
            int aft_str[] = new int[before_str.length];
            for(int j = 0; j < before_str.length; j++){
                aft_str[j] = Integer.parseInt(before_str[j]);
            }
            list.add(aft_str);
        }
        
        // int[]의 크기 순서대로 정렬하기
        Collections.sort(list,(x,y)-> x.length - y.length);
        
        int[] answer = new int[list.size()];
        HashSet<Integer> hs = new HashSet<>();
        
        for (int i = 0; i < list.size(); i++){
            int value[] = list.get(i);
            for (int val : value){
                if (!hs.contains(val)){
                    answer[i] = val;
                    hs.add(val);
                    break;
                }
            }
        }
        
        return answer;
    }
}

[프로그래머스] 큰 수 만들기

cool_code — Wed, 14 Aug 2024 17:58:51 +0900

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

프로그래머스

programmers.co.kr

최대한 탐색을 적게 하기 위해, 탐색 범위를 좁히는 과정을 거친 후에, dfs 탐색을 했다.

근데 테스트케이스는 통과하지만 , 제출 시에 대부분의 케이스에서 런타임 에러가 발생했다.

아래가 기존에 작성한 코드이다.

+) -> 바본가보다.. 굳이 dfs 탐색 안해도 될 문제였다. 첫번째 시작에서 탐색 범위 줄인 것처럼, 계속 탐색 범위 줄여가면서 탐색하면 된다... ^^

import java.util.*;

class Solution {
    
    static int min_length;
    static int max_num = 0;
    public String solution(String number, int k) {
        
        min_length = number.length()-k;
        
        // number.length() - min_length 까지의 인덱스에 접근해서 가장 큰 수 구하기 (-> 탐색 범위 좁히기 위함)
        int index = number.length() - min_length;
        int max_value = 0;
        
        // 탐색 범위 좁히기 (앞자리 수가 가장 커야하니까 가장 큰 수 뽑기)
        for (int i = 0; i < index+1; i++){
            int first = number.charAt(i) - '0';
            max_value = Math.max(max_value, first);
        }
        
        // 앞자리 수가 가장 크면 dfs 탐색 시작하기
        for (int i = 0; i < index+1; i++){
            int first = number.charAt(i) - '0';
            if (first != max_value) continue;
            
            char arr[] = new char[min_length];
            arr[0] = number.charAt(i);
            
            boolean visited[] = new boolean[number.substring(i).length()];
            visited[0] = true; 
            dfs(number.substring(i), 1, 1, arr, visited);
        }
        
        return Integer.toString(max_num);
    }
    
    
    static public void dfs(String number, int depth, int index, char[] arr, boolean[] visited){
        
        if (depth == min_length){
            String return_str = "";
            for (char s: arr){
                return_str +=s;
            }
            
            max_num = Math.max(max_num, Integer.parseInt(return_str));
            return;
        }
        
        for (int i = index; i < number.length(); i++){
            if (!visited[i]){
                arr[depth] = number.charAt(i);
                visited[i] = true;
                dfs(number, depth+1, i+1, arr, visited);
                visited[i] = false;
            }
        }
        
    }
}

그래서 다른 풀이를 참고해서 다시 풀었다... ^^

이 마저도 인덱스 설정하는거 헷갈려서 인덱스 초과 에러 남. 수에서 규칙 찾는 문제가 난 아직도 어렵다.

해결책은 위에서 제시한 해결책과 동일하다.

계속 인덱스 범위를 조절해나가며 제일 큰 수를 찾아 sb.append 해준다.

탐색할 때 시작하는 인덱스 : 제일 처음은 0이고, 이 후에는 이전에 선택된 인덱스 + 1
탐색할 때 마지막 인덱스 : i+k (코드 참고)

그리고, 풀었음에도 계속 10번에서 시간초과가 났다.

원래 코드에서는 숫자 크기를 비교할 때 charAt(j) -'0' 으로 해서 int로 변환해준 후에 수 비교를 했는데, 연산횟수가 더 늘어나다보니 초과가 난 것이다. (사소한 연산이라고 생각했는데, 시간초과 나는 테스트케이스를 만들다니,,,)

=> 해서 char 형으로 서로 크기 비교를 하도록 했다. 연산 횟수도 더 줄어들었고 테케를 다 통과할 수 있었다!

오늘의 교훈 : 사소한 연산이라도 줄이자... !

class Solution {
    public String solution(String number, int k) {
 
        int pick_len = number.length() - k;
        StringBuilder sb = new StringBuilder();
        
        int start = 0;
        
        for (int i = 0; i < pick_len; i++){
            char max = '0';
            for (int j = start; j <= i+k; j++){
                if (max < number.charAt(j)){
                    max = number.charAt(j);
                    start = j+1;
                }
            }
            sb.append(max);
        }
        
        return sb.toString();
    }
}

Reference

https://jhhj424.tistory.com/32

[알고리즘] 프로그래머스 큰 수 만들기(Level 2) [자바/JAVA] 풀이- 개발하는 지토

문제 설명 어떤 숫자에서 k개의 수를 제거했을 때 얻을 수 있는 가장 큰 숫자를 구하려 합니다. 예를 들어, 숫자 1924에서 수 두 개를 제거하면 [19, 12, 14, 92, 94, 24] 를 만들 수 있습니다. 이 중 가장

jhhj424.tistory.com

[프로그래머스] 삼각달팽이

cool_code — Tue, 13 Aug 2024 11:29:33 +0900

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

프로그래머스

programmers.co.kr

문제를 보고, 삼각형을 왼쪽으로 다 밀어버린 후에 배열로 접근하면 되겠다는 생각까지는 했다.

하지만 이를 어떻게 삼각형으로 돌아서 탐색해야하나? 어떻게 구현해야하나? 를 두고 헤맴...

아래 링크에 있는 방법이, 나랑 접근 방식이 비슷해서 코드를 참고했다. 구현 코드를 이해하는데 한참 걸렸지만, 배열을 삼각형으로 뱅글뱅글 탐색을 어떻게 하는지 이해했다. 이를 응용하면 삼각형 뿐 아니라 사각형도 뱅글뱅글 탐색할 수 있을 것 같다..

https://minhamina.tistory.com/58

[프로그래머스 - Java] 삼각 달팽이(월간 코드 챌린지 시즌1)

문제 programmers.co.kr/learn/courses/30/lessons/68645 코딩테스트 연습 - 삼각 달팽이 5 [1,2,12,3,13,11,4,14,15,10,5,6,7,8,9] 6 [1,2,15,3,16,14,4,17,21,13,5,18,19,20,12,6,7,8,9,10,11] programmers.co.kr 설명 * Jungol 1337 달팽이 삼각형

minhamina.tistory.com

class Solution {
    public int[] solution(int n) {
        
        int map[][]= new int[n][n];
        int result[] = new int[n*(n+1)/2];
        
        int x = -1;
        int y = 0;
        int num = 1;
        
        for (int i = 0; i < n; i++){
            for (int j = i; j < n; j++){
                if (i % 3 == 0){
                    x++;
                }
                else if(i % 3 == 1){
                    y++;
                }
                else if(i % 3 == 2){
                    x--;
                    y--;
                }
                
                map[x][y] = num;
                num++;
            }
        }
        
        int index = 0;
        for (int i = 0; i < n; i++){
            for (int j = 0; j < i+1; j++){
                result[index] = map[i][j];
                index++;
            }
        }
        return result;
    }
}

2024년 1차 KDB 산업은행 청년인턴 IT 최종 합격 후기(서류, 면접)

cool_code — Thu, 1 Aug 2024 15:45:08 +0900

안녕하세요,

저는 지금 산업은행 IT 인턴으로 2개월 째 일하고 있습니다.

2024년 2차 청년인턴 공고가 올라온 것을 보고,

청년 인턴을 준비하며 다른 분야 후기는 많은데 IT 후기는 많이 없어 조금이나마 공유하고자 글을 작성하게 되었습니다 !

서류

학교, 학점, 수상, 자격증, 어학 성적 등을 기입하는 칸이 없었습니다. 대신 한국사 2급 합격했는지는 물어보는데, 저도 그렇고 지금 같이 일하는 인턴들 대부분 한국사는 없습니다. (한국사 자격증 유무가 크게 중요하지 않은 것 같습니다.)

교내외활동은 총 4개 기입했고,

교육사항도 IT 전공수업 10개 꽉꽉 채워서 기입했습니다.

추가로 문항 1번은 수기로 작성해야하니, 마감 직전에 급하게 쓰시지 말고 미리미리 깔끔하게 쓰시는 것을 추천 드립니다!

면접

몇년 전의 청년인턴 면접 후기를 보면, 대면으로 진행했다는 후기가 많았는데, 최근에는 비대면 면접만 진행하는 듯 합니다. 저 역시도 비대면 면접이었습니다 !

제가 받은 질문 입니다.

공통질문

자기소개
1. 가끔 후기에 30초 자기소개라고 되어있는데, 제가 본 면접팀은 시간 제한이 없었습니다.
학생인권조례 폐지에 대한 견해
1. 사회 이슈에 대해 묻는다고 해서, 제 나름대로 사회 이슈를 많이 정리했지만 에상치 못한 주제였습니다.. 하지만 해당 이슈를 모르더라도, 최대한 논리정연하게 잘 말할 수 있는지를 보는 질문이라고 생각합니다! 첫번째 순서가 아니라면, 최대한 앞에 사람들이 뭐라고 하는지 참고해서 답할 수 있다고 있다고 생각합니다. 참고로 사회 이슈에 대해 묻지 않은 팀도 있다고 합니다.
협업하면서 제일 맞지 않는 사람은 어떤 사람이며, 어떻게 해결했는지?
나의 직무상 강점은?
업무를 하며 부족하다고 생각했던 역량과 이를 해결하기 위한 노력?
ai 관련 키워드 여러개 제시한 후 이 중 하나 택해서 설명
1. IT인턴이지만, 공통질문은 AI였습니다. 키워드 자체는 정말 기본적인 키워드이니, it시더라도 기본적인 ai 지식은 알고 가셔야할 것 같습니다.
마지막으로 하고 싶은 말

개인질문

자기소개서 기반으로 특정 기술에 대한 질문을 했습니다.

경험에 대한 질문이 아닌, 자소서에 나와있는 특정 키워드를 보고 해당 기술에 대해 설명해 달라고 하셨는데, 저는 기술도 아니고 개발방법론에 대한 질문이 뜬금없이(?) 나와서 제대로 답은 못했던 기억이 납니다,,, (그래도 붙었으니 다행...)

그리고 다른 면접 후기에서도 많이 나와있지만, 말을 길고 장황하게 안하는 것이 중요한 것 같습니다.

제가 면접 봤을 때도 다른 분이 자기소개 때부터 말을 너무 길게 하셔서 면접관 님께서 중간에 끊으시거나, 끝까지 듣고 이해를 못하신건지 다시 물어보셨습니다.

저는 최대한 요점만 간결하게 말하려고 했고, 실제 붙은 인턴들과 후기를 나눠보면 다들 간결하게 말한 것 같습니다!

합 격 !

모두 좋은 소식 있으시길 바랍니다 :)

[프로그래머스] 여행경로

cool_code — Wed, 17 Jul 2024 13:37:34 +0900

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

언제인지 모를, 기존에 짜둔 코드. -> 테케 1번 통과 못함.

import java.util.*;

class Solution {
    
    public static boolean visit[];
    public static ArrayList <String> list; 
    public static ArrayList <String> result;
    
    public String[] solution(String[][] tickets) {
        // 일단 ICN부터 시작하기 -> ICN 2개 이상이면 각자 탐색 ㄱㄱ
        // 더 이상 방문할 수 있는 도시가 없다면 끝
        // ticket의 개수만큼 모두 돌았다면 = 모두 visit 했다면 -> return에 담기
        // 가능한 경로가 2개 이상이면 알파벳 순으로 비교해서 return에 담기. 
        
        visit = new boolean[tickets.length];
        list = new ArrayList<>(); // dfs에 경로 탐색하며 문자열 담을 때 사용. 
        result = new ArrayList<>(); // 경로 끝까지 탐색했을 때 모든 경로 담기 위해 사용
        ArrayList <String> finale = new ArrayList<>(); // 최종 리턴할 리스트
        
        // ICN이 있는 모든 배열을 찾아서 DFS 시작점으로 돌리기 
        for (int i =0; i<tickets.length; i++){
            if(tickets[i][0].equals("ICN")){
                dfs(tickets, i, visit, list, result); // 값 비교 해서 알파벳 비교해서 담기
                if (finale.isEmpty()){
                    finale.addAll(result); 
                }
                else{
                    for (int k =0; k< result.size(); k++){
                        int compare = result.get(k).compareTo(finale.get(k));
                        if (compare == 0) continue;
                        else if (compare > 0) break; // finale가 사전순으로 앞섬 
                        else { 
                            finale.clear();
                            finale.addAll(result);
                        }
                    }
                }
                list.clear();
                result.clear();
                visit = new boolean[tickets.length]; //다시 초기화
            }
        }
        
        String[] answer = new String[finale.size()];
        finale.toArray(answer);        
        
        return answer;
    }
    
    // class 밑단에서 바로 선언된 변수들은 dfs 파라미터에 담을 필요가 있나? 
    
    public void dfs(String[][] tickets, int cur, boolean[] visit, ArrayList<String> list, ArrayList<String> result){
        list.add(tickets[cur][0]); //list add
        visit[cur] = true; // 방문 표시
        
        int count = 0;
        for (int j = 0; j<tickets.length; j++){
            if (visit[j]==true) count++; //방문한 곳 count
        }
        if (count == tickets.length) {
            // 끝까지 경로를 탐색했다면, 탐색한 경로끼리 비교하여서 알파벳 앞서는 경로를 담아야함.
            // 일단 첫번째로 탐색된 경로를 담을 변수 필요. 
            list.add(tickets[cur][1]);// 마지막 경로도 담아주기. 
            if (result.isEmpty()){ // 첫번째로 끝까지 탐색된 경로라면
                result.addAll(list);
            }
            else { // 알파벳 비교하기
                for (int i =0; i< result.size();i++){
                    int compare = result.get(i).compareTo(list.get(i));
                    if (compare == 0) continue;
                    else if (compare > 0){ // list가 사전순으로 앞섬 
                        result.clear();
                        result.addAll(list);
                    } 
                    else break;
                }
            }
        }
        
        for(int j =0; j<tickets.length; j++){
            if (tickets[cur][1].equals(tickets[j][0]) && !visit[j]){
                dfs(tickets, j, visit, list, result); // 값 비교 해서 알파벳 비교해서 담기
                visit[j] = false;
            }
        }
    }
}

여튼, 위에 코드 써둔거 안읽고, 다시 풀어봤는데 이번엔 맞음. 위에선 멀 간과했을까..

풀이 방식은

1. tickets 배열을 탐색하면서. 티켓이 "ICN"으로 출발하는 티켓이면 DFS 탐색을 한다.

2. 탐색하면서 찾은 경로는 다 ArrayList 배열에 add 한다.

3. 탐색 끝났을 때, 찾은 경로가 2개 이상이면 알파벳 비교해서 앞선 알파벳 배열로 return 한다.

import java.util.*;

class Solution {
    
    static ArrayList<String[]> road = new ArrayList<>();
    
    public String[] solution(String[][] tickets) {
        
        // 만약 티켓이 "ICN"에서 출발하는 티켓이면, DFS 탐색하기
        for (int i = 0; i < tickets.length; i++){
            if (tickets[i][0].equals("ICN")){
                
                // 경로배열의 크기 = ticket크기 - 1
                String[] arr = new String[tickets.length+1];
                arr[0] = tickets[i][0];
                arr[1] = tickets[i][1];
                
                // 방문 체크하기
                boolean visited[] = new boolean[tickets.length];
                visited[i] = true;
                
                    
                // 0,1 인덱스는 이미 담겼으니까 2부터 시작하기. 
                dfs(2, arr, tickets, visited);
            }
        }
        
        
        String[] return_road = road.get(0);
        
        // list 돌아가면서 알파벳 순서 비교하기
        if (road.size() >= 2){
            
            for (int i = 1; i < road.size(); i++){
                String[] compare = road.get(i);
                for (int j = 0; j < return_road.length; j++){
                    // 만약 compare[j]가 return_road[j]보다 앞선다면 업데이트 하기.
                    if (compare[j].compareTo(return_road[j]) < 0){
                        return_road = compare;
                        break;
                    }
                    else if(compare[j].compareTo(return_road[j]) > 0){
                        break;
                    }
                }
            }
        }
        // for (String str : return_road){
        //     System.out.print(str+" ");
        // }
        
        return return_road;
    }
    
    static public void dfs(int depth, String[] arr, String[][] tickets, boolean visited[]){
        
        // 만약 arr에 모든 배열 담겼으면 list에 add
        if (depth == arr.length){
            String[] copy = Arrays.copyOf(arr, arr.length);
            road.add(copy);
            return;
        }
        
        for (int i = 0; i < tickets.length; i++){
            // 아직 방문하지 않았고, 현재 티켓 도착지 = 다음 티켓 출발지 이면 arr에 담고 dfs 탐색
            if (visited[i]) continue;
            
            // 왜 마지막 원소가 안 담길까 .. 
            if (tickets[i][0].equals(arr[depth-1])){
                
                arr[depth] = tickets[i][1];
                visited[i] = true;
                dfs(depth+1, arr, tickets, visited);
                visited[i] = false;
                
            }  
        }
        
        
    }
}

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

cool_code — Mon, 15 Jul 2024 16:38:18 +0900

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

프로그래머스

programmers.co.kr

처음 접근한 방법)

전력망 네트워크가 하나의 트리 형태가 아닌 경우는 입력으로 주어지지 않고,

wires가 정렬되어서 입력되기 때문에,

끊어낼 전선을 제외한 wires의 가장 처음 원소의 송전탑 번호를 해시셋에 담고, 반복문을 통해 wires를 탐색하며 해시셋에 값이 있는 경우에만 해시에 계속 add 한다면, 결국에는 트리가 이어진 송전탑만 해시에 담길 것이라고 생각했다.

근데 제시된 테케는 다 통과했지만, 이 후 제출했더니 정확도 20-30이 나옴. ㅎ; ㅠ

-> 예외 케이스는 뭐가 있을까..

import java.util.*;

class Solution {
    
    public int solution(int n, int[][] wires) {
        
        int min_count = 100;
        
        // 와이어 수만큼 bfs 탐색
        for (int i = 0; i < wires.length; i++){
            // i는 끊어낼 wire다. 
            
            int visit = bfs(wires, i, n);
            // 방문한, 방문 안한 노드 수(끊어낸 두 망의 송전탑 개수)가 작은 걸 save
            
            min_count = Math.min(min_count, visit);
        }
    
        return min_count;
    }
    
    static int bfs(int[][] wires, int i, int n){
        // i를 뺀 wires를 순서대로 탐색하며 해시에 넣기
        
        HashSet<Integer> hs = new HashSet<>();
        
        for (int j = 0; j < wires.length; j++){
            // 처음 탐색할 때, 첫번째 노드의 송전탑 번호를 해시에 넣기
            // default로는 첫번째 노드를 해시에 넣지만 i == 0인 경우에만 두번째 노드를 해시에 넣기
            if (j == 0 && i == 0){
                hs.add(wires[1][0]);
                hs.add(wires[1][1]);
            } else if(j == 0){
                hs.add(wires[j][0]);
                hs.add(wires[j][1]);
            }
            
            // 이 후에는 트리 구조라 이어져 있으므로, 해시에 값이 있다면 나머지 값도 계속 해시에 넣어주기
            if (j == i) continue; // 탐색x
            
            if (hs.contains(wires[j][0]) || hs.contains(wires[j][1])){
                hs.add(wires[j][0]);
                hs.add(wires[j][1]);
            }
        }
        
        // return은 송전탑 개수의 차이(절댓값)이 되도록 한다. 
        int count = hs.size();
        int other = n - count;
        return Math.abs(count - other);
    }
}

다시 푼 방법)

정석으로 풀기 위해 인접리스트를 만들어서 bfs 탐색을 했다.

인접리스트를 만들기 위해 ArrayList 배열을 만들었다. (ArrayList<int[]> 형태는 많이 사용했는데, 반대의 경우는 처음 구현해봐서 헷갈렸다. 에러 안나게 초기화 꼼꼼히 잘 해주기. )

방법은 인접리스트를 만든 후에, wires를 탐색하며, 탐색 원소에 포함된 송전탑 번호들을 인접리스트에서 각자 삭제 해준다. 이렇게 하면 서로의 연결 정보가 사라진다.

이렇게 정보를 지운 후에 bfs 탐색을 하면서 송전탑 개수를 카운트 하면 된다. 이 때 트리 구조이므로 아무 노드나 넣어도 연결된 것들은 알아서 탐색 되므로, 코드에서는 1번 노드만 계속 넣어줬다.

그 이후에 방식은 처음 접근한 방법과 동일하게 최솟값을 계속 비교하면서 업데이트 해줬다.

import java.util.*;

class Solution {
    static ArrayList<Integer>[] graph;
    
    public int solution(int n, int[][] wires) {
        // 인접리스트 만들기
        // wires.length 만큼 돌면서 해당하는 번호는 서로 지워주기
        // 지웠으면 탐색하기 -> 임의 노드부터 시작하면 알아서 탐색된다. 
        // 탐색 cnt 비교해서 최솟값 업데이트 하기 -> return
        
        graph = new ArrayList[n+1]; // 인덱스 == 전선번호 맞추기 위해 n+1로 하기
        
        // 그래프 ArrayList 초기화. 노드 개수만큼 ArrayList 생성
        for (int i = 0; i <= n; i++) {
            graph[i] = new ArrayList<>();
        }
        
        // 인접리스트 업데이트 -> 양반향 간선으로 
        for (int i = 0; i < wires.length; i++){
            int v1 = wires[i][0];
            int v2 = wires[i][1];
            
            // 서로의 정보 담아두기
            graph[v1].add(v2);
            graph[v2].add(v1);
        }
        
        // for (int i = 0; i < graph.length; i++){
        //     System.out.println(graph[i]);
        // }
        
        int min = 1000;
        
        // wires.length 만큼 돌면서 해당하는 번호는 서로 지워주고, 탐색하기
        for (int i = 0; i < wires.length; i++){
            int v1 = wires[i][0];
            int v2 = wires[i][1];
            
            // 그래프 복제 하기
            ArrayList<Integer>[] graphCopy = new ArrayList[graph.length];
            
            for (int j= 0; j < graph.length; j++) {
                graphCopy[j] = new ArrayList<>(graph[j]);
            }
            
            graphCopy[v1].remove(Integer.valueOf(v2));
            graphCopy[v2].remove(Integer.valueOf(v1));
            
            boolean visited[] = new boolean[n+1];
            // start 노드, visited 
            // start 노드는 아무거나 설정해도 어쨌든 트리 구조라 이어져있으니까 상관 x
            int cnt = bfs(visited,graphCopy,n);
            
            min = Math.min(cnt, min);
        }
        
        return min;
    }
    
    static int bfs(boolean[] visited, ArrayList<Integer>[] graphCopy, int n){
        
        int cnt = 1; //노드 1포함
        Queue<Integer> q = new LinkedList<>();
        visited[1] = true;
        q.add(1);
        
        while (!q.isEmpty()){
            int num = q.poll();
            ArrayList<Integer> list = graphCopy[num];
            for (int obj : list){
                if (!visited[obj]){// 방문 안했다면
                    visited[obj] = true;
                    cnt++;
                    q.add(obj);
                }
            }
        }
        
        int other = n - cnt;
        return Math.abs(other - cnt);
    }
}

[프로그래머스] 피로도

cool_code — Mon, 15 Jul 2024 15:12:47 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/87946?language=java

프로그래머스

programmers.co.kr

제한 사항을 보니, 정렬을 하면 풀 수 있을 것 같았지만, 방법이 생각나지 않고, 입력 데이터 사이즈가 크지 않아서 완전 탐색으로 구현했다.

대략적인 구현 순서는 아래와 같다.

1. 탐색할 수 있는 순열을 모두 구하여 list에 담는다. (dungeons.length 만큼)

ex) dungeons.length = 3 이라면, 순열은 총 6개가 나온다. (0,1,2) (0,2,1) (1,0,2) (1,2,0) (2,0,1) (2,1,0)

2. list.size 만큼 반복하여서 방문할 수 있는 던전 수를 count한다.

3. 방문 할 수 있는 만큼 방문 했다면, 방문한 던전 수를 count_list에 add한다.

4. 탐색이 모두 끝났다면 count_list의 최댓값을 return 한다.

여기에서, 1번의 순열을 구하기 위해 dfs를 사용한다.

dfs 이니, depth와 순열을 담을 배열을 파라미터로 설정한다.

또한 주의할 점은, 순열을 구하는 경우는 방문 체크하여 dfs를 끝냈다면, 이 후 다시 방문을 해제해야한다. 그래야 해당 값을 또 담아서 다른 순열을 만들 수 있다! (-> 헷갈리면 만들고 나서 print 계속 찍어보기)

그 다음부터는 조건에 따라, 반복문 돌리면서 count 하면 풀리는 문제였다.

++) 근데 풀이 보니까, 그냥 dfs 내에서 탐색 하면서 한번에 던전 방문해서 count 하는 방법도 있었음. 세상에 천재는 많다... (어쨌든 완탐을 위해서 dfs로 접근하는 방식은 동일함. )

근데 아래 문제 시간 복잡도 장난 아니긴 함...

-> dfs 돌릴 때 가능한 모든 순열을 생성하기 때문에 O(n!)

-> 그 다음 for문에서, 만들어진 순열을 기반으로 반복문 돌리고(외부), 내부에서 각 순열 길이별로 또 반복문 돌리니까 O(n!*n) 임...

결국 시간 복잡도눈 n!*n 이다. ㅎㅎ

import java.util.*;

class Solution {
    static ArrayList<int[]> perm_list = new ArrayList<>();
    static boolean visited[];
    
    public int solution(int k, int[][] dungeons) {
        
        visited = new boolean[dungeons.length]; //dfs 위한 배열
        
        // dfs 탐색
        int[] start_arr = new int[dungeons.length];
        dfs(0,start_arr);
        
        // 방문 수 담을 list
        ArrayList<Integer> count_list = new ArrayList<>();
        
        // list 사이즈만큼 던전 탐색하면서 던전 최대 방문 수 count 하기
        for (int[] perm : perm_list){ // 예시 perm = {0,1,2} 
            
            int copy_k = k;
            int visit_count = 0; // 가장 많이 방문한 던전 수 
            
            for (int i = 0; i < perm.length; i++) { // 예시 perm[0] = 0;
                // 만약 최소 필요 피로도(= dungeons[num][0]) > k 라면 list에 count 담고 탐색 끝내기
                // 탐색 가능하다면 1. k - 소모피로도(=dungeons[num][1]) 해주기
                // 만약 마지막 원소 탐색이고, k가 0이상이면 count에 담기. 
                int num = perm[i];
                
                if (dungeons[num][0] > copy_k) {
                    count_list.add(visit_count);
                    break;
                }
                
                // 방문 가능해서 방문 했다면
                copy_k -= dungeons[num][1];
                visit_count++;
                
                // 만약 마지막 원소 탐색이었다면 (Q. 탐색 끝난 후에 copy_k가 음수이면 안되나?)
                if (i == perm.length-1 && copy_k >= 0) count_list.add(visit_count);
            }
        }
        
        Collections.sort(count_list);
        return count_list.get(count_list.size()-1);
    }
    
    static void dfs(int depth, int[] arr){ //완전 탐색 위한 permutation 구하기
        
        if (depth == visited.length){
            //arr 배열 복사 후에 list에 담기
            // return
            int copy_arr[] = Arrays.copyOf(arr, visited.length);
            perm_list.add(copy_arr);
            return;
        }
        
        for (int i = 0; i < visited.length; i++){
            // 방문하지 않았다면 방문표시, int[depth]에 i 업데이트, dfs 탐색하기
            if (!visited[i]){
                visited[i] = true;
                arr[depth] = i;
                dfs(depth+1, arr);
                visited[i] = false; // 방문해제 해야 다른 순열 담을 수 있음!
            }
        }
    }
}