면접 준비하면서 너무 늦게 깨달아버린 인생에 중요한 것이 있었습니다.

일을 잘 하는 것 만큼이나 협업을 잘하는 것이 중요하다 였습니다.

일을 잘 하는 것은 잘할 수 있는데 협업을 잘 하는 것은 사실 잘 못하는 것 같습니다. 

준비 과정에서 대기업 면접에서는 협업을 잘한다는 것을 크게 어필해야한다는 것을 깨달았는데 잘 하지 못하니 대기업에 맞지 않는 사람인가 걱정고민이 많았습니다.

협업했던 경험은 많아서 협업 잘 하겠다는 정량적 평가에는 자신이 있었는데 면접하면서 드러나는 것에 대한 정성적 평가는 자신이 없었습니다.

가서 관련 질문이 나오면 너무 멘붕이 올 것 같아 걱정이 많이 되었습니다.

그럴때마다 이번이 마지막이라는 마음으로 할 수 있는 준비를 100%로 해서 후회없게 면접을 본다면, 이번에 떨어지면 내년엔 합격가능성이 더 떨어지니 또 떨어질 것이니까 대기업을 포기하면 된다고 생각을 하고 현재에 충실했던 것 같습니다.

 

인적성 결과

  • 하이닉스는 합격을 했고 다행히 2차 SKCT 없이 최종면접으로 넘어갔습니다.

  • LG전자는 합격할거라 생각 못했는데 합격해서 AI면접과 1차면접으로 넘어갔습니다.

  • 삼성전자는 진짜 떨어졌다고 생각했는데 합격을 해서 최종 면접으로 넘어갔습니다. 

 

