언제쯔음

[서평 리뷰] 이펙티브 파이썬 3판 - 길벗

susuhana — Wed, 22 Apr 2026 22:00:43 +0900

- 길벗 출판사에서 도서를 제공받아 서평을 진행합니다 -

AI가 강세를 보여주고 있는 지금, 뭐가 중요한지 모르겠는 상황이 진행되고 있다. AI 도구를 이용한 개발을 진행하면 무언가 잘못되고 있다는 느낌이 들고 있을 때가 한번쯤 있었다. 그 이유는 여러가지가 된다. 첫번째로 비개발자와 함께 무언가를 하기 위해 익숙하지 않은 파이썬을 쓰고 있었다. 두번째로 파이써닉하다는 들었지만, 기존에 익숙한 언어를 생각하며 쓰고 있었다.

결국 파이썬을 잘 몰라서 발생하였지만, 정확히는 파이썬을 효과적으로 쓰고 있지 못 해서다. 비개발자와 함께 파이썬을 제대로 쓰고 싶단 생각에 이 책을 제공 받아 읽게 되었다.

이 책은 아이템이란 항목으로 구성되어 있기에 처음부터 끝까지 읽는 정방향이 아니다. 원하는 항목을 찾아서 읽으면 그만이다.

처음 부분이 "파이썬답게 생각하기"이다. 이 부분에서는 왜 파이썬스럽게 못 쓰는지에 대한 설명을 해주면서 언어의 특성을 이야기 해준다. 이 부분이 납득되면서 스크립트 언어들이란 너무 자유도가 높아서 문제가 많다는 생각이 든다. 파이썬을 배우긴 했지만, 너무 겉핥기로 배웠는지 모르는 내용들도 꽤나 많았다. 이런 내용들을 보면 이렇게까지 해서 파이썬을 써야 하나는 자괴감도 들기도 한다. 다만, 다른 언어와도 일맥상통한 부분은 동일했다. 특이한 코드는 가독성을 방해한다. 파이썬은 특히 자유도가 높아서 코드가 괴랄해지고, 편하기도 하다. 그리고 없는 문법들로 인해 타 언어처럼 쓰는 방법도 알 수 있었다.

코딩 테스트보다는, 진짜 이 언어를 어떻게 쓰면 좋을지, 어떻게 써야 하는지, 이렇게 써야 한다는 이야기를 많이 해준다.

만약에 파이썬을 업으로 삼고 있다면, 이 책을 한번쯤 봐야하지 않을까 싶다.

외국은 모르겠지만, 한국에서 파이썬은 초보자와 데이터 쪽에 특화되어 그런 책만 있다. 진짜 프로그래머로써의 파이썬을 쓰는 방법이 없다. 그래서 쓰기 쉽겠지만, 잘 쓰고, 다른 사람과의 협업을 잘하려면 이런 내용 등이 체화되어 있어야 한다고 생각된다.

앞서 이야기한 비개발자와 파이썬을 같이 쓰고 싶어서 이 책을 골랐고 읽었다. 목표에 맞는 책이었고, 한국에서 유일한 책인것 같다.

AI가 모든 일을 할 세상이 아니면, 이런 내용들을 체화해서 AI 쓸 때 활용할 수 있을 것 같다.

[서평 리뷰] 그림과 실습으로 배우는 쿠버네티스 입문 - 길벗

susuhana — Sat, 8 Nov 2025 06:02:46 +0900

쿠버네티스를 왜 배워야 하는가? 직접 운영에서 써본 적이 없어서 와닿지 않는 그런 기술들, 카프카, 엘라스틱 서치, 그라파나 등과 같이 많다. 하지만 역설적이게도 써보지 않으면 모른다. 와닿지 않지만 와닿기 위해 써봐야한다. 이 책은 쿠베 감각을 키우기 위해 트러블을 만들고, 고치면서 습득하도록 하고 있다. 이건 트러블 슈팅을 통한 쿠버네티스 습득이라고 재정의할 수 있다.

책에 대한 기대와 아쉬운 점

그림과 실습 != 만화

책 표지에 귀여운 고양이와 물개가 있다. 또한 만화 형식으로 표지를 구성하고 있다. 책 내용도 만화라고 생각했는데 그건 "만화로 배우는" 시리즈였을 것 같다. 그래서 만화가 각 장을 시작하기 전에 한 페이지씩 있지만, 각 설명에 필요한 개념에 대한 그림들이 있다. 그래도 그 페이지가 너무 귀여워서, 다시 한번 눈길이 간다.

