정신없는 신입사원 적응기 1주일을 보냈습니다. 

할일은 크게 없었지만, 새로운 곳의 적응은 즐겁고도 긴장되기도 했습니다. 

그동안 취업준비를 하면서 느꼈던 것들을 

지금 취업을 준비하시는 분들께 도움이 되고자 이렇게 글을 작성하고자 합니다. 

저는 목표로 했던 결과를 얻었습니다. 비록, 개개인마다 목표가 다르겠지만 제가 했던 것들이 조금이나마 도움이 되었으면 합니다. 

 

<취업 준비 시간을 보내면서 : 서론> 

 저는 대학교때, 대학원가기전, 대학원 재학중에도 항상 면접을 봤습니다. 회사를 가지 못하는 상황에서도 지원을 했었는데, 이유는 간단합니다. '경험'을 쌓기 위해서 입니다. 다양한 기업의 면접과 시험을 보면서 경험을 쌓았고 항상 부족한 점을 보완하고자 노력했습니다. 힘든 순간도 많았지만, 그것을 극복하면서 지금의 결과를 만들어낸것 같습니다. 회사를 다니시는 분들에게는 보잘것 없는 이야기가 될 수 있습니다. 하지만 취업을 준비하는 취준생들의 심정을 알기에 조금이나마 도움이 되고자 글을 적습니다. (어떤 회사의 면접을 봤고와 같은 내용은 생략하겠습니다) 한가지 당부드릴 것은 저는 대학원을 다녔지만 '석사'라는 것이 크게 취업에 엄청난 도움이 되지 않는다는 것을 말씀드리고 싶습니다. 

<본론>

1. 목표를 확실히 해라 

목표를 확실히 하고 준비를 해야 내가 어떻게 방향성을 잡고 가야하는지에 대한 계획이 세워집니다. 이러한 계획을 바탕으로 앞으로 나아가는 것이야 말로 원하는 목표를 성취하는 방법입니다.

대학교 4학년 2학기에 우리가 다 알고 있는 은행의 최종면접을 본적이 있습니다. 당시에 프로젝트 및 코딩교육이 한창인지라, 준비를 제대로 하지 못하고 봤던 아쉬운 기억이었습니다. 졸업 프로젝트 및 코딩 교육이 끝나고 취업을 준비했습니다. 당시에는 단순히 어디선가 들어본 기업이라면 다 지원했습니다. 한 40군데 정도 지원한 것으로 기억에 남습니다. 그 당시에도 2군데 최종면접을 갔지만, 아쉽게 낙방했습니다. 여러 기업을 지원했고 많은 면접을 봤으며 시험도 많이 봤습니다. 프리랜서같은 일도 해봤구요, 다만 과정속에서 많은 부족함을 느꼈습니다. 그러면서 어떻게 목표를 잡아야하는지에 대한 생각을 많이 했으며 그동안 고민했던 대학원에 진학하여 전문성을 얻고자 했습니다. 대학원에 다니면서 내가 가고자 하는 길을 결정했고, 그것에 맞춰 많은 공부를 했으며 여유시간에도 발전하기 위해 노력했습니다. 대학원을 다니면서도 최종 면접을 갔었고, 계속 보완점을 찾았습니다. 가장 큰 목표는 했던 연구를 지속할 수 있는 것이었고, 그 다음은 네트워크 분야의 일을 계속 하는 것이었습니다. 

연구실을 나오면서 이력서를 넣기 시작했고 가고자 하는 기업 몇곳을 선정하여 지원했습니다. 그리고 JD를 보면서 계속 보완했습니다. 그렇게 하면서 자신감도 얻었고 면접에서도 좋은 결과들을 얻었습니다. 

확실히 이제서 느끼는 것은 처음과 달리 확실한 '목표'를 잡고 준비했던것이 큰 도움이 되었습니다. 글을 읽는 여러분도 자기가 무엇을 할지 확실히 목표를 잡고 계획을 세워 앞으로 나아갔으면 합니다. 

 

2. 경험을 얻어라 

선배나 취업 강사들의 말을 들어보면 항상 면접을 보는것만으로 도움이 된다 합니다. 저 또한 이것에 동의합니다. 아무리 말을 잘하는 사람이라도 경험해보지 못한 순간에 실수를 할 수 있으니깐요. 저는 동아리를 하면서 무대에도 많이 서봤고, 축구부 주장등 다양한 경험을 했습니다. 나름 자신이 있었지요. 하지만 면접은 달랐습니다. 특히, 기술을 요구하는 직종에서는 더욱 달랐습니다. 저는 면접을 보면서 반복적인 경험을 쌓았습니다. 그러면서 면접에서 떨어지는 횟수도 점차 줄었들었습니다. 그래서 항상 기술면접에는 자신감이 있었습니다. 그렇게 다져온 경험들이 이번 면접때 도움이 되었습니다. 