면접전형 준비

  • 중간고사 끝나고 삼성전자 면접까지 약 3주정도 시간이 있었습니다.

  • 반도체 공부

    • 삼성전자 DS와 하이닉스에 대한 기업조사를 한번에 끝내준 책이 있습니다.

    • 다 읽고나면 반도체 산업에 대한 질문이 나오면 무엇이든 답할 수 있을 것 같았습니다.

 

  • 면접이론공부

    • 먼저 남들은 어떻게 면접을 보는지 합격하는 사람들은 어떻게 면접을 보는지 조사에 시간을 정말 많이 썼습니다.

    • 가장 도움이 많이 되었던 자료 순으로 말씀드리자면

      • 렛유인 유튜브 + 강의에 나오는 삼성전자 + SK하이닉스 면접관련 동영상 (특히 나상무님 동영상)

      • 강민혁 유튜브

      • 면접왕 이형이 제시하는 기본적인 면접 준비 틀

      • 인싸담당자 유튜브 생방송으로 진행했던 특강

    • 특히 나상무님께서 말씀하시는 삼성 면접 이런식으로 이루어진다, 피드백 등등 가장 큰 도움이 되었습니다. 삼성면접을 준비하시는 분은 꼭 미리부터 보시고 그 방향대로 준비하시면 큰 도움이 될 것입니다.

  • 면접실전연습

    • 면접스터디를 했고 학교에서 제공하는 모의면접도 신청해서 했습니다.

    • 면접스터디가 면접시즌 한번에서 두번정도 모의면접하고 끝나는 식이었습니다.

    • 최대한 많이 하면 좋다고 생각해서 끝나면 바로 다른 스터디 가입하고 해서 거의 매일 모의면접을 했습니다.

    • 스터디가 없는 날은 여자친구님께 부탁해서 3시간 넘게 계속 면접본적도 있고 혼자 예상질문지로 질문을 녹음하고 답변하는 연습을 했습니다.

    • 면접스터디를 하면

      • 전형적인 질문엔 준비된 답변을 실전에서 여러번 말하면서 면접에서 자연스럽게 말할 수 있게 되었습니다.

      • 돌발질문에 대처하는 연습을 할 수 있습니다.

      • 질문 준비 안해가면 바보같기 때문에 더 열심히 준비할 수 있습니다.

      • 잘하는 사람 보고 배울점을 배울 수 있습니다.

    • 학교에서 제공하는 모의면접을 하면

      • 모의면접관 2분을 만났는데 전공이 달랐기 때문에 전공관련해 나올법한 질문을 하실 수는 없어 단점이 있지만 긴장감과 자세 목소리, 일반적인 질문에 대한 피드백을 받을 수 있습니다.

    • 면접스터디든 무엇이든 면접장과 유사한 곳에서 말할 기회를 최대한 많이 갖고자 했습니다.

 

  • 지원동기

    • 면접 질문에 100% 나올 것이라 생각하는 지원동기 답변 준비하는게 너무 힘들었습니다. 

    • 그냥저냥 적당히 이야기했는데 그게 회사에서 중요하게 생각하지 않는 일이거나 아예 하지않는 일일수도 있어서 걱정이었습니다.

    • 직무기술서에 적힌 직무는 무조건 있겠지 하고 직무기술서에 적힌 직무 중 하고싶었던 직무를 답변으로 준비했습니다.

 

  • LG전자 면접

    • 집에서 AI면접을 쳤어야 했습니다.

    • 지원동기, 등등 전형적인 질문 물었던 것 같고 문제풀거나 하는 건 없었습니다.

    • 1차면접은 직무면접이었습니다.

    • 면접 때 설명에 도움을 줄 ppt를 만들어 제출해야 했습니다.

    • 오전 7시 30분까지 오라고 했는데 모든 지원자가 이 때 오는게 아니라 각자 오는 시간이 달랐습니다.

    • 오니까 지원자중에 가장 먼저 온 것 같았습니다. 면접을 일찍 보면 면접관분들께서 가장 안피곤할 때기 때문에 유리하다는 얘기를 들어 운이 좋다고 생각했습니다.

    • 각 지원자마다 정해진 시간표대로 차례차례 면접을 보고 모든 면접이 끝나면 바로 집에 가는 그런 매우 지원자 신경을 많이 쓴 면접이었습니다.

    • 간식이 있어 간식을 먹으며 긴장 풀고 있었는데 문제지를 주고 문제를 풀라고 했습니다.

    • 키워드 3개로 창의적인 이야기 만들기, 문제상황 주어지고 해결방안 제시하기, 손코딩을 40분정도안에 해야했습니다.

    • 다 풀었으면 직무면접에 가서 제출했던 ppt로 직무적합한 이유를 설명, 질의응답, 키워드와 문제상황 적었던 것에 대해 이야기 했습니다.

    • 끝나고 다른 방으로 가서 영어면접을 봤습니다.

    • 영어 수준이 너무 떨어져서 면접관님 표정이 안좋았던게 느껴졌습니다..

    • 면접 끝나고 나니 9시 반쯤 되어 집으로 갔습니다.

    • H&A 사업부 건물 되게 멋있게 생겼습니다.

 

  • SL 면접

    • 면접준비를 하려고 썼던 자기소개서를 꺼내 읽었습니다.

    • 마지막 질문이 우리 회사에 궁금한 점 있으면 적어주세요였습니다.

    • 제 답변은 저를 회사가 크게 성장시켜줄 수 있는지 궁금합니다. 뭐 이런식이었던 것 같습니다.

    • 면접준비를 하면서 굉장히 최악의 답변이라는 것을 깨닫게 되었습니다.

    • 이 회사 지원동기도 잘 떠오르지 않았고 만약 저 답변에 대해 면접관이 질문한다면 멘탈이 와장창 깨질 것 같아 면접을 가지 않았습니다.

    • 자소서는 항상 겸손하게 써야겠다고 생각을 했습니다. 

 

 

  • SK하이닉스 면접

    • 전날에 이천 숙소에 가다 저녁을 버스터미널 끄트머리 분식집에서 김치볶음밥을 먹었는데 정말 맛있어서 하이닉스 붙으면 여기 또먹으러 와야겠다 생각했습니다.

    • 이천 SK 연수원에서 면접을 봤습니다.

    • 상반기 면접과 다르게 인성면접과 직무면접을 따로 봤습니다. 

    • SKCT 인성부분을 따로 컴퓨터실에서 치고 인성면접을 보러 갔습니다.

    • 지원자중에서 인성면접을 첫번째로 봤습니다. 운이 좋다고 생각했습니다.

    • 20분간 인성면접을 봤는데 지원동기를 제외하고는 협업관련 질문이 계속 이어졌습니다.

    • 아마 SKCT에서 협업관련 점수가 낮게 나와서 그런 질문을 하신 것 같았습니다.

    • 공모전과 랩실에서 개발했던 것에 대해 질문하셨는데 각자 개발할 것을 나누어 따로 개발했다고 말씀드렸습니다. 그래서 혼자 개발하는 것 좋아하냐고 하셨고 협업한게 아니다. 이렇게 말씀하셔서 면접 망했구나 하는 생각이 좀 들었습니다.

    • 여가시간에 뭐 하냐고 하셔서 평일엔 웨이트트레이닝하고 주말엔 여자친구와 놀러 간다고 답변했습니다

    • 면접 끝나고 생각해보니 계속 협업관련 지적을 하는 상황에서 저런 질문을 하면 무난하게 친구와 술한잔 하거나 합니다. 이런 답변으로 핵 아싸는 아닙니다라는 걸 말했어야 했을 것 같은데 신나게 혼자하는 운동 좋아한다 이런식으로 말했기 때문에 굉장히 잘못된 답변이었다 생각했습니다.

    • 면접 끝날 때 쯤엔 면접관님들 표정이 뭔가 안좋았던 것 같아 매우 자괴감이 들었습니다..

    • 역시 대기업이랑 안맞는가 보다 생각을 했습니다.

    • 직무면접은 가장 마지막에 봤는데 작성했던 코드를 띄워주시면 면접관님들께 리뷰하는 면접이었습니다.

    • 문제를 푼 알고리즘을 먼저 설명드리고 왜 그렇게 동작하는지 코드를 보며 설명드렸는데 사실 너무 횡설수설해서 잘 이해 못하셨을 것 같았습니다.

    • 거기에 변수와 함수명을 가독성 떨어지게 적었던 문제가 있었는데 언급하셔서 너무 급해서 그랬습니다. 입사해서는 이런 것 하나하나 신경써서 코드 작성하겠습니다. 이렇게 답변했습니다.

    • 마지막에 시간 안 부족하셨어요? 라는 질문으로 면접이 끝났습니다.

    • 그냥 대기업이랑 나는 안맞는가보다 생각했습니다.

 

  • 삼성전자 면접

    • 하이닉스면접에서 너무 털려서 잘할 수 있을까 걱정이 많이 됐습니다.

    • 면접전날 부터 감기가 심하게 와서 열이 많이 났는데 묵었던 숙소에 온수가 안나와 씻는데 너무 추웠습니다.

    • 약을 먹으니 좀 나아서 면접을 보러 갔습니다.

    • DSR타워 처음 봤는데 정말 멋있었고 저기서 일하고 싶다는 생각을 했습니다.

    • 게이미피케이션이 처음 도입되어 재밌게 했고 컴퓨터로 인성검사를 했습니다.

    • 운좋게도 인성면접을 지원자중에 가장 빨리보는 조에 들어가서 처음으로 인성면접을 봤습니다.

    • 면접을 잘 봤다는 생각이 드는 면접을 봤습니다. 굉장히 솔직하게 면접을 봤던 것 같습니다.

    • 직무면접을 그다음 바로 보러 갔습니다.

    • 주제 3개중에 하나 골라 푸는 것인데 2개는 전혀 모르는 것이였고 1개 이전에 열심히 들었던 수업의 내용이어서 선택했고 굉장히 자신있게 풀고 면접을 봤습니다. 

    • 창의성 면접은 오후에 본다고 했는데 창의성 면접은 합격에 큰 영향을 미치지 않는다고 해서 조원들과 마음편하게 밥먹고(굉장히 맛있음) 쉬었습니다.

    • 오후에 창의성 면접을 재미있게 봤습니다. 창의성 면접에서는 매번 창의적인 아이디어에 대한 이야기를 묻는다고 알고 있었습니다. 코워킹 스페이스 해커톤에서 1등했던 아이디어로 말씀을 드렸는데 반응이 좋아서 재밌게 면접 봤습니다.

    • 면접 보고 나와서 느낌이 너무 좋아서 이거 만약 안되면 내년엔 이것보다 더 면접을 잘 보기 힘들다고 생각했고 그러면 대기업 안가야겠다 생각을 했습니다.

 

  • 결과발표

    • LG 1차면접은 합격했고 2차 면접일이 삼성 예상결과발표일 하루 뒤여서 삼성 합격해서 면접 안가도 되면 좋겠다 생각했습니다.

    • 삼성 면접결과는 결과나오기 한 두시간 전이되면 전형결과 확인기간이 아닙니다? 이런 문구가 뜹니다. 또 합격이면 안내 글자가 녹색이고 아니면 다른색이고 이런 말이 있었습니다.

    • 다행히 녹색이었습니다. 

    • 하이닉스는 그 뒤 일주일 뒤에 나왔는데 당연히 불합격이라 생각했습니다.

    • 대기업에 안맞는 사람은 아닌가 보다 생각을 했습니다.

 

    • 정말 알 수 없지만 개인적인 생각으로는

    • 공채 합격하는데 필요한 것은

    • 이 때까지 해온 것 7, 말하는 스킬 1, 준비 2 라고 생각합니다.

    • 그런데 7와 1이 완벽하더라도 2가 부족하다면 떨어질 수 있습니다. 지원동기가 명확하지 않음이 드러나면 합격가능성이 매우 낮아지기 때문입니다.

    • 7을 올릴 수 있는 상황이면 최대한 7을 올리고 그렇지 않은 상황이라면 완벽한 2를 준비해서 2에 준비가 부족했던 사람들보다 경쟁력을 갖춘다면 합격할 수 있을 것이라 생각합니다.

    • 취업 준비하면서 가장 힘든 점은 어느정도 하면 합격 하겠다. 이런게 전혀 없다는 것이 가장 힘들었습니다. 막막해 보이더라도 할 수 있는 최선을 다했다면 좋은 결과가 있게되는 것 같습니다.

 

 

 

 