Drilling?

TopDown? BottomUp? 무엇으로 표현해야 할지 모르겠지만, 드릴마냥 깜깜한 땅을 파면서 지식을 얻어가는 느낌이다. 어찌보면 다이아를 찾는 여정은 다이아를 찾았을 때 행복하지만, 다이아가 x, y 어느 지점에서 많이 나오는지 궁금해지는 건 한국인이다. 그래서 리소스가 무엇이 있는지 장표를 하나 보고 싶단 생각이 들었다. 적어도 리소스가 전체적으로 몇가지인지 알고 가고 싶었다. 아쉽게도 끝까지 읽으면 얼추 알 수 있지만, 이런 부분은 좀 더 자세한 책을 읽어야 하거나 공식 문서를 봐야 한다.

이 책은?

쉽게 다가갈 수 있는 책

나는 자랑은 아니지만, 꽤나 많은 도커 책과 쿠버네티스 책을 읽었다. 탁상공론과 같이 실제로 쓰지도 않으면서 읽기만 하니까 실력이 늘리가 없었다. 뻔히 알면서 왜 도전하지 못했는가?

1. 쿠버네티스의 도구들을 무엇을 골라야 하는지 잘 몰라서
2. 도구를 골라서 실행해보니 컴퓨터에 렉이 걸려서
이 책을 읽기 전에 메모리를 32GB로 올렸더니, 실습 진행 시 메모리가 20GB 근처에서 놀고 있었다.
3. 쿠버네티스 명령어를 쓰는데 내가 무엇을 하는지 몰라서
4. 운영에서 못 써보는 기술을 왜 배우는지 현타가 와서
5. 도커로도 충분히 만족하고 있어서
6. 테라폼이 무엇인지 궁금해서
7. 클라우드 컴퓨팅의 하드한 내용에 압도되어서

이 책은 목표는 마음을 쉽게 먹을 수 있도록 하고, 쉽게 다가갈 수 있도록 도와주는 책이다.

좋은 마인드를 가진 책

잘하고 싶은 마음에, 자꾸 이해 못하고 하니 주눅 들며 기피하게 되고 안 하게 된다. 그런데 책에서는 자꾸 망가뜨리자고 권유한다. 결국 고쳐서 잘만 돌아가면 그만이다. 이런 마인드 덕에 마음이 편해진다. 그래서인 전체적인 내용에 대한 설명은 하지 않고 하나씩 설명해나가는게 납득도 된다.

책의 구성

1장부터 3장은 기초적인 쿠버네티스에 들어가기전 사전 지식이고, 4장부터 6장까지는 쿠버네티스 학습이다. 7장-8장은 배운 지식을 통해 응용하는 단계이다. 9장부터 12장은 더 나아아기 위해 필요한 지식을 주는 장이다.

백준 계단오르기, DP 기본 지식 2일차

susuhana — Thu, 6 Feb 2025 20:52:39 +0900

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

https://koolreview.tistory.com/180

설탕배달, DP 기본 지식 1일차

DP 문제임을 알고 풀며, DP 문제 풀이 방식에 익숙해지기 위해 해당 글을 씁니다. 해당 문제는 수학적으로도 해결이 가능하기도 합니다. 다만 완전 탐색(브루토포스)으로 해결이 가능하다는 점을

koolreview.tistory.com

DP 2일차, 사실 이 문제도 옛날에 풀었던 문제이지만, 그 당시에는 너무 어려워서 꽤나 괴로웠다. 그리고 정답 코드를 보고 너무 간단해서 좌절감을 느꼈었던 것 같다.

지금의 나는 이전보다 많이 달라졌으니, 시작해보자.

문제 위와 같은데 눈 여겨 볼만한 점은 3가지다.

1. 1단계씩 올라가기, 2단계씩 올라가기
2. 연속된 세 칸 밟기
3. 마지막 계단 밟기.

문제를 잘 읽으면, 1단계식 계속 올라가면 모든 점수를 얻을 수 있으니 제일 큰 값이다. 그런 경우를 막기 위해서 연달아서 3칸은 밟으면 안 되다는 조건이 달리고, 2단계식 올라갈 수 있는 선택지도 늘어났다고 생각해도 된다.