상반기가 시작하지 않았더라도 수시,상시등을 이용하여 면접 보는 것을 추천합니다. 단언컨대 절대로 손해볼 것이 없습니다. 이러한 경험들이 지금 혹은 나중에라도 큰 도움이 될 것 입니다. 

 

3. 전문성을 갖춰라 

저는 기술직이기 때문에 기술직을 준비하는 입장에서 서술하겠습니다. 전공이 컴퓨터이기 때문에 많은 준비를 해야했습니다. 특히, 이번에 준비할때는 

  • CS(네트워크, DB, 운영체제, 알고리즘, 프로그래밍언어..)
  • 연구 분야
  • 논문 내용
  • 그동안 진행한 연구 정리
  • 코딩테스트
  • 대학교때 진행한 프로젝트
  • 인성( 경험정리) 

이밖에도 많은 것을 정리하며 공부했습니다. 

이렇게 했던 이유는 단 하나 입니다. '면접'은 예상할 수 없기 때문입니다. 면접을 보면서 후기를 보며 준비들 하지만 요즘은 그렇게 나오지 않습니다. 더군다나 수시,상시 등으로 변하면서 더욱더 전문성을 원합니다. 하지만 전문성을 원하지만 인성 또한 소홀히 할 수 없습니다. 

저 또한 처음에는 후기를 보고 예상하고 면접들을 봤습니다. 하지만 여러 면접을 봤지만 같은 면접은 없더군요. 그렇기 때문에 대학원을 다니면서 위에 작성한 것들을 꾸준히 공부했습니다. 공부하면서 반복적으로 정리하고 면접스타일로 또 정리하면서 계속 전문성을 쌓기 위해 노력했습니다. 심지어 CS의 경우에는 200개에 가까운 예상 질문을 만들었으니.. 그래도 나름 많이 공부한 것 같습니다. 또한 연구실을 나왔어도 연구실에서 진행한 내용을 꾸준히 공부했습니다. 계속 공부했어야 했던 이유는 요즘의 기술 트랜드는 빠르게 바뀌니까 뒤처지지 않기 위해서 입니다. 이렇게 하고나니 정말 면접에 자신감이 생겼습니다. 

자신이 한것을 마침표를 찍을때마다 잘 정리해보세요, 언젠가 큰 재산이 될 것 입니다. 그리고 어떠한 것도 소홀히 하지마세요.

 

4. 너무 많은 것을 하진 말자.   

가끔 보면 취업을 준비하면서 여러 기술을 공부하려는 사람이 있습니다. 저는 추천하지 않습니다. 위에 얘기의 연장선이 되겠지만 짧게 남기겠습니다. 3번에서도 얘기했지만 요즘은 '다양'하게 아는 것 보다 얼마나 '깊이'아는 것이 중요합니다. 뭐 다양하게 깊이 알면 BEST겠지만요.. 솔직히 힘들지 않습니까? 

  • 자신이 한 것을 명확히 파악할것
  • 자신의 기술적 장점을 알고 있을것
  • 미래에 대한 방향성을 세울것

위의 것들을 바탕으로 무기를 만드세요. 당연 컴퓨터CS는 '기본'입니다. 어찌되었든 면접에서는 방패만들고 있을순 없습니다. 자기의 무기를 바탕으로 적당히 면접에서 주도권을 가져야 합니다.(너무 자만심에 기만하는 행동을 하라는 것을 아닙니다.) 

당연히 면접관분들은 다양하게 겉만 아는 사람보다 기본에 충실하며 한가지라도 제대로 아는 사람을 선호합니다. 

 

5. 절제하자 