갑작스럽게 취업준비를 시작한거라 막막했습니다.

여기저기서 알아보니 방학때 취업준비를 시작해서 기업분석, 자기소개서는 미리 써두고 인적성 준비를 시작하는게 정석처럼 보였습니다.

너무 늦은 것 같아 불안했지만 그래도 가능성은 있다고 생각하며 열심히 첫 취업을 준비했습니다.

 

4학년 2학기 - 취업준비(자소서 + 코테)

 

  • 지원기업선정

    • 처음엔 삼성전자, SK하이닉스, LG전자 H&A 만 내려고 했습니다.

    • 그러다 이것이 거만한 생각임을 깨달았고 잡코리아를 밥먹듯이 들어가며 펌웨어 직무중 합격가능성이 있어보이는 곳은 다 넣자고 생각을 했습니다.

    • 그래서 뷰웍스, SL, 농심엔지니어링, DB inc, 원익(어디에 넣었는진 모르겠음)에 FW직무를 올리브네트웍스에 SW개발직무에 원서를 추가로 넣었습니다.

 

  • 자기소개서 작성

    • 가장먼저 자기소개서를 쓴 기업은 SK하이닉스였습니다.

    • 제가 다니는 대학에서 하이닉스는 많이 들어가지 못했고 예전에(약 1년전) 요즘은 하이닉스라는 말을 어디서 들었던 것 같아 가장 가고싶었던 것 같습니다.

    • 하이닉스 자기소개서 항목은  https://www.jobkorea.co.kr/company/1496894/keyword 와 같습니다.

    • 맨 처음에 1번 문항만 하루이상을 걸려 열심히 작성했습니다.

    • 어디 첨삭을 받고 싶은데 딱히 없어서 코멘토라는 곳에서 1번 문항만 첨삭을 받았습니다.

    • 적나라하게 잘못된 점을 여러 현직자 분께서 지적해주셨고 굉장히 자괴감이 들었습니다.

    • 문제점은 요약하면 너무 장황하고 기업자기소개서에 맞지 않는 내용을 적었다는 내용이었습니다.(말귀를 못알아 먹었다는 뜻)

    • 특히 하이닉스 자소서항목은 괄호안에 어떤 내용을 쓰라고 친절하게 설명까지 해 뒀는데 이상한 걸 썼다는 걸 깨달았습니다.

    • 괄호 안에 말하는 내용을 모두 포함하도록 신경쓰며 C++ 수업을 열심히 들었던 내용을 적었습니다.

    • 다시 첨삭을 받았는데 칭찬도 받고 별점도 5점만점에 4점넘게 받았습니다.

    • 계속 괄호 안 말하는 내용을 신경쓰며 2번엔 코워킹스페이스 해커톤 나갔던 이야기 3번엔 랩실에서 연구한 이야기 4번엔 공모전에서 장관상 받은 이야기를 작성했습니다.

    • 좋은 자소서를 쓰기 위해 가장 도움이 많이 되었던 자료는 아래 책이었습니다.

    • 앏은 책인데 꽤 비쌉니다. (다른 책 자소서바이블 아님)

    • "자소서와 면접을 한방에 준비" 라는 말에 공감이 갔고 실제로 취업과정을 다 겪으면서 면접을 치뤘는데 맞는 말이라고 생각합니다.

    •  자소서 작성에서 관련 유튜브도 많이 참고하며 도움이 많이 되었습니다. 취업이 어떤 것이고 어떻게 준비해야 하는지를 잘 알 수 있었습니다.

 

    • 하이닉스 자기소개서가 완성되었고 다음 삼성전자 자소서를 작성했습니다.

    • 삼성전자는 하이닉스와 자소서 문항이 차이가 많이 났습니다.  하이닉스는 내 경험을 잘 적어 내기만 하면 됐다면 삼성전자는 회사가 날 왜뽑아야하는지를 설명하라고 하는 것 같은 느낌이었습니다. 하이닉스보다 훨씬 까다로웠습니다.

    • 크게 까다로웠던 것은 지원동기를 묻는 것 입니다. 회사 내부에서 어떤 일을 하는지 잘 모르는 상황에서 어떤 분야에서 어떤 일을 하고싶다 라고 작성하는게 굉장히 어려웠습니다. 하고싶은 일은 FW개발인데 삼성전자내에도 사업부가 많다보니 메모리사업부라면 SSD에 들어가는 fw인지 S.LSI사업부에 취급하는 제품의 FW 개발인지 고민해서 작성해야했습니다.

    • 하고싶은 것은 S.LSI쪽 FW 개발인데 이것도 문제가 있었습니다. 메모리사업부는 본래 사람을 많이 뽑는데 S.LSI는 사람을 적게 뽑거나 한다면 이쪽일을 하고싶다고 하면 합격가능성이 낮아진다는 고민부터 정말 답답했던 기억이 있습니다.

    • 그냥 소신 것 엑시노스 개발쪽 FW 개발을 하고 싶다고 적어 냈습니다.

    • 2, 3, 4번 항목은 경험을 주로 묻는 내용이어서 경험을 작성했습니다.

    • 다른 기업들은 삼성전자 + 하이닉스 자소서에 내용을 항목에 맞게 잘 넣어서 제출했습니다. 특히 LG는 자소서 항목을 대폭 축소해서 굉장히 좋았지만 무엇을 보고 뽑을 건지 의아하긴 했습니다.

 

  • 인적성준비

    • 해왔던 경험과 전혀 맞지 않았던 올리브네트웍스를 제외하고 서류통과를 했습니다.

    • 각 기업의 인적성

      • 삼성전자/하이닉스 -> 코딩테스트

      • LG전자 H&A /  농심엔지니어링 / DB inc  인적성

      • 뷰웍스 -> 전공 테스트 + 문제해결력테스트

      • SL / 원익 -> 인적성 없이 1차면접

    • 농심엔지니어링, DB inc인적성은 다른 기업과 겹쳐 치지 못했습니다.

    • 뷰웍스는 삼성전자, 하이닉스 면접준비시간을 벌기 위해 치르지 않았습니다.

    • SL, 원익은 면접준비시간 벌기위해 치르지 않았습니다.

    • 9월 16일 서류마감 후 한달 정도의 코테 준비 시간이 있었습니다.

    • 삼성코테는 기출과 유사한 문제가 백준에 있었고 하이닉스는 어떤게 나오는지 알 수가 없어 그냥 삼성 코테만 준비했습니다.

    • 준비 전 객관적 실력

      • 백준 알고리즘강의 기초, 중급1 수강 후 여러번 복습

      • 백준 400문제 정도 품

      • 코드포스 50문제 A,B,C 위주로 품

      • 종만북 대부분 한번 봄 (이해는 책 전체에 30%도 못함)

    • 삼성 코테 준비

      • 목표는 기출문제 + A형 기출문제 + SW expert에서 모의 SW 역량테스트로 검색해서 나오는 문제 모두 풀 수 있는 실력 이었습니다.

      • 3시간에 두 문제 풀어야 했으므로 문제푸는 시간을 꼭 체크했고 문제풀고 정리할만한 건 정리했습니다. (백준 삼성기출 풀고 혼자 끄적인 것)

      • 문제가 너무 많아서 거의 먹고 자고 풀고만 한달가량 했습니다.

      • KOI 초등부 문제도 난이도가 유사한 것 10개년 정도 풀었습니다.

    • LG 인적성

      • 하이닉스에서 공지 오기 전까지 SKCT 치는 줄 알고 SKCT 책으로 모의고사 한개, LG 인적성 모의고사 1개 풀어봤습니다.

      • 실제 LG 인적성에서 모의고사 한번 풀어봤던게 도움이 좀 되었습니다. (문제 유형파악하는데 시간이 덜 걸림)

      • SW직군으로 C문제 50분 JAVA문제 50분 인 직무문제를 풀었는데 C는 거의 다 맞춘 것 같았고 JAVA는 배워본 적이 없기 때문에 거의 다 틀렸을 것 같았습니다.

      • 직무 말고 다른 과목을 그렇게 잘치진 않았는데 H&A 사업부가 경쟁률이 낮았던 것 같아 합격했습니다.

    • SK하이닉스 코테

      • LG 인적성 다음날 오전 코테여서 잠만자고 바로 치러 갔습니다.

      • 잘은 모르지만 200명은 넘었던 것 같습니다.

      • 간식박스를 예쁘게 포장해서 준 게 인상깊었습니다.

      • 웹 환경이라 디버깅하는데 안 익숙한 점이 있었지만 크게 문제는 없었습니다.

      • 문제는 4문제 시간은 2시간 반이었습니다.

      • 1번부터 4번까지 점점 어려워지는데 4번도 삼성코테 중간정도 난이도보다 쉬웠던 것 같습니다.

      • 4문제 다 예전에 백준에서 풀어본 문제들이었습니다.

      • 작성한 코드로 코드리뷰한다는 소문이 있어 다풀고 30분정도 남았을 때 주석을 열심히 달았습니다. (변수이름과 인덴트를 더 깔끔하게 바꾸는게 주석다는 것 보다 좋음)

      • 풀고 나왔을 때 하이닉스 오픈카톡방에 3, 4솔(solve) 가 대부분이어서 3문제 컷이 될 것 같다는 의견이 많았습니다.

    • 삼성 코테

      • 정말 합격하고 싶었고 합격할 만큼 노력했다고 생각했습니다.

      • 전날 풀려고 쉬운 문제 2문제를 남겨뒀는데 한문제가 계속 안풀렸는데 결국 풀고 숙소에서 잤습니다.

      • 19년 상반기에 문제가 쉬웠고 A형 코테면제가 도입되어 2솔 컷이라는 소문을 들었습니다.

      • 하반기도 A형 코테면제여서 난이도와 크게 관계없이 2솔 컷이라고 예상했습니다.

      • 바나나랑 박카스 먹고 치러 갔습니다.

      • 2문제중에 1번째 문제가 2번째 문제보다 어려워 보였고 어짜피 2솔 목표였기 때문에 1번을 먼저 풀었습니다.

      • 1시간 정도걸려 제출했는데 시간초과가 떠서 20분 수정을 더해서 통과 했습니다.

      • 2번이 더 쉽고 시간은 절반 이상 남았으니 화장실 갔다와서 풀어야 겠다하고 여유롭게 갔다왔습니다.

      • 다 짜고 알 수 없는 버그가 자꾸 나서 결국 못풀었습니다.

      • 풀고 나와서 정말 상실감이 컸습니다. 오픈카톡방에는 쉬웠다는 카톡이 많아 보였고 A형 면제때문에 2솔 컷이라 떨어졌다고 생각하니 너무 아쉬웠고 내년에 또 해도 비슷할 것 같았습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