이전 글에서 이야기했듯이 이 문제도 완전탐색으로 해결이 가능하다.

먼저 처음에 선택할 수 있는 경우는 첫번째 칸, 두번째 칸이다.

파란색은 연속되어서 정답이 될 수 없다.

익숙하지 않은 개념이 하나 나온다. 연속되면 안 된다.우린 연속되지 않았다는 사실을 코드로 어떻게 표현할 수 있을까?

간단하다. 진짜 숫자가 연속되지 않으면 된다. -> ?

선택지를 고를 때 보자.

무조건 첫번째를 선택한다고 가정했을 때 위처럼 2가지 경우가 생긴다. 왜 생기냐는 질문은 단순한 답이 있다. 최대한 많이 고르면 점수가 높다. 왜냐 각 요소들은 음수를 가지지 않지지 않기 때문에 무조건 많이 골라야 한다. 그렇기 때문에 위와 같이 고르는 경우가 제일 득점이 높다.

그렇다면 이를 코드를 어떻게 나타낼까? 아래와 같이 나타낼 수 있겠다.

다만 순방향으로 가면서 4개의 요소를 한번에 선택해서 계산해나가면 뭔가 안 맞는 느낌이 들 것이다.

이런 느낌은 이전 문제에서도 있었다. 재귀는 내려갔다가 다시 올라면서 값이 합쳐지면서 반환하게 된다.

그렇기 때문에 순방향으로 지나가면서 이전 값을 확인해야 한다.

그래서 아래와 같은 코드가 나오게 된다.

아직도 익숙하지 않다면 내일 또 봅시다. 아직도 1차원 상태라서 2차원으로 넘어가야 합니다!

설탕배달, DP 기본 지식 1일차

susuhana — Wed, 5 Feb 2025 23:05:38 +0900

DP 문제임을 알고 풀며, DP 문제 풀이 방식에 익숙해지기 위해 해당 글을 씁니다.

해당 문제는 수학적으로도 해결이 가능하기도 합니다. 다만 완전 탐색(브루토포스)으로 해결이 가능하다는 점을 눈 여겨 봐야 합니다.

주먹구구식 방식으로 해결이 가능하다는 점과 문제를 재귀로 해결이 가능하다는 점을 보았을 때 중첩된 하위 구조의 특징을 가지고 있다는 점을 알 수 있고, 이를 통해 DP로 해결이 가능하다는 점을 알 수 있습니다.

중첩된 하위 구조를 가지고 있다는 것을 어떻게 알 수 있을까요? 재귀를 타고 내려감에 따라 호출된 똑같은 값이 있다면 이전에 계산된 값을 쓰면 되기에 최적화가 가능합니다.

DP의 첫번째글이니까 더 적어 보려 합니다. 이름이 왜 DP일까요?, 흔히 말하는 DP 테이블, 메모제이션이 있다고 해서 DP 문제일까요? 아닐까요? 아닙니다. 정답을 찾아가는 도중에 상태를 보고 선택을 하기 때문에 동적 프로그래밍이라고 이름을 지엇다고 생각합니다.

잡설은 그만하고, 설탕 문제를 한번 볼까요?

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

눈여겨볼만한 점은 다음과 같습니다.

1. 정확한 N 킬로그램을 배달한다.
2. 최대한 적은 봉지를 들고 간다.
3. 설탕 공장에서 만드는 설탕은 3kg, 5kg 봉지

여기서 선택할 수 있는 요소는 무엇일까요? 바로 3kg, 5kg 봉지입니다. 그렇다면 상태는 무엇일까요? 현재 선택한 설탕의 무게임을 유추해볼 수 있습니다. ? 를 띄울 수 있지만 문제 내용도 없고, 선택할 요소도, 상태가 될 만한 요소도 거의 없다는 점을 생각한다면 소거법에 의해서도 무게임을 추측해볼 수 있습니다.

상태 -> 무게 w
선택 -> 3kg, 5kg

이제 이를 완전 탐색으로 내려 가봅시다.

루트 노드는 설탕의 무게를 0을 나타내고 있고, 왼쪽/오른쪽 자식은 선택에 따라 내려감을 나타냅니다.
색을 칠한 요소는 중복된 요소를 나타냅니다.