이것은 호불호가 나뉘겠지만, 저는 언제부턴가 저의 할일을 끝내 하지못하고는 편하게 놀지 못했습니다. 대학원때는 평일/주말 구분이 없기 때문에 완전히 속세와 동떨어져 살았습니다. 저는 원하는 곳에 취업하는 것이 제가 할 수 있고 해야하는 목표라고 생각했습니다. 그래서 그전까지는 절제하며 사는 것을 목표로 했습니다. 이렇게 하다보니 이 생활에 익숙해져 오히려 편해졌고.. 사실 이전에 너무 재밌게 놀면서 살았기 때문에 후회가 없었습니다. 비록, 친구들을 서운하게 해서 미안한 마음도 컸습니다. 하지만 친구들도 항상 응원해주었으며 합격하고나서 함께 기뻐해주니 너무 고맙기도 했습니다.(앞으로 친구들에게 잘할것입니다..ㅎㅎ)

제가 이렇게 했던 이유는 스스로 목표도 있고 한번 노는 것이 어렵지 놀다보면 다짐했던 결심들이 약해져 공든탑이 무너질까봐였습니다. 목표를 얻고보니 힘들었지만, 자신이 자랑스럽기도 하면서 후회는 없었습니다. 

비록 저처럼 극단적으로 갈필요는 없습니다. 적당히 자기의 할일과 균형을 맞추며 하는 것을 추천합니다. 저도 가끔은 술한잔씩 했습니다. 저도 사람이니깐요. 자신에게 맞는 삶의 패턴으로 도전하시길 권장합니다. 

 

6. 포기하지 말자 

마지막으로 절대 포기하지 마십시요. 어찌됫든 졸업전에 취업을 했지만, 저의 과정을 아는 분들이 많은 걱정을 할만큼 힘든 시간들을 보냈습니다. 실패의 순간에는 언제나 힘들었습니다. 하지만, 저는 그 순간을 슬퍼하되 '실패'의 원인을 분석하고 앞으로 나아고자 했습니다. 힘들면 운동을 하고 노래를 들으며 여러 방법으로 극복했습니다. 특히 코로나로 인해 취업시장의 안좋은 소식을 들어도 '그럼에도 불구하고' 할 수 있다 라는 자신감을 가졌습니다.

개개인의 목표가 다르겠지만, 취업이라는 것은 마라톤과 같다고 생각합니다. 포기하지 않고 달리다 보면 목적지에 도착할 수 있습니다.

원하는 목표로 가실때까지 포기하지 않고 나아가시길 바라겠습니다. 간절하고 끊임없이 노력한다면 이루어지니깐요. 항상 긍정적으로 생각하시고 할 수 있다고 다짐하세요.

 

<마치며>

글 재주가 없어서 어떻게 느끼실지 모르겠습니다. 저 또한 여러 후기를 읽으면서 많은 도움을 받았습니다. 그렇기 때문에 이렇게 글을 남겨 도움을 드리고 싶습니다. 2014년 산티아고 순례길을 걸으며 다짐했던 것을 이제서야 이루었습니다.

가고 싶은 좋은 회사에 갔으며 하고 싶었던 직무를 하게 되었습니다.

코로나로 인해 취업시장이 좋지 않고 미래가 불투명하기 때문에 저 또한 많이 힘들었습니다. 그럼에도 항상 긍정적으로 생각하며 목표를 향해 나아갔고 원하는 결과를 이루었습니다. 포기하지 않고 목표를 향해 모두 같이 달려갔으면 합니다. 그 과정속에서 조금이나마 제 글이 도움이 되었으면 좋겠습니다. 

모두 화이팅합시다 :)  

 

<P.S>

코딩테스트, CS 준비, 연구분야 정리 등.. 구체적인 방법에 관해서는 댓글에 남겨주시면 도움드리겠습니다.

'일상 > 그냥이야기' 카테고리의 다른 글

블로그를 다시 시작합니다.  (0) 2020.08.30

소스 보러가기
문제 보러가기

사용한 알고리즘 및 자료구조
Sol 1 : ArrayList, Sol 2 : Stack

풀이
따로 알고리즘 구현이 필요 없는 문제이다. ArrayList, List, Stack 과 같은 자료구조 개념을 알고 있다면 쉽게 풀 수 있는 문제이다.

  1. 열 순서대로 인형 탐색

  2. 인형 있으면 -> 해당 칸 빈칸으로

  3. Stack or List 마지막 칸과 비교 같으면 삭제 후 정답 카운트 증가
    다르면 맨 뒤에 추가

  4. moves배열의 길이만큼 수행했다면 정답 카운트 출력

상당히 간단하다. Stack, List 둘다 가능할 것이라 생각하여 solution을 2개 만들었다.