09/15 구슬탈출 2의 교훈

 

백준 정답률 24.7% 3537 / 24362

구현 난이도 꽤 았는 문제?? 로 누가 평가

 

일단, 끝까지 풀면 된다.는걸 알게되었고

최대한 반복할 수 있는 걸 염두해두고 코딩하는 것이 좋음. (그거 고민하느라 손도 못대는 건 가장 끔찍한 일이니 잘 고민하고)

끝까지 잡고 디버깅하면 풀리긴 풀린다. 더 꼼꼼하게, 테스트케이스 자기가 만들 수 있게 열심히하자

 

09/18 2048(easy) 의 교훈

 

3462 / 23508 23%

 

나눌 수 있는 만큼은 나누자 (k를 통해 나누던지 left right 최대한 공통적인 부분은 비슷한데 두어 같이 feedback 할 수 있게

 

초기화를 제때 잘해야한다.

 

09/18 뱀 교훈

 

65분소모 (노트알고리즘체크 8분)

logic별로 함수 만드는건 귀찮지만 매우 유효했다.

 

logic별로 나누니 어떤걸 어디에 배치해야할지만 고민하면 되어서 디버깅이 매우 쉬웠다. 이런 습관을 가지자

 

09/19 시험감독 교훈

 

45분소모 (노트알고리즘체크 4분)

long long...

정말 정답이라고 생각하면 자료형이 다를 수 있다는 것을 생각 선택지에 넣자.

 

09/19 주사위 굴리기 교훈

 

100분소모 (노트알고리즘체크 10분)

x, y좌표를 입력단부터 헷갈리게 할 수 있다..

row 는 행 (y의 개념. 위에서 떨어진 양)

col 는 열 (x의 개념. 왼쪽에서 떨어진 양)

명심

 

문제 잘 읽는 것 중요.

 

단위 나눠서 move, check 등 이렇게 나눠서 푸니까 굉장히 도움

 

09/19 테트리미노 교훈

 

82분 소모 (노트알고리즘체크 7분)

문제 제대로 읽지 못해 조건 못찾고 컴파일

너무 복잡한 코드 탓에 잘못한게 많음

 

09/20 퇴사 교훈

 

56분 소모 (노트알고리즘 5분)

코너케이스 잘 찾자.

유일한 기출중 dp였으나 완전탐색으로 처리 가능했음.

 

09/20 연구소 교훈

 

43분 소모 (노트알고리즘 3분)

무난하게 풀림. 순열 같은 것 잘 찾는 것 중요

next_permutation 여기서 쓰진 않았지만 사용법 알기

bitset도

 

09/20 로봇청소기

 

59분 소모 (노트알고리즘 3분)

무난하게 풀림.

논리정연하게 풀자. 이대로 되면 될 수 밖에 없는 것으로

함수화를 통해 그 논리를 생각하기 쉽게 하자.

 

09/20 연산자 끼워넣기

 

30분 소모 (노트알고리즘 8분)

순열로 쓰면 더 쉬웠을 수도

dfs로 순열 만들기를 했따. 계속 쓸 수 있게 익히던가 next_permutation 알기

 

09/21 스타트와 링크

 

52분 소모 (노트알고리즘 6분)

이것도 순열 잘 써야할듯

순열 10개 줄세워야하는 경우 있었음. 크기 순서 무시하면 메모리초과.

크기 순서 추가하는 방법은 dfs 진행될 때 인덱스 인자로 넣기 (1020 조합 말하는 것)

 

void find_cases(int start_idx, vector<int> temp) {

if (temp.size() == N / 2) {

cases.push_back(temp);

return;

}

for (int i = start_idx+1; i < N; ++i) {

if (visited[i] == false) {

visited[i] = true;

temp.push_back(i);

find_cases(i, temp);

temp.pop_back();

visited[i] = false;

}

}

}

 

09/22 경사로

 

58분 소모(노트알고리즘 5분)

노트알고리즘을 너무 간단히 했다.

여기도 상승과 하강 두가지 경우 있는데 하나의 for문으로 합치는 걸 해보면 좋겠다.

좀더 검증 잘 해서 했으면 더 빨리 끝났을 듯. 디버깅만 30분

 

09/22 톱니바퀴

 

39분 소모(노트알고리즘 5분)

무난하게 했다. 경우의수를 너무 나누긴 했지만 적당한 정도였다. 남들어떻게했는지 한번 볼 필요는

 

09/23 감시

 

65분소모(노트알고리즘 8분)

알고리즘이 맞다면 정확한 코딩으로 구현가능

머리속으로 대충 때려맞추지 말고 제대로 검증하고 구현하자.

 

09/23~09/24 사다리조작

 

10시간은 쓴듯

시간줄이기도 신경써야하고 (가지치기방식으로)

애초에 심각한 for문 문제 있었다. -> y먼저 체크하는 거였는데 x로갈때 y가 0부터 다시 경우의수를 셈. 여기서 가지치기위해 y=sy같은 걸 해서 0~sy-1까지 무시해서 답이 틀림

다시금 느끼는건 알고리즘이 맞았으면 코드가 잘못되었다. 디버깅 잘 할 수 있는걸 염두해서 짜야한다. 코드 짜는데 20분 더 걸려도 디버깅 잘 할수 있게 짜놔야

3시간안에 디버깅이 가능하다.

 

09/25 회전하는큐 (not 기출)

 

쉬운문제인데도 1시간 20분정도 사용

index 대충 머리속으로 이렇게하면되겠지? -> 무조건 틀린다

항상 손으로 정리하고 검증하는 습관. 제발 가지자. 이게 아니면 무조건 통과 못한다.

 

09/25 연산자 끼워넣기(2) (not 기출)

 

40분소모

max_min 이 10억 -10억 인데 999999999 라고 함(9억)

 

09/25 외판원 순회2 (not 기출)

 

20분소모

 

09/25 드래곤커브

 

노트알고 20분 총 75분

문제굉장히 어려울 것 같았는데 일단 답은 무조건 구할 수 있다는 생각으로 규칙을 찾았다.

규칙대로 그대로 정확하게 구현하려 하니까 한번에 구현이 된 듯.

중간중간 디버그 용이하게 print 문과 print용 함수도 잘 구현함.

 

09/25 치킨배달

 

노트알고 8분 총 24분

조합 뽑고 그대로 시뮬레이션. 그렇게 어렵지 않은데 드래곤커브보다 정답률을 낮았다.

특이한 것은 먼저 조합알고리즘 정리후 구현 -> 다음 문제 정답을 위한 구현 방법으로 접근

나쁘지 않았다.

 

09/26 큐빙

 

3시간 23분

무식한 구현문제. 중간 인덱스 틀려서 계속 문제 생겼음.

디버깅하기도 엄두가 안나서. 큐브 좌표계 디버깅위주로 작성하는 것도 괜찮아 보임.

좌표를 종이에 다 써넣고 생각하는 게 특이점.

눈으로 디버깅 잘하자.

 

09/26 나무재테크

 

57분

생각한대로 구현하면 되는 무난한 문제였음.

봄여름가을겨울 있는데 봄,여름 사이에 디펜던시가 없고 가을 겨울끼리 마찬가지여서 함께 묶어 구현했다는 것이 특이점.

 

09/26 아기상어

 

2시간 14분

dfs로 했다가 시간초과, bfs로했다가 메모리초과. 조건 하나 잘못봐서 while 종료조건을 생각해놓고도 그대로 동작하지 못해 시간을 많이 날림.

생각한 건 종이에 정리하거나 제대로 구현되었는지 확인하는 습관.

일단 이건 메모리 다른사람보다 훨씬 많이 써서 한 경우라 다른사람 코드 확인이 필요함.

 

10/18 아기상어 2번째 1시간

다시 푸니까 너무 쉽다. 위의 시도에서는 메모리, 시간 많이 썼는데 두번째에선 0ms 에 메모리 최소 사용했다.

실력이 늘긴 는듯

 

 

09/27 한윤정이 이탈리아에 가서 아이스크림을 사먹는데 (not기출)

 

20분

dfs 중간 최적화가 필요했음.

순열 이나 조합 넣을 때 1 ,2 3 이라면 탐색 vector에 3,2,1 로도 넣어주어야 모든 경우를 찾을 수 있다.

 

09/27 인구이동

 

22분

하라는 대로 하면 무난히 구현되는 문제.

 

09/27 미세먼지 안녕!

 

57분

좌표계 잘 써야

특이점은 미세먼지확산, 공기청정기 작동 두가지 동작으로 나뉘는데

완전히 분리해서 만들어서 확산 디버깅 다로 공기청정기 따로 디버깅 했다는게 특이점. 매우좋은방법.

 

하나 주석치고 잘 동작하는지 확인하면서 check

 

 

09/27 낚시왕

 

83분

크게 두가지로 나눌 수 있었음. 문제에서 나와있었기 때문에 쉽게 나눌 수 있었음. 안그런 문제라도 그렇게 나누자.

좌표 1부터시작하는지 0부터 시작하는지,

vector empty 되는 타이밍 언제인지

 

cmp함수 짠 것도

 

 

참고.

 

09/28 이차원 배열과 연산

 

54분

시키는 대로 구현하면 되었었음.

1중포문안의 sort는 데이터 사이즈가 100 이내일때 0ms 의 결과가 나올 정도로 써도 용이해보임

 

09/28 연구소3

 

3시간

시간초과때문에 힘들었다. 가지치기가 핵심. 가장 크리티컬한 요소를 찾고 그걸 해결할 방법 생각. A형 수준이면 알고리즘이 필요한 게 아니라 간단한 아이디어가 중요

처음 bfs로 구현, 더 좋은 아이디어 같아 dfs로 구현, -> 더 느렸음

이후 질문검색에서 나는 2중포문을 돌면서 바이러스가 퍼지지 않은 곳을 찾아 비효율적이었는데

bfs가 방문한 횟수를 세서 방문횟수랑 빈공간이랑 일치하면 다 돈것으로 판단하는 효율적인 것을 봄.

바로 내 것에 적용하긴 힘들어서 최소 빈공간 만큼와 일치하거나 더 많이 일치하면 2중포문을 돌며 체크하는 원래 함수를

쓰도록 가지치기함.

 

09/28 괄호 추가하기

 

1시간 30분

생각보다 복잡하게 생겼는데 논리적으로 맞게 작성하니까 제대로 돌아갔다.

특이한 점은 9^10 을 곱하면서 오버플로우가 날 수 있다.

또 최댓값 구하는 문제인데 초기값을 -1로 주고 만약 값이 음수가 최댓값이 될 수 있으므로 -1이나오면 이부분 생각해보자.

 

 

09/28 파이프 옮기기1

 

40분

구현하는 대로 구현하면 됨. 특히 오른쪽 아래방향으로만 진행하기 때문에 visited 도 필요없고 쭉 진행하게 두면 dfs 가 알아서 찾아주었음.

특이점은 pipe이동경로에서 애매한 부분이 있었기 때문에 for문화 시키지 못하고 일일히 구현. 하지만 양이 적은 것을 알고 있었기 때문에 의식하고 짠 것임. 더 좋은 코드 참고해보기

 

09/29 캐슬 디펜스

 

65분

 

아래와 같이 기능별로 구분이 되는 코드를 짜서 디버깅이 쉬웠음.

  • 같은 거리일 때 왼쪽 우선순위가 있었는데 bfs 탐색 순서를 dx, dy배열을 통해 왼쪽 먼저 탐색하도록 하고 돌린 결과 따로 왼쪽이 먼저인지 구현 안해도 올바르게 작동함.

  •  

    이건 이 수식 구현하라는게 아니라 bfs 탐색 순서대로라면 자연스럽게 depth가 거리가 된다는 것을 알게됨.

 

 

 

 

 

09/29 색종이 붙이기

 

3시간.

 

  • 뭔가 꼼수처럼 브루트포스를 쓰지 않고 더 효율적인 방법을 찾는 것은 삼성 문제에 맞지 않음. 반례가 있기마련

  • 여기서는 왼쪽위부터 가장 큰 색종이를 먼저 붙이면 될 것으로 생각. 25퍼에서 컷

  • 그래서 왼쪽위와 아래오른쪽 에서 탐색하는 걸 찾음 50퍼에서 컷.

  • 모든 경우의 수를 다 따져야 해서 모든 조합을 생성 후 하나 씩 돌림 (매우 비효율적으로 안돌아감)

  • 방법은 매 좌표마다 판단을 하는 것. 중요함

 

09/30

 

94분

  • 간단한 문제였지만 뭔가 말렸다.

  • 8개 숫자중에서 8개 순열 구하는 건 1초 시간내에 충분했다.

  • 거기서 시간초과가 날 것이라 먼저 염려하고 다른 방법 강구하다가 이 다른방법이 꼼수에 가까워 진다는 것을 보고 포기했다.

  • 다시 원래 모든 경우를 탐색하는 방법을 생각해보니 딱히 문제될 건 없었다.

  • system("pause") 혹은 cin 을 통해 pause를 걸고 확인해 보았다.

  • 테스트케이스하나를 온전히 프로그램으로 돌려보면서 에러부분을 찾았다. 여기선 변수 초기화 타이밍을 놓친 것.

 

09/30 Brain_fuck interpreter (실패)

  • 잘 디버깅하면 될 것 같지만 뭔가. .복잡하고 못할 것 같은 기분

  • 나중에 다시 해보자

 

10/1 배열 돌리기4 85분

  • 찬찬히 잘 하니까 되었다.

  • 처음에 배열 돌리는 걸 바깥 가장자리만 돌아가게 생각해서 망했다 했는데 모듈화를 잘 시켜서 size만 1씩 감소시키는 걸로 처리가 가능했음. 모듈화 핵심

  •  

10/1 게리맨더링 210-85 = 135분

  • 코너케이스 잘 생성하기

  • 디버깅 정말 오래 걸렸다. 함수 기능별로 구현해 두고 하나하나 보면서 뭐가 잘못되었는지 명확하게 따지자.

  • 코너케이스 가지고 찾는게 좋다.

  • cin도 많이 사용.

 

10/18 다리만들기2 116분

  • 생각하는 그대로 구현하기

  • 디버깅은 체계적으로.

 

10/1 Brain_fuck interpreter 성공

  • 조건에 대해서 굉장히 간단하게 구현할 수 있는 문제였지만 생각을 덜 해서인지 시간이 촉박해서인지 그렇기 하지 못했다.

  • 정말 아이디어가 중요한 문제였다. 그렇지 않으면 계속 복잡해진다.

  • 모든 조건을 완벽하게 맞춰야 하기 때문에 가장 간단하고 확실한 방법을 생각하자.

 

10/1 숫자고르기 KOI

  • 사이클찾기

    • int 로 visited를 한다음 첫 시작점 dfs에 넣어주고 visited == 2 되면 한 사이클 돈 것으로 침

    • 애초에 이런 유형 나올거라 생각도 못해서. 사이클도 답 찾는 관점 안에 넣어두자

 

10/2 아맞다우산 A형대비 BFS+빡구현 81분 30초

  • 최단거리 탐색은 두가지 방법이 생각난다.

    • 1. dfs로 모든 경우 다 찾은 후 depth작은걸로

    • 2. bfs로

    • 무조건 bfs로 접근하려 하자. 시간차이난다.

  • 간단하게 DP 적용할만한 포인트가 있어 적용했다.

 

10/2 아맞다우산 A형대비 BFS+빡구현 60분

  • 사이클 느낌 나면 dfs로 사이클 찾아야 한다.

  • bfs로 사이클 찾는 방법도 알아두면 혹시 모를 때 유용할 듯

  • 깊이 우선 검색은 폭 넓은 첫 번째 검색보다 메모리 효율이 높으므로 더 빨리 되돌릴 수 있습니다. 또한 호출 스택을 사용하는 경우 구현하기가 더 쉽지만 스택 오버플로가 발생하지 않는 가장 긴 경로에 의존합니다.

  • 위와 같으므로 굳이 찾을 필요는 없을 듯

 

10/2 움직이는 미로탈출 A형대비 BFS+빡구현 24분

  • 정답률 24%에 푼사람도 별로 없어서 긴장하고 풀었는데 쉽게 풀림

 

  • #이 벽인데 이 벽에 닫지 않게 왼쪽맨아래부터 오른쪽 맨위로 도달해야 1을 출력하는 문제

  • 백트래킹을 테이블 전체로 적용. 벽을 한번 내렸다가 백트래킹 타이밍에 다시 벽을 올리는 코드를 적용

  • visitedcheck가 까다로웠을 법 한데 왜냐하면 방문한 곳 여러번 방문해야 하기 때문.

  • 그 방문한 것의 최대값이 모든 벽이 다 꽉차있을 때(사람이 위치하는 좌표 col만 제외) 로 생각, 한곳에 7초과로 머물필요는 없다.

  • 이걸 visited 조건으로 추가하니 풀림.

 

10/2 움직이는 미로탈출 A형대비 BFS+빡구현 24분

  • 정답률 24%에 푼사람도 별로 없어서 긴장하고 풀었는데 쉽게 풀림

 

  • #이 벽인데 이 벽에 닫지 않게 왼쪽맨아래부터 오른쪽 맨위로 도달해야 1을 출력하는 문제

  • 백트래킹을 테이블 전체로 적용. 벽을 한번 내렸다가 백트래킹 타이밍에 다시 벽을 올리는 코드를 적용

  • visitedcheck가 까다로웠을 법 한데 왜냐하면 방문한 곳 여러번 방문해야 하기 때문.

  • 그 방문한 것의 최대값이 모든 벽이 다 꽉차있을 때(사람이 위치하는 좌표 col만 제외) 로 생각, 한곳에 7초과로 머물필요는 없다.

  • 이걸 visited 조건으로 추가하니 풀림.

 

 

10/2 성곽 A형대비 BFS+빡구현 50분

  •  

  • 이게 시간초과 안났다 2초 제한에 376ms로 통과

  • M, N 제한이 50미만인데 50^4 에 dfs한번씩하는 시간인데 테스트케이스가 양반으로 나온듯

 

 

10/2 Maaaaaaaaaze A형대비 순열과 조합 97분

  • 3차원 벽을 훑는 줄 알고 이상한 고민을 많이 함. (실제 그런 구현이 나오면 어떡하냐)

  • 판때기돌리는 것 매우 비효율적으로 노가다 했음 (15분정도 걸림) 그래도 한번에 신뢰할 수 있는 값이 나옴.

  • 판크기가 5x5니까 가능했지 그 이상이면 비효율일수도.

  • 이것도 시간초과가 날 듯 한데 안났다. 실제 피시로 돌렸을 때 실제시간으로 시간초과라도 그건 프로세서 점유하는 시간 따라 차이나니 채점 서버에선 다를 수 있다.

  • 빡구현이었다.

 

 

10/2 Baaa aaaaaaduk2(Easy) A형대비 순열과 조합 51분

  • 정말 많은 cout 을 통해 디버그를 하나하나 잡아가며 해결한 문제.

  • dfs 조건 맞을 때 바로 나가게 해버리면, 들어온 조건에 대해 visit을 적당히 진행하고 남겨두고 나가기 때문에 제대로 안됨. 바로탈출하는건 시간 크리티컬 하거나 상황 잘 고려해서 하기.

 

 

 
#include <iostream>
#include <vector>
#include <set>
using namespace std;
struct Node {
        int val;
        Node *left;
        Node *right;
        Node() {
               val = 0;
               left = NULL;
               right = NULL;
        }
};
string preorder(Node *root) {
        string ans = "";
        //V는 방문하지 않은 노드를 방문할 때 쓰는 check
        ans += "V";
        if (root->left) {
               //L은 left방문하지 않았을 때 방문하면서 ch
               ans += "L";
               ans += preorder(root->left);
               //l은 방문한 노드를 방문할 때 쓰는 ch
               ans += "l";
        }
        if (root->right) {
               ans += "R";
               ans += preorder(root->right);
               ans += "r";
        }
        //방문한 노드를 방문할때 쓰는 v
        ans += "v";
        return ans;
}
void remove(Node *root) {
        //root의 왼쪽자식이 있으면 그것부터 지우러간다.
        if (root->left) {
               remove(root->left);
        }
        if (root->right) {
               remove(root->right);
        }
        delete root;
}
int main(void) {
        ios_base::sync_with_stdio(false);
        cin.tie(NULL);
        int n, m;
        cin >> n >> m;
        set<string> s;
        for (int k = 0; k < n; ++k) {
               vector<int> a(m);
               for (int i = 0; i < m; ++i) {
                       cin >> a[i];
               }
               Node *root = new Node;
               root->val = a[0];
               for (int i = 1; i < m; ++i) {
                       Node *cur = root;
                       while (true) {
                               // 비교하는 값보다 노드가 더 크면 왼쪽에 넣어야 한다.
                               if (cur->val > a[i]) {
                                      //왼쪽에 넣어야하는데 비었으면 그자리가 자기자리다.
                                      if (cur->left == NULL) {
                                              cur->left = new Node;
                                              cur->left->val = a[i];
                                              break;
                                      }
                                      //그렇지 않다면 왼쪽으로 계속 탐색한다.
                                      else {
                                              cur = cur->left;
                                      }
                               }
                               else if (cur->val < a[i]) {
                                      if (cur->right == NULL) {
                                              cur->right = new Node;
                                              cur->right->val = a[i];
                                              break;
                                      }
                                      else {
                                              cur = cur->right;
                                      }
                               }
                               else {
                                      break;
                               }
                       }
               }
               s.insert(preorder(root));
               remove(root);
        }
        cout << s.size() << '\n';
        return 0;
}


#include <iostream>
#include <set>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int main(void) {
        set<string> s;
        int a, b;
        cin >> a >> b;
        string input;
        vector<string> output;
        for (int i = 0; i < a; ++i) {
               cin >> input;
               s.insert(input);
        }
        for (int i = 0; i < b; ++i) {
               cin >> input;
               if (s.insert(input).second == false) {
                       output.push_back(input);
               }
        }
        cout << output.size() << endl;
        sort(output.begin(), output.end());
        vector<string>::iterator it;
        for (it = output.begin(); it != output.end(); ++it) {
               cout << *it << endl;
        }
        return 0;
}