그렇기 때문에 중복된 요소를 계산을 굳이 또 할 필요도 없기도 하고, 현 문제는 간단한 문제이지만 복잡한 문제인 경우 하나의 연산이 무거워질 수록 중복된 연산은 이미 계산된 내용을 기반으로 재활용한다면 최적화가 이루어집니다.

그리고 이렇게 중복된 하위 문제가 나오는 것을 중첩 하위 구조임을 알 수 있습니다.

dfs 문제에서 보던 그림과 비슷하기도 합니다. 이를 가지고 메모이제이션을 해봅시다.

문제에서 상태는 1개임으로 1차원 테이블 하나 생성하면 충분할 듯합니다.

나타내보면 위 그림과 같습니다.

글을 적다보니 이런 생각도 듭니다. 9가 3과 5로 이루워진 조합은 3 + 3 + 3이고, 10은 5 + 5, 15는 5 + 5 + 5, 3 + 3 + 3 + 3 + 3 + ... 어떻게 15일 때 어떻게 5 + 5 + 5임을 보장할까? 란 그런 생각도 들 것 같습니다.

그런 걱정은 잠시 넣어두어도 될 듯합니다.

매번 최적임을 보장하고 있기 때문에 15는 무조건 5,5,5를 선택하게 됩니다.

예제 문제의 18은요? 5 + 5 + 5 + 3 입니다.

그렇다면 각 무게에서 최적의 봉지 선택은 어떻게 할까요?

저는 0부터 18까지 순방향으로 진행하면서 현재 무게에서 - 3, - 5를 통해 이미 저장된 값을 확인했습니다.
즉, 15는 DP[15-3], DP[15-5] 의 값을 비교해서 최소 값을 선택해 봉지 하나(3을 선택하든 5을 선택하든 봉지는 하나 추가됨)를 추가해서 저장합니다. 즉 DP[12] -> 4, DP[10] -> 2 => 2 + 1 즉 3입니다. (위 테이블은 잘못 그렸네요. 사소하니 넘어..가요)

여튼.. 이렇게 구한 MIN(DP[I-3], DP[I-5])+1은 점화식이니 뭐라니 등.. 제일 기초적인 문제를 통해 DP를 엿보았습니다.

다음은 2차원 문제로 와보면 좋겠네요. DP 뿌셔요.

백준 탑 골드 5, 문제 특징 고려해서 풀어보기

susuhana — Wed, 15 Jan 2025 22:05:57 +0900

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

해당 문제는 뒤에 있는 탑에서 앞에 있는 탑 중 자신과 가까운 제일 큰 탑을 찾는 문제이다.

위 그림을 토대로 정답을 보자면 다음과 같다.

0 0 2 2 4

나도 그랬고, 다른 사람도 다음과 같이 생각하지 않았을까?

1. 백준에서 스택을 활용하는 문제이니까, 스택을 어디다 쓰지? 어디다 쓸까?
1-1. 스택의 특징이 무엇이지? FILO, LIFO이지?
2. 반복문을 통해서 뒤에서 앞으로 이동하며 큰 탑을 찾아볼까?

먼저 2번부터 본다면, 해당 입력 값의 크기가 N은 1 이상 500,000이하임으로 N^2 만 되도 약 10억번을 넘어간다는 사실을 알 수 있기에 이중 포문 이상으로는 사용하지 못한다. 그렇다면 해당 문제를 어떻게 풀어야 할까?

위에서 이야기한 1번처럼 거의 Stack 문제임을 알고 왔기 때문에 Stack으로 풀어야겠다는 사고가 흘러가겠지만, 잠시 잊어보자.
먼저 예시 데이터를 잘게 쪼개보자. 그렇다면 이상한 특징 하나가 보인다.

그 특징은 정렬이다. 정확하게는 큰 탑을 만날 때까지 정렬이 유지된다.

이러한 특징을 가진 데이터 구조를 단조 스택( Monotonic Stack )이라고 한다.

단조 스택은 다음과 같다. ( 직접 읽으면 좋습니다.)

https://www.geeksforgeeks.org/introduction-to-monotonic-stack-2/

Introduction to Monotonic Stack - Data Structure and Algorithm Tutorials - GeeksforGeeks

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

www.geeksforgeeks.org

단조 스택은 새로운 요소를 스택에 넣을 때마다 스택 내부의 요소를 정렬한다. NGE이란 Next Greater Element 문제에서 많이 사용된다. 다시 말하면 다음으로 큰 요소는 무엇인지 찾을 때 사용하는데, 위 문제도 돌이켜보면 NGE 문제임을 알 수 있다.