로직은 같고 차이점은 Stack은 뽑는 행위가 디폴트 값으로 마지막 위치에 인형을 뽑는다. 그리고List는 (인덱스 값-1)을 매개변수로 get()을 이용하여 바구니 마지막 위치에 있는 인형을 출력한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
// before test, have to delete 'static' keywords
    public static int solution(int[][] board, int[] moves) {
        int answer = 0;
 
        ArrayList<Integer> box = new ArrayList<Integer>();
 
        for (int idx = 0; idx < moves.length; idx++) {
 
            int row = moves[idx] - 1;
 
            for (int col = 0; col < board.length; col++) {
 
                int boxLastIdx = box.size() - 1;
 
                if (board[col][row] != 0) {
 
                    if (box.isEmpty()) {
                        box.add(board[col][row]);
                    } else {
 
                        if (box.get(boxLastIdx) == board[col][row]) {
 
                            box.remove(boxLastIdx);
                            answer += 2;
                        } else {
                            box.add(board[col][row]);
                        }
 
                    }
                    board[col][row] = 0;
 
                    break;
 
                }
 
            }
 
        }
 
        return answer;
    }
    
 
    public int solution2(int[][] board, int[] moves) {
        Stack<Integer> box = new Stack<Integer>();
 
        int answer = 0;
        for (int i = 0; i < moves.length; i++) {
            int row = moves[i];
            for (int col = 0; col < board.length; col++) {
                if (board[col][row - 1] != 0) {
 
                    if (box.empty()) {
                        box.push(board[col][row-1]);
                    } else {
 
                        if (box.peek() == board[col][row-1]) {
                            box.pop();
                            answer += 2;
                        } else {
 
                            box.push(board[col][row-1]);
                        }
 
                    }
                    board[col][row-1] = 0;
 
                    break;
                }
 
            }
 
        }
 
        return answer;
    }
cs

'알고리즘(추가예정) > 기타' 카테고리의 다른 글

[프로그래머스] 베스트앨범  (0) 2020.08.30

소스 보러가기
문제 보러가기

사용한 알고리즘 및 자료구조
DP

풀이
처음에 설계를 올바르게 하지 못해 상당히 시간이 걸렸다. 30분정도 진행하다가 이내 잘 못 되었다는 것을 깨닫고 다시 설계를 해서 10분만에 끝냈다.
숫자 3개와 뭔가 규칙성이 있다는 것을 알고 있었지만, 이것을 3의 지수승으로 접근했다. 하지만 숫자에 따라서 3으로 나누면 나머지가 0,1,2가 된다는 것을 알게 되었다. 단, 1,2,4로 표현을 해야되기 때문에 나머지가 0일때는 4를 문자열에 더해주면 된다.

너무 어렵게 생각하면 독이 된다는 것을 가르쳐준 문제였다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    public static String solution(int n) {
 
        String answer = "";
 
        int mod;
 
        while (n > 0) {
 
            mod = n % 3;
            n /= 3;
 
            if (mod == 0) {
                n -= 1;
                mod = 4;
            }
 
            answer += String.valueOf(mod);
 
        }
 
        return answer;
 
    }
cs

'알고리즘(추가예정) > 동적계획법' 카테고리의 다른 글

[프로그래머스] 네트워크  (0) 2020.08.23
[프로그래머스] 2n 타일링  (0) 2020.08.23
백준 2315 가로등 끄기  (0) 2017.11.16
백준 1563 개근상  (0) 2017.11.14
백준 1495 기타리스트  (0) 2017.11.13

소스 보러가기
문제 보러가기

사용한 알고리즘 및 자료구조

HashMap,ArrayList

풀이
문제를 보고 HashMap 사용을 떠올랐다. 가장 먼저 생각한 것은 자바의 콜렉션을 최소화 하여 문제를 풀어내는 것 이었다. 그리고 총 4개의 콜렉션을 사용하여 문제를 풀었다.

먼저 파악해야 될 것은 정렬의 우선순위 요소 파악이다.

“장르 우선순위 , 노래 재생 횟수, 고유번호가 낮은 순서” 이렇게 우선순위가 선정되어 정렬이 된다. 파악한 우선순위로 차례차례 문제를 풀면 간단히 해결이 된다.

  1. 각 장르별로 재생된 횟수 구하여 HashMap에 담기

  2. 노래에 대한 구조체를 만들어 ArrayList에 담기

  3. 정렬하기 : Collections.sort() 함수 이용

  4. 정렬된 ArrayList에서 장르별 순서대로 2개씩 노래 새로운 ArrayList에 담기