#include <iostream>
#include <set>
#include <cstring>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
string must, up, down;
int n;
int upsize;
int downsize;
int dp[1001][1001][2];
//bool upgo => True이면 다음에 up을 돌아야 한다는 것
int go(int idx, int mustidx,bool upgo) {
        if (mustidx == n) {
               return 1;
        }
        int& ret = dp[idx][mustidx][upgo];
        if (ret != -1) {
               return ret;
        }
        ret = 0;
        for (int i = idx + 1; i < upsize; ++i) {
               if (upgo && must[mustidx] == up[i]) {
                       ret += go(i, mustidx + 1, false);
               }
        }
        for (int i = idx + 1; i < downsize; ++i) {
               if (!upgo && must[mustidx] == down[i]) {
                       ret += go(i, mustidx + 1, true);
               }
        }
        return ret;
}
int main(void) {
        memset(dp, -1, sizeof(dp));
        cin >> must >> up >> down;
        int ans = 0;
        n = must.size();
        upsize = up.size();
        downsize = down.size();
        for (int i = 0; i < upsize; ++i) {
               if (must[0] == up[i])
                       ans += go(i, 1, false);
        }
        for (int i = 0; i < downsize; ++i) {
               if(must[0] == down[i])
                       ans += go(i,1,true);
        }
        cout << ans << endl;
        return 0;
}

  • top-down은 다음에 해보자. 오랜만의 botton-up
  • 맨처음 case는 1,1,1 
  • 다음부터 cache[N][L][R]은 이전 정보를 받아온 다음 마지막 길이 1번건물을 어디에 놓냐만 생각하면 된다. 
  • cache[N - 1][L - 1][R] 이 식은 오른쪽에 1을 놓았다고 생각해서 이전정보에서 더해주는 것
  • cache[N - 1][L][R - 1] 이식은 반대로 왼쪽에 1을 놓았다고 생각한 것
  • cache[N - 1][L][R] * (N - 2) 이것은 양 끝을 제외하고 1을 놓았다고 생각한 것. 그래서 L과 R에 변화가 없다. 