단어 뜻 => 단조: 값이 항상 일정한 방향으로만 변화함

#include <iostream>
#include <vector>
#include <stack>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> heights(n);
    vector<int> answers(n);
    stack<pair<int, int>> s;

    for (int i = 0; i < n; ++i) {
        cin >> heights[i];

        while (!s.empty() && s.top().first <= heights[i]) {
            s.pop();
        }

        if (s.empty()) {
            answers[i] = 0;
        } else {
            answers[i] = s.top().second + 1; // 1-based index
        }

        s.push({heights[i], i});
    }

    for (int i = 0; i < n; ++i) {
        cout << answers[i] << " ";
    }

    return 0;
}

미세먼지 안녕! 골드 4

susuhana — Sun, 24 Nov 2024 12:48:13 +0900

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

문제 읽고, 생각해보기

문제를 읽어보다면, 특별한 점은 기존의 BFS에 공기 청정기가 하나 추가되고, 배열 내 값이 이동한다는 점이다.

해당 사항의 대해 순서대로 어떻게 진행되는지도 친절하게 되어 있다.

해당 문제에서 요구하는 기술은 BFS와 배열 회전이라고 생각된다.

다만 해당 글을 쓰는 이유는 그 2가지를 제대로 못해서, 참회하고자, 기억하고자 적는다.

먼저 문제에서는 공기 청정기에 대한 정의가 있다.

공기청정기는 항상 1번 열에 설치되어 있고, 크기는 두 행을 차지한다.

해당 내용을 통해 이후 회전 방법에 대해 고민될 부분이 조금 적어진다.

그 다음은 미세먼지가 확산되는 방법은 기존 토마토? 관련되어 비슷하니 넘어가도 좋을 것 같다.(어차피 아래에서 설명할 예정)

문제 풀이

BFS라고 해서 큐를 무조건 써야 하는 건 아니다.

먼저 문제에서 BFS라는 점을 주었기 때문에 공기 청정기 가동되는 부분을 제외하고 동일하게 풀어도 된다는 생각이 들어서 그렇기 풀게 된다면 이런 생각이 들 수 있다.

BFS -> 큐가 필요하다. -> 큐에 T초를 구분하기 위해서 값을 어떻게 넣지?

왜 그렇냐면 문제 정의에 따르면, 1초 돌고 공기 청정기가 돌아야 하니 큐에 넣은 값으로 한번 탐색을 멈춰야 하기 때문이다. 어떻게 할 수 있을까?

다른 문제를 조금 풀어보았다면, 구분하기 위해서 큐 요소에 초를 넣는 행위를 하지 않을까 싶다. 나도 그렇게 생각했다. 다음 초가 된 경우 break를 하지 않을까?

나는 그게 싫어서 큐를 하나 만들어서 다음 요소를 들을 담아두었다.

그런데 그럴 필요가 없었다. 미세먼지를 찾아서 확산만 하면 된다. 그러니까 미로 찾기? 길 찾기? 단축 경로 찾기 등이 아니다. 그러니까 미세먼지만 찾아서 확장시켜주면 된다.

배열 회전은 거꾸로

배열 회전에서도 그림에 그려진 방향대로 하니, 각 마지막 요소를 어떻게 덮어쓰기를 해줄지 고민이었는데, 거꾸로 하면 그런 문제가 해소되는 것이었다...

#include <iostream>
#include <vector>
using namespace std;

int dx[4] = { 0, 0, -1, 1 };
int dy[4] = { -1, 1, 0, 0 };

// 상단 공기청정기 순환
void rotateTop(vector<vector<int>>& board, int top, int cols) {
    // 왼쪽 세로
    for (int i = top - 1; i > 0; --i) {
        board[i][0] = board[i - 1][0];
    }
    // 위쪽 가로
    for (int j = 0; j < cols - 1; ++j) {
        board[0][j] = board[0][j + 1];
    }
    // 오른쪽 세로
    for (int i = 0; i < top; ++i) {
        board[i][cols - 1] = board[i + 1][cols - 1];
    }
    // 아래쪽 가로
    for (int j = cols - 1; j > 1; --j) {
        board[top][j] = board[top][j - 1];
    }
    board[top][1] = 0; // 공기청정기에서 나온 공기
}