간단하게 표현하면 이렇게 4단계로 문제가 풀린다. 자세한건 코드를 보면서 파악하기 바란다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
    // before test, have to delete 'static' keywords
    public static int[] solution(String[] genres, int[] plays) {
        HashMap<String, Integer> genresCheck = new HashMap<String, Integer>();
        HashMap<String, Integer> inputCheck = new HashMap<String, Integer>();
        ArrayList<Song> songList = new ArrayList<Song>();
        ArrayList<Integer> outputList = new ArrayList<Integer>();
        //1. genres count
        
        
        
        for(int g_idx = 0; g_idx < genres.length; g_idx++) {
 
            String g_str = genres[g_idx];
            songList.add(new Song(g_str,plays[g_idx],g_idx));
            
            if(genresCheck.containsKey(g_str)) {
                genresCheck.put(g_str, genresCheck.get(g_str)+plays[g_idx]);
            } else {
                
                genresCheck.put(g_str, plays[g_idx]);
            }
            
        }
        //2. sort
        
        Collections.sort(songList, new Comparator<Song>() {
            
            //s1 new
            @Override
            public int compare(Song s1, Song s2) {
                
                if(s1.genresName.equals(s2.genresName)) {
                    
                    if(s1.playCount != s2.playCount) {
                        return - (s1.playCount - s2.playCount);
                    } else {
                        
                        return (s1.songNum - s2.songNum);
                    }
                    
                } else {
                    
                    return -(genresCheck.get(s1.genresName) - genresCheck.get(s2.genresName));
                    
                }
                
            }
            
            
        }); 
        //3.checking
        for(int idx = 0; idx < songList.size(); idx++) {
            
            Song song = songList.get(idx);
            
            if(!inputCheck.containsKey(song.genresName)) {
                inputCheck.put(song.genresName, 1);
                outputList.add(song.songNum);
            } else {
                
                int cnt = inputCheck.get(song.genresName);
                
                if(cnt > 1) {
                    continue;
                } else {
                    inputCheck.put(song.genresName, cnt+1);
                    outputList.add(song.songNum);
 
                }
                
            }
            
        }
        
        int[] answer = new int[outputList.size()];
        
        for(int s_idx = 0; s_idx < answer.length; s_idx++) {
            answer[s_idx] = outputList.get(s_idx);
        }
 
 
        return answer;
    }
 
    static class Song {
        
        String genresName;
        int playCount;
        int songNum;
 
        public Song(String genresName, int playCount, int songNum) {
            
            this.genresName = genresName;
            this.playCount = playCount;
            this.songNum = songNum;
 
        }
 
    }
 
cs

'알고리즘(추가예정) > 기타' 카테고리의 다른 글

[프로그래머스] 인형뽑기  (0) 2020.08.30

블로그를 다시 시작합니다. 

알고리즘은 이전에 풀어놓은것을 사용하지 않고 다시 풀면서 

업로드를 진행할 예정입니다.

연구실에서 경험한 

SDN, NFV, 컨테이너, 쿠버네티스등 다양한 분야에 관련된 글 포스팅을

진행할 예정입니다.

현재 구직중에 있습니다 

링크드인 :  https://www.linkedin.com/in/gilho0608/

 

 

'일상 > 그냥이야기' 카테고리의 다른 글

2021년 취업 성공 후기  (2) 2021.01.17

소스 보러가기
문제 보러가기

사용한 알고리즘 및 자료구조
DFS/BFS, 그래프

풀이

간단한 DFS/BFS 문제이다. 문제를 푸는데 20분도 안 걸렸다. 이번에는 DFS를 이용해서 해당 문제를 풀었다. 이 문제를 읽고 생각을 했던 것은 2차원 배열에서 (n,n) 칸들을 기준으로 좌우 대칭이 된다는 것이다. 또한 각각의 값들이 연결관계를 표현했다. 따라서 처음에 탐색할 때는 1/2만 탐색을 하고 DFS 를 사용할 때는 연결관계를 기준으로 탐색을 하면 된다. 보통의 DFS 문제는 ‘상하좌우’로 움직이면서 문제를 해결했지만, 해당 문제는 배열의 값들이 내포하고 있는 연결관계를 이용해서 DFS 함수를 구현했다.

  1. 초기화
  2. 문제에 해당하는 조건( 배열의 값 : 1 && 아직 탐색하지 않은 칸) 찾기 ,조건을 찾을 때 마다 answer++
  3. 조건 찾고 나서 DFS 함수를 이용해 연결관계를 따라 영역표시하기
  4. 다시 2-3번 반복
  5. Answer 출력