#include <iostream>
using namespace std;
long long cache[101][101][101];
int main(void)
{
        int n, l, r;
        cin >> n >> l >> r;
        cache[1][1][1] = 1;
        for (int N = 2; N <= n; ++N) {
               for (int L = 1; L <= l; ++L) {
                       for (int R = 1; R <= r; ++R) {
                               cache[N][L][R] = cache[N - 1][L - 1][R] + cache[N - 1][L][R - 1] + cache[N - 1][L][R] * (N - 2);
                               cache[N][L][R] %= 1000000007;
                       }
               }
        }
        cout << cache[n][l][r] << endl;
        return 0;
}



#include <iostream>
#include <vector>
#include <cstring>
using namespace std;
vector<pair<int, int>> coin;
int cache[10001][101];
int n;
int money;
int go(int cash, int idx) {
        if (cash == 0) {
               return 1;
        }
        if (idx >= n) {
               return 0;
        }
        int& ret = cache[cash][idx];
        if (ret != -1) {
               return ret;
        }
        ret = 0;
        for (int i = 0; i <= coin[idx].second; ++i) {
               if (cash - (coin[idx].first * i) >= 0)
                       ret += go(cash - (coin[idx].first * i), idx + 1); // 다음 코인 쓰러 간다.
        }
        return ret;
}
int main(void)
{
        memset(cache, -1, sizeof(cache));
        cin >> money;
        cin >> n;
        for (int i = 0; i < n; ++i) {
               int a, b;
               cin >> a >> b;
               coin.push_back(make_pair(a, b));
        }
        cout << go(money, 0);
        return 0;
}