// 하단 공기청정기 순환
void rotateBottom(vector<vector<int>>& board, int bottom, int cols, int rows) {
    // 왼쪽 세로
    for (int i = bottom + 1; i < rows - 1; ++i) {
        board[i][0] = board[i + 1][0];
    }
    // 아래쪽 가로
    for (int j = 0; j < cols - 1; ++j) {
        board[rows - 1][j] = board[rows - 1][j + 1];
    }
    // 오른쪽 세로
    for (int i = rows - 1; i > bottom; --i) {
        board[i][cols - 1] = board[i - 1][cols - 1];
    }
    // 위쪽 가로
    for (int j = cols - 1; j > 1; --j) {
        board[bottom][j] = board[bottom][j - 1];
    }
    board[bottom][1] = 0; // 공기청정기에서 나온 공기
}

int main() {
    int r, c, t;
    cin >> r >> c >> t;

    vector<vector<int>> board(r, vector<int>(c, 0));
    pair<int, int> upAir = { -1, -1 }, downAir;

    // 입력 처리 및 공기청정기 위치 확인
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
            cin >> board[i][j];
            if (board[i][j] == -1) {
                if (upAir.first == -1) {
                    upAir = { i, j };
                }
                else {
                    downAir = { i, j };
                }
            }
        }
    }

    while (t--) {
        // 1. 미세먼지 확산
        vector<vector<int>> temp(r, vector<int>(c, 0)); // 확산 결과 저장
        for (int i = 0; i < r; i++) {
            for (int j = 0; j < c; j++) {
                if (board[i][j] > 0) {
                    int spreadAmount = board[i][j] / 5;
                    int spreadCount = 0;

                    for (int k = 0; k < 4; k++) {
                        int nx = i + dx[k];
                        int ny = j + dy[k];
                        if (nx >= 0 && ny >= 0 && nx < r && ny < c && board[nx][ny] != -1) {
                            temp[nx][ny] += spreadAmount;
                            spreadCount++;
                        }
                    }
                    temp[i][j] += board[i][j] - (spreadAmount * spreadCount);
                }
            }
        }
        board = temp;

        // 2. 공기청정기 작동
        rotateTop(board, upAir.first, c);
        rotateBottom(board, downAir.first, c, r);

        // 공기청정기 위치 값 유지
        board[upAir.first][0] = -1;
        board[downAir.first][0] = -1;
    }

    // 최종 출력
    int result = 0;
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
            if (board[i][j] > 0) {
                result += board[i][j];
            }
        }
    }
    cout << result << "\n";
    return 0;
}

숨바꼭질 2 골4

susuhana — Sat, 23 Nov 2024 19:21:09 +0900

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

시간 복잡도 계산
=> 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다

N이 10^5 임으로 O(N^2) 해결할 수 없고, 그 하위로 풀어야 한다.

BFS는 정점의 개수 10^5, 간선의 수 3개 O(V) 안에 해결 가능하다.

visisted를 while 안과, for문 안 탐색할 때 처리가 가능한데, 이에 대한 이유를 알 수 있었던 문제라고 생각된다.

#include<iostream>
#include<vector>
#include<queue>
using namespace std;

int main() {
	ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	int n, k;
	cin >> n >> k;

	if (n == k) {
		cout << 0 << "\n" << 1;
		return 0;
	}

	queue<pair<int, int>> q;
	bool visit[100001] = { false, };

	q.push({ n, 0 });

	int cnt = 0, t = 0;
	while (!q.empty()) {
		int line = q.front().first;
		int time = q.front().second;
		q.pop();
		visit[line] = true;

		if (line == k) {
			if (cnt == 0) {
				t = time;
				cnt++;
			} else if (cnt > 0 && time == t) {
				cnt++;
			}
		}
		
		int dx[3] = { line - 1, line + 1, 2 * line };
		for (int i = 0; i < 3; i++) {
			int nx = dx[i];

			if (0 <= nx && nx <= 100000 && !visit[nx]) {
				q.push({ nx, time + 1 });
			}
		}
	}

	cout << t << "\n" << cnt;

	return 0;
}

아기 상어 골3, 장애물 생각해보기

susuhana — Wed, 20 Nov 2024 09:25:49 +0900

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

상어가 사이즈가 1인 경우, 위 쪽 1과 아래쪽 1을 갈 수 있다. 이 때 문제에서 장애물에 대한 정의를 말하지 않았다.