간단한 DFS 문제이다. 실제로 삼성 시험을 봤던 사람들에게는 매우 쉬웠을 거라 생각한다. 다만 이것을 어떻게 해야 더 효율적으로 구현할 수 있을까 고민해보았다. 간단한 문제라 특별하게 적용할 것은 없었으나, 그래도 고민 해보면 좋을 것이다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
    public static int SIZE;
 
    // before test, have to delete 'static' keywords
    public static int solution(int n, int[][] computers) {
        int answer = 0;
        boolean[][] visited = new boolean[n][n];
        SIZE = n;
 
        for (int c_idx = 0; c_idx < n; c_idx++)
            for (int r_idx = c_idx; r_idx < n; r_idx++) {
 
                if ((computers[c_idx][r_idx] == 1) && (visited[c_idx][r_idx] == false)) {
                    visited[c_idx][r_idx] = true;
                    dfs(r_idx, visited, computers);
                    answer++;
 
                }
            }
 
        return answer;
    }
 
    public static void dfs(int idx, boolean[][] visited, int[][] computers) {
 
        for (int col = 0; col < SIZE; col++) {
 
            if ((computers[idx][col] == 1) && (visited[idx][col] == false)) {
 
                visited[idx][col] = true;
 
                dfs(col, visited, computers);
 
            }
 
        }
 
    }
 
 
cs

'알고리즘(추가예정) > 동적계획법' 카테고리의 다른 글

[프로그래머스] 124 나라의 숫자  (0) 2020.08.30
[프로그래머스] 2n 타일링  (0) 2020.08.23
백준 2315 가로등 끄기  (0) 2017.11.16
백준 1563 개근상  (0) 2017.11.14
백준 1495 기타리스트  (0) 2017.11.13

소스 보러가기
문제 보러가기

사용한 알고리즘 및 자료구조

DP , 피보나치

풀이

문제에 대한 접근 방향이 중요하다. 여러 접근에 대한 후보를 떠올리고 최적의 후보를 택하여 접근해보았다. 인덱스 순서대로 접근하려고 했으나, 이내 방향을 바꿔 가장 맨 뒤를 가정하고 접근했다.

내가 N일 때, N-1, N-2에 올 수 있는 모양에 대해서 생각해보면 된다.

  • N-1 일 때 : 블록을 세울 수 밖에 없다.

  • N-2 일 때 : 세로 블록 2개 , 가로 블록 2개인 경우로 나뉠 수 있다. 하지만 세로 블록 2개인 경우에 N-1인 경우와 같다. 따라서 가로 블록 2개인 경우만 카운팅 된다.

즉, N-1, N-2가 어떠한 블록이 오느냐에 따라서 자동으로 N번째까지 블록이 채워진다.

그러므로 N-1 + N-2 개수를 합하여 더 하면 된다.

N = (N-1)+(N-2) => 피보나치

규칙을 보면 피보나치 수열이 근간이 되어 풀리는 문제다. 자세한건 코드를 보면서 파악하기 바란다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
    public static int solution(int n) {
        int answer = 0;
        int s = 1000000007;
 
        int[] dp = new int[n + 1];
 
        dp[0] = 0;
        dp[1] = 1;
        dp[2] = 2;
 
        for (int idx = 3; idx <= n; idx++) {
 
            dp[idx] = (dp[idx - 2] + dp[idx - 1]) % s;
 
        }
 
        answer = dp[n];
 
        return answer;
    }
 
 
cs

'알고리즘(추가예정) > 동적계획법' 카테고리의 다른 글

[프로그래머스] 124 나라의 숫자  (0) 2020.08.30
[프로그래머스] 네트워크  (0) 2020.08.23
백준 2315 가로등 끄기  (0) 2017.11.16
백준 1563 개근상  (0) 2017.11.14
백준 1495 기타리스트  (0) 2017.11.13
VEN을 설치하는 과정에서 여러가지의 오류가 발생할 수 있다.

특히 make를 하는 과정에서는 다양한 오류를 가져올 수 있다. 

최근에 make 를 진행하면서 발견했던 오류들에 대해서 작성해 보겠다. 

error가 발생했다고 해서 다시 리눅스를 깔지말자, 


--



jsonfilter 부분에서 

the requested url returned error 504
error rpc failed result=22 http code = 504

오류 생길시 

git config —global http.proxy ‘’ 