//절대값이 같은 음수, 양수가 있으면 음수가 더 위에 있어야 한다.
#include <iostream>
#include <queue>
#include <functional>
#include <vector>
#include <algorithm>
#define abs(a) (a>0 ? a : -a)
using namespace std;
vector<int> heap;
void push_heap(vector<int>& heap, int newValue) {
        heap.push_back(newValue);
        int idx = heap.size() - 1;
        while (idx > 0 && (abs(heap[(idx - 1) / 2]) > abs(heap[idx]) || ((abs(heap[(idx - 1) / 2]) == abs(heap[idx]) && heap[(idx - 1) / 2] > heap[idx])))) {
               swap(heap[idx], heap[(idx - 1) / 2]);
               idx = ((idx - 1) / 2);
        }
}
void pop_heap(vector<int>& heap) {
        heap[0] = heap.back();
        heap.pop_back();
        int here = 0;
        while (true) {
               int left = here * 2 + 1, right = here * 2 + 2;
               if (left >= heap.size()) {
                       break;
               }
               int next = here;
               if (abs(heap[next]) > abs(heap[left])) {
                       next = left;
               }
               else if (abs(heap[next]) == abs(heap[left]) && heap[next] > heap[left]) {
                       next = left;
               }
               if (right < heap.size() && abs(heap[next]) > abs(heap[right]))
                       next = right;
               else if (right < heap.size() && abs(heap[next]) == abs(heap[right]) && heap[next] > heap[right]) {
                       next = right;
               }
               if (next == here)
                       break;
               swap(heap[here], heap[next]);
               here = next;
        }
        
}
int main(void) {
        int n;
        cin >> n;
        for (int i = 0; i < n; ++i) {
               int k;
               cin >> k;
               if(k!=0)
                       push_heap(heap,k);
               else {
                       if (!heap.empty()) {
                               cout << heap[0] << endl;
                               pop_heap(heap);
                       }
                       else {
                               cout << 0 << endl;
                       }
               }
        }
        
        return 0;
}


//절대값이 같은 음수, 양수가 있으면 음수가 더 위에 있어야 한다.
#include <iostream>
#include <queue>
#include <functional>
#include <vector>
#include <algorithm>
#define abs(a) (a>0 ? a : -a)
using namespace std;
int main(void) {
        ios_base::sync_with_stdio(false);
        cin.tie(NULL);
        priority_queue<int, vector<int>,greater<int>> minh;
        priority_queue<int, vector<int>,less<int>> maxh;
        int n,input;
        cin >> n;
        for (int i = 0; i < n; ++i) {
               cin >> input;
               if (minh.size() == maxh.size()) {
                       maxh.push(input);
               }
               else {
                       minh.push(input);
               }
               if (!maxh.empty() && !minh.empty() && maxh.top() > minh.top()) {
                       int a = maxh.top();
                       int b = minh.top();
                       maxh.pop();
                       minh.pop();
                       maxh.push(b);
                       minh.push(a);
               }
               cout << maxh.top() << '\n';
        }
        return 0;
}

+ Recent posts