그렇기 때문에, BFS 문제라고 말했지만, 장애물이 없다는 사실에 착안해서 좌표끼리의 차이를 계산해서 거리를 계산했다.

하지만 물고기가 장애물이라 사실을 몰랐다. 물고기가 좌표 사이에 있어서 무시하고 지나갈 수 있는 조건이 없기 때문에, 피해서 가야 한다. 그렇다면 피하기 위해서는 결국 해당 값을 확인해야 한다. 그렇기 때문에 좌표를 통해 직접 이동하지 않고 구할 수 있는 방법이 없었다.

결국 BFS로 문제를 풀어야 하는 시뮬레이션 문제이다. 다시 BFS로 풀어야 겠다.

사전 순 최대 공통 부분 수열 성공 C++

susuhana — Tue, 12 Nov 2024 23:26:45 +0900

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

문제는 백준에서 읽을 수 있습니다.

해당 문제는 solved.ac에서 4 클래스 문제를 다 풀기 위해서 문제를 해결하려고 했으나, 너무 오래 걸렸다.

문제에서는 해당 부분을 주의 깊게 보면 좋다. 처음에 봤을 때 무슨 말인지 감이 안 왔다.

예제 값과 문제의 설명을 함께 본다면, 무조건 큰 값이 앞에 오면 된다는 내용을 이해할 수 있다.

그러니까 크게 문제의 시간 복잡도도 그렇게 높지도 않기 때문에 DP까지 갈 필요가 없는 문제이기도 하고, 무조건 공통 값 중 큰 값이 앞으로 오면 된다는 점을 착안해서 문제를 풀 수 있다.

내가 오래걸린 문제

일단 다른 사람들의 해결 방법을 보았을 때 살짝 어지러웠다. 문제에서는 공통 값 중 큰 값 순으로 나열하면 된다는 생각이 크게 뇌를 지배하고 있는데, 다들 투 포인터 기법을 곁들여서 공통의 값을 찾아나갔다.

여기까지는 이해할 수 있는 부분인데, 배열을 지워나가는 행위까지 포함되어 있었다.

상당히 복잡해진 느낌이라 왜 이렇게까지 해야하나 싶었다.

질문 게시판에 가면 다른 예제도 볼 수 있다.

여기서 확인할 수 있는 부분은 두 배열에 공통된 수가 있는 경우, 어떻게 처리하는지 놓치지 말자란 생각이 들 수 있다.

하여튼.. 배열은 건드리고 싶지 않고, 공통된 수만 보고 싶다는 내 니즈에 코드를 닦았다가 이상한 조건을 하나 달았다가 된통 오래 걸렸다.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {

    int n, m;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    
    cin >> m;
    vector<int> b(m);
    for (int i = 0; i < m; i++) cin >> b[i];
    
    vector<pair<int, pair<int, int>>> commonNumber;
    
    for(int i=0; i<n; i++) {
    	for(int j=0; j<m; j++) {
    		if(a[i] == b[j]) {
    			commonNumber.push_back({ -a[i], { i, j } });
    		}
    	}
    }
    
    sort(commonNumber.begin(), commonNumber.end());
    
    vector<pair<int, pair<int,int>>> ans;
    for(int i=0; i<commonNumber.size(); i++) {
    	if(ans.size() == 0) {
    		ans.push_back(commonNumber[i]);
    	} else {
    		if(
                -ans[ans.size()-1].first >= -commonNumber[i].first 
            &&  ans[ans.size()-1].second.first < commonNumber[i].second.first
    		&& ans[ans.size()-1].second.second < commonNumber[i].second.second
    		) {
    			ans.push_back(commonNumber[i]);
    		}
    	}
    }
    
    cout << ans.size() << "\n";
    for(int i=0; i<ans.size(); i++) {
    	cout << -ans[i].first << " ";
    }
    
    return 0;
}

1. 공통된 값을 찾고, 값 순으로 정렬한다.
2. answer 배열이 비어 있으면 값을 추가하거나 Answer의 마지막 요소의 인덱스를 A, B 배열의 인덱스확인해서 값을 추가한다.

코드는 굉장히 간단한 흐름을 가지고 있다.

위 코드에서 이상한 점을 찾았을까?

-ans[ans.size()-1].first >= -commonNumber[i].first

위 코드는 불필요하다.

이미 공통 값을 가진 배열이 내림차순 정렬이 되어 있기 때문이다.