--





libxerces-c-3.1.2 부분에서

fatal the remote end hung up unexpectedly3 Mib
발생시

git config http.postBuffer 104857600 




--

Ubuntu Command Line으로 wifi 접속하기


브릿지로 하다가 와이파이로 하려고하면 오류가 발생한다. 

일단 가상머신에서 디스크 설정 -  > 네트워크 

브릿지 -> NAT 

COMMAND로  
 sudo service network-manager restart

해주면된다. 


문제보기


상당히 오래 걸렸다. 

백준강의 자료를 참고해서 완성할 수 있었다. 


마징가는 태권V덕분에 가로등만 끄면 되는 편한일(?)을 맡았다는 내용,


마징가의 움직임에 살펴보자 마징가는 현재 '5'번의 위치하고 있다. 

그리고 끄려면 수평으로 움직여야 한다. 

그렇다면 어떻게 움직일 수 있는가 ? 

좌우로 움직이면 된다. 

그리고 생각해보면 만약 두칸을 움직여서 끄면 건너뛴 가로등을 다시 꺼야되는

일이 발생한다. 

두번 일하지 말고, 가면서 만나는 가로등은 다 끄도록하자.

결국

좌우로 움직이게 되고 가로등을 끄면서 켜져있는 값들을 더하면서 나가면된다. 


점화식은 

if(left - 1 >= 1) {

ans = Math.min(ans, solution(left-1,right,0) + (a[now]-a[left-1])*(s[n]-s[right]+s[left-1]));

} 

if(right + 1 <=n) {

ans = Math.min(ans, solution(left,right+1,1) + (a[right+1]-a[now])*(s[n]-s[right]+s[left-1]));

}


이렇게 된다 왼쪽으로 움직이는 경우 마지막 index 1번까지 갈 수 있고 ,

오른쪽으로 움직이는 경우 마지막은 n까지 갈 수 있다. 

그리고 왼쪽으로 움직인경우 index를 이동해야하기 때문에 left-1, 오른쪽은 right+1하면서 이동하면된다. 


베이스 케이스는

if(left == 1 && right == n) {

return 0;

}

이렇게 된다. 


그리고 현재 켜져있는 값들을 계산해야된다. 


(a[now]-a[left-1])*(s[n]-s[right]+s[left-1]));

-> 끄러 이동하는 시간   // -> 그때까지 켜져 잇는 가로등의 값들 ( 시그마 형식 ) 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
package Problems;
import java.util.Arrays;
/**
 * 
 * 백준 2315 가로등끄기 
 * 
 *  동적계획
 * 
 *
 */
import java.util.Scanner;
public class Boj2315dp {
    
    public static int n,m;
    public static int a[] = new int[1001];
    public static int w[] = new int[1001];
    public static int s[] = new int[1001];
    public static int d[][][] = new int[1001][1001][2];
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m= in.nextInt();
        
        for(int i = 1; i <= n; i++) {
            a[i] = in.nextInt();
            w[i] = in.nextInt();
            s[i] = s[i-1] + w[i];
        }
        
        for(int i = 0; i < 1001; i++) {
            for(int j = 0; j < 1001;j++) {
                for (int w = 0; w <2; w++) {
                    d[i][j][w] = -1;
                    
                }
            }
        }
        
        System.out.println(solution(m,m,0));
        
    }
    
    public static int solution(int left, int right, int where) {
        
        if(left == 1 && right == n) {
            return 0;
        }
        
        if(d[left][right][where] != -1) {
            return d[left][right][where];
        }
        
        int ans = 214748364;
        
        int now = where == 0 ? left : right;
        System.out.println("now  :  " + now);
        if(left - 1 >= 1) {
            ans = Math.min(ans, solution(left-1,right,0) + (a[now]-a[left-1])*(s[n]-s[right]+s[left-1]));
        } 
        
        if(right + 1 <=n) {
            ans = Math.min(ans, solution(left,right+1,1) + (a[right+1]-a[now])*(s[n]-s[right]+s[left-1]));
            
        }
        
        d[left][right][where] = ans;
        
        return ans;
    
    
    }
 
}
 
cs

'알고리즘(추가예정) > 동적계획법' 카테고리의 다른 글

[프로그래머스] 네트워크  (0) 2020.08.23
[프로그래머스] 2n 타일링  (0) 2020.08.23
백준 1563 개근상  (0) 2017.11.14
백준 1495 기타리스트  (0) 2017.11.13
백준 11048 이동하기  (0) 2017.11.08