또한 나는 >=에서 =를 빼먹어서 계속 틀렸다. 결국.. 잘 몰랐다는 점을 상기할 수 있었다.

[백준 5639] 이진 검색 트리 C++, 전위 순회 특징과 이진 트리 특징 고려해보기

susuhana — Sun, 3 Nov 2024 21:42:31 +0900

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

이 문제를 해결하기 위해서는 이진 트리의 특징과 전위 순회 특징에 대한 이해가 있어야 해결할 수 있는 문제이다.
=> 즉, 트리의 특징을 제대로 이해했는지 확인하는 기본적인 문제이다.

먼저 이진 트리의 특징을 간단하게 생각해보자.

1. 2개의 자식 노드를 가진다.

이 특징으로 인해 실제 자료구조를 구현 시 배열, 인접 리스트, 포인터 등을 고려해볼 수 있게 된다.

또한 배열로 구현하게 된다면 Root 노드는 기본적으로 인덱스 1에 두는 방식을 사용하고 왼쪽 자식 노드는 2 * root index, 오른쪽 노드는 2 * root +1을 하게 된다.

인접 리스트는 다른 방법을 생각해보야 하는데, 이 문제는 트리 구조를 입력 값으로 주지 않기 때문에 위 방식을 사용하지 못한다.

문제에서는 살짝 응용된 부분은 이미 전위 순회된 결과 값을 주고 있다는 사실이다.
그렇다는 의미는 우리가 이미 알고 있는 트리를 만들기 위해서는 트리를 직접 만들어볼 수 도 있다는 뜻이다.

실제 해결된 방법에서는 트리를 직접 만들지는 않을 것이라 전위 순회를 가지고 트리를 파악하는 방법으로 살펴보자.

문제의 예시로 살펴본다면.. 다음과 같다.

50, 30, 24, 5, 28, 45, 98, 52, 60
볼드 처리한 숫자를 보면 Root 50으로 부터 왼쪽, 오른쪽 자식 노드임을 알 수 있다.
왼쪽 자식 노드를 타고 내려간다면 어떨까?

30, 24, 5, 28, 45

24, 5, 28

전위 순회된 결과에서 오른쪽 자식 노드까지 탐색을 내려가는 방식으로 내려간다면 노드 탐색을 할 수 있다.

이진 트리를 만들어서 탐색을 하자가 아니라, 이진 탐색된 결과를 가지고 중위/후위 순회를 할 수 있다는 점이 이 문제의 해결 방법의 실마리다.

그렇다면 현재 서브 트리의 오른쪽 노드를 어떻게 찾을까?
순회 한번씩 하면, 나오기 때문에 간단하다.
그리고 오른쪽 자식 노드는 현재 서브트리의 Root보다 큰 값(이진 트리의 특성)임을 알 수 있다.

#include <iostream>
#include <vector>
using namespace std;

vector<int> v;

void post(int root, int end) {
    if (root >= end) {
        return;
    }
    
    int rightIndex = end;
    for(int i = root + 1; i < end; i++) {
        if(v[root] < v[i]) {
            rightIndex = i;
            break;
        }
    }

    post(root + 1, rightIndex);
    post(rightIndex, end);
    cout << v[root] << "\n";
}

int main() {
    int temp;
    while (cin >> temp) {
        v.push_back(temp);
    }

    post(0, v.size());
    return 0;
}

언제쯔음

[서평 리뷰] 이펙티브 파이썬 3판 - 길벗

[서평 리뷰] 그림과 실습으로 배우는 쿠버네티스 입문 - 길벗

책에 대한 기대와 아쉬운 점

그림과 실습 != 만화

Drilling?

이 책은?

쉽게 다가갈 수 있는 책

좋은 마인드를 가진 책

책의 구성

추천의 말

백준 계단오르기, DP 기본 지식 2일차

설탕배달, DP 기본 지식 1일차

백준 탑 골드 5, 문제 특징 고려해서 풀어보기

0 0 2 2 4

미세먼지 안녕! 골드 4

숨바꼭질 2 골4

아기 상어 골3, 장애물 생각해보기

사전 순 최대 공통 부분 수열 성공 C++

내가 오래걸린 문제

-ans[ans.size()-1].first >= -commonNumber[i].first

[백준 5639] 이진 검색 트리 C++, 전위 순회 특징과 이진 트리 특징 고려해보기