문제보기


실제로 이 문제를 푸는 방법은 여러가지가 있더라 , 

하지만 배열을 다루는 것에 있어 미숙한점을 알고 있기때문에

조건을 배열로 바꾸어 5차원 배열로 풀어보았다. 

 

풀이는 간단하지만 복잡하다. 

경우를 충분히 나누면 풀 수 있다. 

다만 그 경우가 다른 쉬운 다이나믹 문제보다 조건이 많아 처음에는

힘들었다. 


조건의 예를 들어보자 

점화식을 설명해보자면 

D[현재몇일][오늘의 출결][어제의 출결][그제의 출결][지각횟수]

이다. 

오늘 출결했다고 하면 뭘해도 상관없다.  이런식으로 조건을 나열하여 풀면된다. 

처음에는 상당히 시간이 걸렸다.

D[i][0][prev][prev2][0] += D[i-1][prev][prev2][prev3][0];

D[i][0][prev][prev2][1] += D[i-1][prev][prev2][prev3][1];


그리고 안되는 조건을 살펴보자면 

now , prev , prev2가 다 결석이면 안된다. 연속3일 결석을 할 수 가 없다. 

지각은 한번까지 허용된다. 그럼으로 오늘지각을 했다면 어제까지 지각을 하면안된다. 


주석을 달아놨으니 참고하면된다.




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
package Problems;
 
/**
 * 
 * 
 * 백준 1563 개근상
 * 
 * 동적계획
 *
 */
import java.util.Scanner;
 
public class boj1563dp {
    public static int mod = 1000000;
 
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[][][][][] D = new int[1001][3][3][3][2];
 
        for (int now = 0; now < 3; now++) {
            for (int prev = 0; prev < 3; prev++) {
                for (int prev2 = 0; prev2 < 3; prev2++) {
 
                    // 결석 연속3번은 안
                    if (now == 1 && prev == 1 && prev2 == 1) {
                        continue;
                    }
 
                    // 지각 2번은 안됨
                    if ((now == 2 && prev == 2) || (now == 2 && prev2 == 2) || (prev == 2 && prev2 == 2)) {
                        continue;
                    }
 
                    if (now == 2 || prev == 2 || prev2 == 2) {
                        D[3][now][prev][prev2][1] = 1;
                    } else {
 
                        D[3][now][prev][prev2][0] = 1;
 
                    }
 
                }
            }
        }
 
        for (int i = 4; i <= n; i++) {
            for (int prev = 0; prev < 3; prev++) {
                for (int prev2 = 0; prev2 < 3; prev2++) {
                    for (int prev3 = 0; prev3 < 3; prev3++) {
 
                        // 출석했을
                        D[i][0][prev][prev2][0] += D[i - 1][prev][prev2][prev3][0];
                        D[i][0][prev][prev2][0] %= mod;
                        D[i][0][prev][prev2][1] += D[i - 1][prev][prev2][prev3][1];
                        D[i][0][prev][prev2][1] %= mod;
 
                        // 결석
 
                        if (prev == 1 && prev2 == 1) {
 
                        } else {
 
                            D[i][1][prev][prev2][0] += D[i - 1][prev][prev2][prev3][0];
                            D[i][1][prev][prev2][0] %= mod;
                            D[i][1][prev][prev2][1] += D[i - 1][prev][prev2][prev3][1];
                            D[i][1][prev][prev2][1] %= mod;
 
                        }
 
                        D[i][2][prev][prev2][1] += D[i - 1][prev][prev2][prev3][0];
                        D[i][2][prev][prev2][1] %= mod;
 
                    }
                }
            }
        }
        
        int ans = 0;
        
        for(int i = 0; i < 3; i++) {
            for(int j = 0; j < 3; j++){
                for(int k = 0; k < 3; k++) {
                    for(int l = 0; l < 2; l++) {
                        ans += D[n][i][j][k][l];
                        ans%=mod;
                    }
                }
            }
        }
        
        System.out.println(ans);
 
    }
 
}
 
cs


'알고리즘(추가예정) > 동적계획법' 카테고리의 다른 글

[프로그래머스] 2n 타일링  (0) 2020.08.23
백준 2315 가로등 끄기  (0) 2017.11.16
백준 1495 기타리스트  (0) 2017.11.13
백준 11048 이동하기  (0) 2017.11.08
백준 1912 연속합  (0) 2017.11.07

+ Recent posts

티스토리툴바