.Zzumbong

우주 속 나의 족보, 그 시작과 끝 — 「별의 자식」 시리즈 2부

쭘봉 — Wed, 24 Jun 2026 13:10:36 +0900

빛에서 별로, 별에서 나로

도입 — 사라지는 것은 정말 하나도 없을까

1부에서 나는 내가 '굳어버린 에너지'라는 걸 알게 됐다. 그런데 받아들이자마자 다음 질문이 따라왔다.

이 에너지는 어디서 와서, 결국 어디로 가는 걸까?

쌍소멸로 사라진 전자와 양전자는 빛이 되어 어디론가 날아갔다. 그 빛이 무언가에 부딪혀 흡수되면? 또 그 무언가가 식으면? 한참을 따라가다 보면 자연스레 의심이 든다. 이러다 에너지가 어디선가 그냥 '없어져' 버리는 순간이 오는 건 아닐까?

답부터 말하면 — 아니다. 그 어느 단계에서도 에너지는 사라지지 않는다. 다만 끝없이 옷을 갈아입을 뿐이다.

1. 사라지는 것은 없다 — 에너지 보존과 엔트로피

학교에서 우리는 '질량 보존의 법칙'을 배웠다. 그런데 사실 그건 정확한 법칙이 아니다. 화학 반응에서는 질량 변화가 너무 작아서 보존되는 것처럼 보일 뿐, 우주가 진짜로 철통같이 지키는 법칙은 에너지 보존이다. (1부에서 봤듯, 질량도 결국 에너지의 한 형태니까.)

그러니 빛이 흡수되어도 그 에너지는 사라지지 않는다. 빛을 흡수한 물질 속 원자들의 운동 에너지로 넘어간다. 그리고 여기서 작은 깨달음 하나 — '열'이라는 건 사실 미시적인 운동 에너지다. 무언가가 뜨거워진다는 건, 그 안의 원자들이 더 격렬하게 떨고 있다는 뜻이니까.

그럼 그 운동 에너지가 중력에 부딪혀 사라지면? 공을 위로 던져 보자. 올라갈수록 느려지며 운동 에너지가 줄어든다. 사라진 걸까? 아니다. 그 에너지는 '높이'라는 형태로 저금됐을 뿐이다. 공이 다시 떨어지면 정확히 그만큼 운동 에너지로 돌아온다. 합계는 1줄도 변하지 않는다.

이렇게 에너지는 영원히 모양만 바꾸며 돌고 돈다.

빛 → 운동 → 열 → 위치 에너지 → 다시 운동 → ⋯

다만 한 가지 경향은 있다. 에너지는 사라지지 않지만, 점점 흩어지고 쓸모없어진다. 뜨거운 커피가 식어 주변과 미지근해지는 것처럼. 양은 그대로인데 '써먹기 좋은 상태'에서 '골고루 퍼진 상태'로 흘러간다. 이것이 엔트로피다.

그리고 이 흐름을 우주 전체에, 무한한 시간에 걸쳐 끝까지 밀어붙이면 — 도달하는 곳이 **빅 프리즈(열죽음)**다. 별은 모두 타버리고, 새 별도 생기지 않고, 마지막엔 블랙홀마저 천천히 증발한다. 어디에도 에너지의 차이가 남지 않아, 더는 아무 일도 일어날 수 없는 우주. 절대영도에 가까운, 텅 비고 차갑고 영원히 고요한 어둠. 지금으로선 우주의 가장 유력한 결말이다.

여담: 사실 '우주 전체'의 에너지 보존은 묘한 구석이 있다. 우주가 팽창하면서 먼 은하의 빛은 파장이 늘어나며 에너지를 잃는데(적색편이), 그 에너지가 어디로 갔는지 깔끔하게 설명되지 않는다. 일반상대성이론에선 우주 규모의 에너지 보존이라는 개념 자체가 명확히 정의되지 않는다. 동네 공놀이에선 답이 분명하지만, 우주 규모에선 아직 토론 중인 영역이다.

2. 우리는 왜 존재하는가 — 10억분의 1의 기적

이제 시간을 거꾸로, 우주의 맨 처음으로 돌려보자.

빅뱅 직후의 우주는 상상도 못 할 만큼 뜨거웠다. 너무 뜨거워서 안정적인 '물질'이란 게 존재할 수 없었다. 그저 펄펄 끓는 에너지 덩어리였다. 그 안에서 빛은 끊임없이 입자와 반입자 쌍을 만들어냈고(1부의 E=mc²이 거꾸로 작동), 그 쌍은 곧바로 만나 다시 빛으로 소멸했다. 만들어지고, 사라지고, 또 만들어지고.

이때 물질과 반물질은 거의 정확히 같은 양으로 생겨났다. 그런데 둘이 만나면 쌍소멸한다. 만약 완벽하게 50대 50이었다면? 모든 것이 소멸해 우주엔 빛만 남고, 물질이라곤 단 하나도 없었을 것이다. 별도, 지구도, 나도 없었을 것이다.

그런데 무슨 이유에선지, 물질이 10억분의 1만큼 더 많았다. 반물질 10억 개당, 물질이 10억 하고도 1개. 우주가 식으면서 거대한 대소멸이 일어났고, 모든 반물질이 짝을 찾아 사라진 뒤 — 짝을 못 찾은 그 '1개'의 물질만이 살아남았다.

그 10억분의 1의 잔여물이, 지금 우주의 모든 물질이다. 모든 은하, 모든 별, 그리고 나까지.

증거도 하늘에 찍혀 있다. 지금 우주에는 물질 입자 하나당 광자가 약 10억 개 떠다닌다(우주배경복사). 이것이 바로 그 대소멸의 '재'다. 10억은 빛으로 돌아갔고 1개만 물질로 남았다는 비율이, 지금도 온 하늘에 새겨져 있는 것이다.

그런데 — 왜 물질이 아주 조금 더 많았는가? 이건 아직 아무도 풀지 못했다. 물리학이 가진 가장 큰 미스터리 중 하나이고, "우리가 왜 존재하는가"라는 질문에 현대 과학은 아직 완전한 답을 내놓지 못하고 있다.

3. 빛에서 별로, 별에서 나로 — 나의 족보

나는 천문학을 좋아하면서, 막연히 우리가 '별의 파편'이라고 생각해 왔다. 우리 몸을 이루는 원소들은 단순한 핵융합으로 뚝딱 만들어지는 게 아니니까, 우리는 태양의 형제이자 항성의 자녀라고. 그 생각은 — 정확했다. 다만 진실은 거기서 한 층 더 깊은 곳까지 이어진다.

빅뱅이 직접 만든 원소는 사실 가장 가벼운 것들뿐이었다. 수소, 헬륨, 그리고 아주 약간의 리튬. 그게 전부였다. 우주는 너무 빨리 식어서 그 이상 무거운 원소를 만들 시간이 없었다.

그래서 내 몸의 탄소, 뼈의 칼슘, 피 속의 철 같은 무거운 원소들은 빅뱅이 만들지 못했다. 이것들은 전부 별 내부의 핵융합과, 별이 죽을 때의 초신성 폭발·중성자별 충돌에서 빚어졌다. 그리고 그 별이 죽으며 흩뿌린 잔해에서 새로운 별과 행성이 태어났다.

그러니 내 족보를 거슬러 올라가면 이렇게 된다.

빅뱅의 빛 — 모든 것의 시작
→ 굳어버린 물질 (10억분의 1의 생존자)
→ 수소와 헬륨 (빅뱅이 직접 준 태초의 원소)
→ 별 (그 수소를 태워 무거운 원소를 빚어낸 용광로)
→ 별의 잔해 (죽은 별이 흩뿌린 먼지)
→ 나 (그 먼지가 다시 모여 깨어난 존재)

칼 세이건의 말처럼, 우리는 별의 먼지로 만들어졌다. 태양은 부모라기보다 같은 구름에서 태어난 형제이고, 진짜 부모는 태양보다 먼저 살다 죽어간 윗세대의 별들이다.

빅뱅에서 시작된 그 빛이, 결국 우리 은하와 태양과 지구와 — 그리고 나를 이루는 모든 물질의 근원이었던 것이다

다음 편에서

여기까지가, 과학이 알려준 사실이다. 나는 빅뱅의 빛에서 와서, 대소멸을 살아남고, 별의 용광로를 거쳐 지금 여기에 있다.

그런데 이상한 일이 일어난다. 이 사실들을 알고 나면, 머릿속만 채워지는 게 아니라 — 마음에 무언가가 남는다. 어떤 날은 그게 까마득한 공포처럼, 어떤 날은 벅찬 경외처럼 다가온다.

마지막 편에서는, 이 모든 진실이 한 인간에게 무슨 의미인지를 이야기하려 한다. 코스믹 호러와 경외 사이에서, 허무주의에 빠지지 않고 내가 찾은 답에 대해.

— 「별의 자식」 시리즈, 3부에서 계속

나는 굳어버린 빛이다 — 「별의 자식」 시리즈 1부

쭘봉 — Thu, 18 Jun 2026 13:44:52 +0900

반물질에서 시작된, 내 정체에 관한 질문 — 「별의 자식」 시리즈 1부

프롤로그 — 사소한 질문 하나에서 시작됐다

시작은 정말 별것 아니었다.

전자는 음전하를 띤다는데, 그럼 반대는 뭘까? 찾아보니 양전자(positron)라는 게 있다고 한다. 거기서 멈췄으면 됐을 텐데, 한 번 당긴 실이 우주의 끝까지 풀려 나갈 줄은 몰랐다.

양전자에서 시작된 질문은 어느새 "질량이란 무엇인가", "나는 대체 무엇으로 만들어졌는가", 그리고 끝내 "우리는 왜 존재하는가"까지 번졌다. 그날 밤 나는 천문학을 취미로 좋아하는 평범한 사람일 뿐이었는데, 어느 순간 내 손으로 우주의 가장 근본적인 질문들을 하나씩 꿰고 있었다.

이 글은 물리 교과서가 아니다. 어느 밤, 가벼운 호기심 하나가 나를 어디까지 데려갔는지에 대한 기록이다. 그리고 그 끝에서 내가 왜 뭉클해졌는지에 대한 이야기이기도 하다.

먼저, 모든 것이 시작된 그 단어부터.

1. 반물질 — 이름이 만든 오해

반물질(antimatter). 이름부터 SF다. '반(反)'이라는 글자가 붙는 순간, 머릿속엔 반대 차원, 거울 세계, 평행우주 같은 게 떠오른다. 뭔가 우리 세상과 정반대인, 닿으면 안 될 것 같은 신비한 물질.

그런데 알고 보니 그 '반'은 그렇게 거창한 게 아니었다.

반물질의 '반'은 그저 전하 부호가 뒤집혔다는 뜻일 뿐이다. 양전자는 전자와 질량이 완전히 똑같다. 단지 전자가 음(−)전하라면 양전자는 양(+)전하라는 것, 그 차이뿐이다. 반대 세상에서 온 무언가가 아니라, 그냥 부호가 뒤집힌 평범한 입자. 만약 발견자들이 '거울입자' 같은 밋밋한 이름을 붙였다면, 우리는 반물질을 이렇게까지 신비롭게 여기지 않았을 것이다.

재미있는 건 그다음이다. 물질과 반물질이 만나면 어떻게 될까?

쌍소멸(annihilation)이 일어난다. 둘은 서로를 끌어안고 동시에 사라진다. 그리고 그 사라진 질량은 빛(감마선)으로 바뀐다. 여기서 그 유명한 식이 등장한다.

E = mc²

질량(m)이 빛의 속도 제곱(c²)을 곱한 만큼의 에너지(E)로 변하는 것이다.

이게 왜 무서운(?) 변환이냐면 — 우리가 아는 가장 격렬한 반응들조차 질량을 에너지로 바꾸는 효율이 형편없기 때문이다. 장작이 타는 화학반응은 질량의 거의 0%를, 원자폭탄조차 0.1% 정도만 에너지로 바꾼다. 그런데 물질과 반물질의 쌍소멸은 **질량의 100%**를 에너지로 바꾼다. 이론상 우주에서 가장 완벽한 에너지 변환이다.

2. 질량이라는 착각 — 나는 사실 에너지다

E=mc²을 우리는 보통 "질량을 에너지로 바꾼다"고 읽는다. 그런데 이 식의 진짜 의미는 훨씬 충격적이다.

질량이 에너지를 '가진' 게 아니라, 질량이 곧 에너지의 한 형태라는 것. 둘은 별개의 무언가가 아니라, 처음부터 같은 것이었다.

비유하자면 이런 거다. "1마일은 왜 1.6km나 되는 큰 거리를 품고 있지?"라고 묻는 사람은 없다. 마일이 km를 '가진' 게 아니라, 둘 다 같은 거리를 다른 단위로 잰 것뿐이니까. 질량(kg)과 에너지(줄, J)도 정확히 그런 관계다. 그리고 c²은 그 둘 사이를 바꿔주는 환율이다.

그럼 왜 이 환율이 이렇게 어마어마하게 클까? 순전히 우리가 일상에서 쓰는 단위 때문이다. 빛의 속도는 초속 3억 미터라는 비현실적인 숫자인데, 그걸 제곱하니 천문학적인 값이 나온다. 그래서 아주 작은 질량도 c²을 곱하면 엄청난 에너지가 된다.

하지만 물리학자들이 쓰는 식으로 빛의 속도를 그냥 '1'로 놓으면, 이 식은 놀랍도록 단순해진다.

E=m

질량과 에너지가 같은 숫자가 되는 것이다. "질량은 엄청난 에너지를 품고 있다"는 우리의 감탄은, 사실 인간이 만든 단위가 만들어낸 착시였다.

3. 내 몸의 99% — 묶여 있는 에너지

여기서부터가 진짜 소름이 돋는 지점이다.

그렇다면 질량은 대체 어디서 오는 걸까? 답을 알고 나면 세상이 조금 다르게 보인다. 내 몸무게의 약 99%는, 이미 '에너지'다.

내 몸을 잘게 쪼개 보자. 몸은 원자로 되어 있고, 원자 질량의 대부분은 핵 속의 양성자와 중성자에 있다. 그 양성자 하나를 또 열어 보면 안에는 쿼크 세 개가 들어 있다. 그런데 — 이 쿼크 세 개의 질량을 전부 더해도, 양성자 질량의 고작 1% 정도밖에 안 된다.

그럼 나머지 99%는 뭘까?

쿼크들을 묶어두는 강한 핵력의 에너지, 그리고 그 좁은 공간에 갇혀 미친 듯이 움직이는 쿼크들의 운동 에너지다. 양성자 질량의 대부분은 '물질 덩어리'가 아니라, 갇혀 있는 에너지 그 자체인 것이다. 더 놀라운 사실. 쿼크를 묶는 글루온은 질량이 아예 0이고, 쿼크 자체의 질량도 거의 0에 가깝다. 그러니까 나는 — 질량이 거의 없는 재료들이 좁은 공간에 갇혀 맹렬하게 움직이고 서로를 붙드는, 그 에너지로 만들어진 존재다. 질량이, 질량 없는 것들로부터 솟아난 것이다.

"나는 단단한 물질로 된 존재"라는 직관은 사실 거의 틀렸다. 더 정확히 말하면, 나는 텅 빈 공간 속에서 안정적으로 진동하는 에너지 패턴에 훨씬 가깝다.

나는, 굳어버린 빛이다.

다음 편에서

좋다. 나는 단단한 물질이 아니라 굳어버린 에너지다. 받아들이고 나니 묘한 평온이 찾아온다.

그런데 곧바로 다음 질문이 따라온다. 그럼 이 에너지는 대체 어디서 왔을까?

이 실을 당기는 순간, 우주의 시작과 끝이 통째로 딸려 나온다. 사라지지 않는 에너지, 모든 것이 식어 멈추는 우주의 마지막, 그리고 137억 년을 거슬러 올라가는 내 진짜 족보까지.

다음 편 **「빛에서 별로, 별에서 나로」**에서, 내가 어디서 왔는지를 따라가 본다.

— 「별의 자식」 시리즈, 2부에서 계속

행성과 별을 죽이는 SF미래 병기 뉴트로늄 탄자를 서울에 낙하해보기

쭘봉 — Wed, 14 Jan 2026 03:14:26 +0900

'뉴트로늄(Neutronium)'은 뭘까?

0. '뉴트로늄(Neutronium)'이란?

우리가 아는 일반적인 물질(철, 물, 공기 등)은 사실 속이 거의 비어 있다. 원자를 축구장이라고 치면 원자핵은 한가운데 놓인 축구공 하나 정도고, 나머지는 전자가 돌아다니는 텅 빈 공간이다. (우리를 이루는 물질들은 텅텅 비어있는데 왜 벽을 통과하지 못할까? 라는 생각을 오래전에 해본 적이 있는데, 이것도 나중에 다뤄보면 재미난 주제일 것 같다.)

하지만 뉴트로늄은 다르다! 거대한 별이 수명을 다해 죽으면서 엄청난 중력으로 짓눌려, 축구장만 한 원자들이 모두 축구공 크기로 압축되어 다닥다닥 붙어버린 상태다. 우주에서 블랙홀 다음으로 밀도가 높은 '중성자 반죽'이라고 이해하면 쉽다.

5.56mm 탄환 하나의 무게는 약 2억 톤이다. 전 세계의 모든 자동차를 한데 뭉쳐놓은 것보다 무겁고,
에베레스트산 전체 무게 와 맞먹는다. (손가락만한 게 산 하나의 무게)

사실 뉴트로늄은 중력이 약한 곳에선 금방 폭발하며 붕괴한다.

발사전에 준비할 것

SF 차폐막 (붕괴 억제): 뉴트로늄은 중성자별의 엄청난 중력이 없으면 순식간에 폭발하며 붕괴한다.
우리는 탄환이 목표에 맞을 때까지 이 붕괴를 막아주는 미래 기술의 차폐막이 있다고 하자.
발사 에너지 (리틀보이 8,000발): 에베레스트산을 총알 속도로 쏘려면 얼마나 많은 에너지가 필요할까?
히로시마 원자폭탄(리틀보이) 약 1,300발을 동시에 터뜨려야 겨우 발사할 수 있다.
이번엔 리틀보이 8,000발 분량의 막대한 운동 에너지를 가지고 지구로 돌진한다고 가정하자.

이제 발사 버튼을 눌러보자.

1. 대기권 진입: 공기를 삭제하는 '플라즈마 바늘'

나노 바나나 이쉨..

정지궤도에서 서울로 내려올 때, 우리가 아는 공기역학은 가볍게 무시된다.

2억 톤의 질량이 5.56mm 바늘 끝에 실려 있으니 대기는 그냥 없는 거나 다름없다.

공기 분자들은 비켜날 시간조차 없어 탄환 표면 원자와 그대로 충돌하며 핵융합을 시작한다. 서울 하늘에는 낙뢰보다 수조 배 강한 감마선 레이저와 태양보다 뜨거운 플라즈마 터널이 뚫린다. 탄환이 땅에 닿기도 전에 지상의 생명체들은 이 강렬한 빛에 눈이 멀고 타버릴 것이다.

2. 서울 명중: "구멍이 뚫리는 지각"

탄환이 서울 시청 광장 보도블록에 닿는 순간을 상상해 보자, 보통의 폭탄은 땅에 닿으면 표면에서 터지지만, 이 탄환은 다르닷!

탄환이 지면에 가하는 압력은 너무나 거대해서, 암석이나 콘크리트의 원자 구조가 버틸 수 없으므로 탄환에게 지각은 마치 '부드러운 안개'나 '묽은 주스' 로 처리된다.

탄환은 폭발하기도 전에 지각을 수십 킬로미터 깊이로 뚫고 들어간다. 마치 뜨겁게 달궈진 바늘이 스티로폼을 뚫고 지나가는 것과 같이.. 이 과정에서 탄환이 가진 120메가톤(리틀보이 8,000발)의 운동 에너지가 순식간에 열과 충격파로 변환되며 지면으로 전달됩니다.

이 충격은 지구 반대편까지 감지될 정도의 초거대 지진을 일으킵니다. 서울 시내의 모든 건물은 0.1초 만에 가루가 되고, 충격파는 음속의 수십 배로 경기도 전역을 향해 뻗어 나갑니다. 이 충격파에 닿는 모든 생명체는 세포 단위에서 분해됩니다.

3. 뉴트로늄 활성화: 현실의 붕괴

진짜 재앙은 탄환이 박힌 뒤 차폐막이 깨지면서 시작된다. 지금까지의 파괴는 '운동 에너지' 때문이었지만,

이제는 짓눌려 있던 중성자들이 서로를 밀어내는 힘(축퇴압) 때문에, 탄환은 찰나의 순간에 원래의 부피로 돌아가려 한다.

5.56mm였던 물질이 순식간에 수 킬로미터 크기의 가스 덩어리로 부풀어 오르며 지구 내부에서 밖으로 폭발한다.

2억 톤의 뉴트로늄이 일반 물질로 돌아가며 방출하는 에너지는 지구의 지각 일부를 우주 밖으로 튕겨낼 정도.

4. 그 후, 지구가 마주할 거대한 재앙

뉴트로늄 탄환이 박히고 '활성화'되어 서울이 지도에서 사라진 뒤에도 비극은 끝나지 않는다. 이 작은 탄환 하나가 불러온 여파는 한반도를 넘어 지구 전체의 운명을 뒤흔들게 된다.

방사능의 바다 (베타 붕괴의 역습): 뉴트로늄은 중성자 덩어리다. 압박이 사라진 중성자는 약 10분의 반감기를 거치며 양성자와 전자로 변하는 '베타 붕괴'를 일으킨다. 2억 톤의 뉴트로늄이 붕괴하며 뿜어내는 에너지는 단순히 폭발에 그치지 않고, 지구 대기를 치명적인 중성자 방사선과 고에너지 입자로 가득 채운다. 한반도를 넘어 전 세계의 방사능 수치가 생명체가 살기 힘든 수준으로 급격히 치솟게 된다. (그야말로 방사능 지옥이 열리는 셈이다.)

지구를 휘감는 충격파: 120메가톤 급의 폭발과 뉴트로늄의 팽창 에너지는 대기를 타고 전 지구로 퍼져나간다. 과거 크라카토아 화산 폭발 당시 충격파가 지구를 일곱 바퀴 돌았다고 하는데, 이 탄환의 충격파는 그보다 훨씬 강력하다. 전 세계의 기압계가 요동치고, 해안가 근처의 도시들은 이 인공적인 진동이 만들어낸 거대한 쓰나미를 마주하게 될 것이다.

암흑의 겨울 (Impact Winter): 폭발로 인해 증발한 서울의 잔해와 뉴트로늄 가스, 그리고 성층권까지 치솟은 수십억 톤의 먼지구름이 태양 빛을 가로막는다. 낮에도 밤처럼 어두운 상태가 수개월간 지속되며 지구의 기온은 급격히 떨어지게 된다. 식물들이 광합성을 멈추고 생태계 사슬이 무너지는 '충격의 겨울'이 찾아오는 것이다.

지각의 상처와 궤도의 미세한 변화: 탄환이 뚫고 들어간 지각의 구멍은 거대한 마그마 분출구가 될 가능성이 높다. 또한, 2억 톤이라는 질량이 초고속으로 부딪힌 충격은 지구의 자전 속도나 축에 아주 미세하지만 물리적인 영향을 줄 수 있다. (물론 지구가 박살 날 정도는 아니겠지만, 전 세계의 정밀 시계들을 모두 다시 맞춰야 할지도 모른다.)

좀 더 생각해보면.

뉴트로늄에 대한 체쥐, 제조 후 유통, 발사 까지하려면 수많은 고비가 많다. 거기에 탄자 또는 탄두 등으로 만들어서 발사까지 하려면 엄청난 에너지가 필요할 것이다. 단순히 리틀보이 8000개를 주요 타격지점에 쏘는게 나을지도?

만약 카르다쇼프 척도 2티어 급 문명이라면?
뉴트로늄을 제조하는건 에너지가 너무 많이 들어서 안할꺼고 중성자별에 가서 채취하는게 나아보이는데? 어찌저찌 축퇴물질을 뜯어서 가져온다 치고

그럼 중력이 강한 무언가로 잡아둬야함. 미니 블랙홀이나 시공간 왜곡????

발사는 뭐 다이슨 스피어를 통한 에너지를 레이저화 한다면 충분히 밀어내 줄 수 있어보이고 아니면 태양을 통한 스윙바이나 투석기처럼 돌다가 쏘면 충분히 가능해보임.

: 예전에 나사 출신 과학자들이 재미있는 망상 질문에 진지하게 답변해주던 왓이프를 처음 읽던 느낌으로 AI와 함께 작성했다.
계산은 너무 귀찮기도 하고 뇌내 에너지도 없고 할 줄 도 모르지만 AI가 다 해주니 너무 좋아.

[leetCode/JS] 1266. Minimum Time Visiting All Points

쭘봉 — Mon, 12 Jan 2026 12:59:40 +0900

난이도 [ ] Easy

문제 설명

On a 2D plane, there are n points with integer coordinates points[i] = [xi, yi]. Return the minimum time in seconds to visit all the points in the order given by points. You can move according to these rules: In 1 second, you can either: move vertically by one unit, move horizontally by one unit, or move diagonally sqrt(2) units (in other words, move one unit vertically then one unit horizontally in 1 second). You have to visit the points in the same order as they appear in the array. You are allowed to pass through points that appear later in the order, but these do not count as visits.

입출력 예

Example 1:

Input: points = [[1,1],[3,4],[-1,0]]
Output: 7
Explanation: One optimal path is [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> [-1,0] Time from [1,1] to [3,4] = 3 seconds Time from [3,4] to [-1,0] = 4 seconds Total time = 7 seconds

Example 2:

Input: points = [[3,2],[-2,2]] Output: 5

Constraints

points.length == n
1 <= n <= 100
points[i].length == 2
-1000 <= points[i][0], points[i][1] <= 1000

내 솔루션

/**
 * https://leetcode.com/problems/minimum-time-visiting-all-points
 * @param {number[][]} points
 * @return {number}
 */
var minTimeToVisitAllPoints = function (points) {
    let awnser = 0;
    for (let i = 0; i < points.length - 1; i++) {
        let cur = points[i];
        let next = points[i + 1];
        awnser += Math.max(
            Math.abs(next[0] - cur[0]), Math.abs(next[1] - cur[1])
        );
    }

    return awnser;
};

감상평

이지 문제가 가장 재미있다.

[leetCode/JS] 1339. Maximum Product of Splitted Binary Tree

쭘봉 — Wed, 7 Jan 2026 09:41:42 +0900

난이도 [ ] Medium

문제 설명

Given the root of a binary tree, split the binary tree into two subtrees by removing one edge such that the product of the sums of the subtrees is maximized. Return the maximum product of the sums of the two subtrees. Since the answer may be too large, return it modulo 109 + 7. Note that you need to maximize the answer before taking the mod and not after taking it.

입출력 예

Example 1:

Input: root = [1,2,3,4,5,6]
Output: 110
Explanation: Remove the red edge and get 2 binary trees with sum 11 and 10. Their product is 110 (11*10)

Example 2:

Input: root = [1,null,2,3,4,null,null,5,6]
Output: 90
Explanation: Remove the red edge and get 2 binary trees with sum 15 and 6.Their product is 90 (15*6)

Constraints

The number of nodes in the tree is in the range [2, 5 * 10^4].
1 <= Node.val <= 10^4

내 솔루션

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxProduct = function (root) {
    const MOD = 1000000007;

    // DFS로 순회하면서 현재 트리 합을 계속 저장하면서 
    // 전체 합을 구해두기

    const allSums = [];

    const getSum = (node) => {
        if (!node) return 0;

        const currentSum = node.val + getSum(node.left) + getSum(node.right);

        allSums.push(currentSum);
        return currentSum;
    }
    const totalSum = getSum(root)

    let maxProd = 0;

    for (let sum of allSums) {
        const currentProd = sum * (totalSum - sum);
        if (currentProd > maxProd) {
            maxProd = currentProd;
        }
    }

    return maxProd % MOD
};

감상평

array push 가 아니라 그때그때 비교하는 코드로 만들면 더 빠름
MOD 하는거 0 몇개인지 자꾸 햇갈려 1-0은 8개-7

[leetCode/JS] 1161. Maximum Level Sum of a Binary Tree

쭘봉 — Tue, 6 Jan 2026 09:25:12 +0900

난이도 [ ] Medium

문제 설명

Given the root of a binary tree, the level of its root is 1, the level of its children is 2, and so on. Return the smallest level x such that the sum of all the values of nodes at level x is maximal.

이진 트리의 루트(root)가 주어집니다. 루트의 레벨은 1이고, 그 자식들의 레벨은 2, 그다음은 3으로 이어집니다.각 레벨에 있는 모든 노드 값의 합을 구했을 때, 그 합이 최대가 되는 가장 작은 레벨 x를 반환하세요.

포인트 1: 합이 최대인 레벨을 찾아야 함.
포인트 2: 만약 합이 같은 레벨이 여러 개라면, 그중 숫자가 더 작은 레벨(더 위쪽에 있는 레벨)을 선택해야 함.

입출력 예

Example 1:

Input: root = [1,7,0,7,-8,null,null]
Output: 2
Explanation: Level 1 sum = 1. Level 2 sum = 7 + 0 = 7. Level 3 sum = 7 + -8 = -1.
So we return the level with the maximum sum which is level 2.

Example 2:

Input: root = [989,null,10250,98693,-89388,null,null,null,-32127]
Output: 2

Constraints

The number of nodes in the tree is in the range [1, 10^4].
-10^5 <= Node.val <= 10^5

내 솔루션

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxLevelSum = function (root) {
    let maxSum = -Infinity;
    let maxLevel = 1;
    let level = 1;
    let que = [root];

    while (que.length > 0) {
        let currentSize = que.length;
        let currentSum = 0;
        for (let i = 0; i < currentSize; i++) {
            let node = que.shift();
            currentSum += node.val;

            if (node.left) que.push(node.left);
            if (node.right) que.push(node.right);
        }

        if (currentSum > maxSum) {
            maxSum = currentSum;
            maxLevel = level;
        }
        level++;
    }
    return maxLevel;
};

감상평

문제 보고 음.. BFS를 사용해야 겠네
BFS로 레벨 별로 돌아야 하니까 while 속에 for문으로 돌리면서 합계를 구해야하는군!
for문이 끝나면 누가 더큰지 비교해서 제일 큰 값의 레벨을 리턴하면 된다!
라는 생각으로 풀면 쉽게 풀림.

Beast 100% 달성 코드 첨부

로직와 알고리즘 모두 똑같은데, 찿이가 que 대신에 head하는 index를 이용해서 반복함.
shift() 같은 경우 [1,2,3,4] 에서 1이 빠지면 나머지 3칸이 이동하는 시스템이라고함. 그래서 더 오래 걸림.
단순히 head 라는 index만 ++ 하니까 런타임이 줄어든다고 한다.
BFS가 잘 도는데 느리다고 빠꾸 먹으면 head BFS를 떠올릴 것

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxLevelSum = function(root) {
    if(!root) return -1;

    const queue = [root];
    let head = 0;

    let maxValue = -Infinity;
    let maxIndex = 1;
    let currentLevel = 1;

    while (head < queue.length) {
        const levelSize = queue.length - head;
        let levelSum = 0;
        
        for (let i = 0; i < levelSize; i++) {
            const node = queue[head++];
            levelSum += node.val;

            if(node.left) queue.push(node.left);
            if(node.right) queue.push(node.right);
        }

        if(levelSum > maxValue) {
            maxValue = levelSum;
            maxIndex = currentLevel;
        }

        currentLevel++
    }

    return maxIndex
};

[leetCode/JS] 1975. Maximum Matrix Sum

쭘봉 — Mon, 5 Jan 2026 12:36:34 +0900

난이도 [ ] Medium

문제 설명

You are given an n x n integer matrix. You can do the following operation any number of times: Choose any two adjacent elements of matrix and multiply each of them by -1. Two elements are considered adjacent if and only if they share a border. Your goal is to maximize the summation of the matrix's elements. Return the maximum sum of the matrix's elements using the operation mentioned above.

당신에게 n x n 크기의 정수 행렬이 주어집니다. 당신은 다음과 같은 연산을 원하는 만큼 수행할 수 있습니다.행렬에서 인접한 두 요소를 선택하고, 각각에 -1을 곱합니다.두 요소가 경계(변)를 공유하는 경우에만 인접한 것으로 간주합니다.당신의 목표는 행렬 내 모든 요소의 합을 최대화하는 것입니다. 위 연산을 사용하여 얻을 수 있는 행렬 요소 합의 최댓값을 반환하세요.

입출력 예

Example 1:

Input: matrix = [[1,-1],[-1,1]]
Output: 4
Explanation: We can follow the following steps to reach sum equals 4:
- Multiply the 2 elements in the first row by -1.
- Multiply the 2 elements in the first column by -1.

Example 2:

Input: matrix = [[1,2,3],[-1,-2,-3],[1,2,3]]
Output: 16
Explanation: We can follow the following step to reach sum equals 16:
- Multiply the 2 last elements in the second row by -1.

Constraints

n == matrix.length == matrix[i].length
2 <= n <= 250
-10^5 <= matrix[i][j] <= 10^5

내 솔루션

/**
 * https://leetcode.com/problems/maximum-matrix-sum
 * @param {number[][]} matrix
 * @return {number}
 *//**
 * @param {number[][]} matrix
 * @return {number}
 */

/**
 * @param {number[][]} matrix
 * @return {number}
 */
var maxMatrixSum = function (matrix) {
    // 1차원 배열로 펼쳐서 처리 (가독성을 위해 flat 사용)
    const flatMatrix = matrix.flat();
    
    let numberOfMinus = 0; // 행렬 내 음수(-)의 총 개수
    let sum = 0;           // 모든 요소의 절댓값 합
    let minimunABS = Infinity; // 가장 작은 절댓값을 저장 (초기값은 무한대)

    for (let i = 0; i < flatMatrix.length; i++) {
        const val = flatMatrix[i];
        const absNum = Math.abs(val); // 현재 요소의 절댓값
        
        // 1. 모든 숫자를 양수로 가정하고 합산
        sum += absNum;
        
        // 2. 음수의 개수를 카운트
        // 인접한 두 수의 부호를 바꾸는 연산을 반복하면, 
        // 음수 부호를 원하는 위치로 이동시키거나 짝수개의 음수를 제거할 수 있음
        if (val < 0) numberOfMinus++;
        
        // 3. 행렬에서 절댓값이 가장 작은 숫자 찾기
        // 만약 음수가 홀수개라면, 전체 합에서 이 가장 작은 값을 음수로 남겨야 손해가 최소화됨
        if (minimunABS > absNum) minimunABS = absNum;
    }

    /**
     * 결과 반환 로직:
     * - 음수가 짝수개(numberOfMinus % 2 === 0): 
     * 모든 음수를 연산을 통해 양수로 바꿀 수 있으므로 전체 합(sum) 반환.
     * * - 음수가 홀수개: 
     * 무조건 한 개의 숫자는 음수로 남음. 가장 작은 숫자(minimunABS)를 음수로 선택.
     * 이미 sum에는 minimunABS가 양수로 더해져 있으므로, 
     * 이를 음수로 바꾸기 위해 sum에서 해당 값을 두 번 뺌 (sum - 2 * min).
     */
    return numberOfMinus % 2 === 0 ? sum : sum - (minimunABS * 2);
};

감상평

재미있는 문제. 구현이 어렵다기 보단 규칙을 찾아서 알고리즘을 만드는 이해력 문제
const flatMatrix = matrix.flat(); 대신에 2중 for 문을 사용하면 100% 가능해짐.

[leetCode/JS] 66. Plus One

쭘봉 — Fri, 2 Jan 2026 08:27:28 +0900

난이도 [ ] Easy

문제 설명

You are given a large integer represented as an integer array digits, where each digits[i] is the ith digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading 0's. Increment the large integer by one and return the resulting array of digits.

입출력 예

Example 1:

Input: digits = [1,2,3]
Output: [1,2,4]
Explanation: The array represents the integer 123. Incrementing by one gives 123 + 1 = 124.
Thus, the result should be [1,2,4].

Example 2:

Input: digits = [4,3,2,1]
Output: [4,3,2,2]
Explanation: The array represents the integer 4321. Incrementing by one gives 4321 + 1 = 4322.
Thus, the result should be [4,3,2,2].

Example 3:

Input: digits = [9]
Output: [1,0]
Explanation: The array represents the integer 9. Incrementing by one gives 9 + 1 = 10.
Thus, the result should be [1,0].

Constraints

1 <= digits.length <= 100
0 <= digits[i] <= 9
digits does not contain any leading 0's.

내 솔루션

/**
 * https://leetcode.com/problems/plus-one
 * @param {number[]} digits
 * @return {number[]}
 */
var plusOne = function (digits) {
    for (let i = digits.length - 1; i >= 0; i--) {
        digits[i]++;

        if (digits[i] < 10) {
            return digits;
        }
        digits[i] = 0;
    }
    digits.unshift(1);
    return digits;
};

감상평

처음엔 reduce로 모든 배열을 더해서 숫자 -> 스트링으로 변경 후 -> 다시 배열 변경 하려고 했는데 숫자가 100 자리 이상이라 오류가 났음.
배열을 직접 건들이는 방식으로 해결.

[leetCode/JS] 1970. Last Day Where You Can Still Cross

쭘봉 — Wed, 31 Dec 2025 13:24:19 +0900

난이도 [ ] Hard

문제 설명

There is a 1-based binary matrix where 0 represents land and 1 represents water. You are given integers row and col representing the number of rows and columns in the matrix, respectively.

Initially on day 0, the entire matrix is land. However, each day a new cell becomes flooded with water. You are given a 1-based 2D array cells, where cells[i] = [ri, ci] represents that on the ith day, the cell on the rith row and cith column (1-based coordinates) will be covered with water (i.e., changed to 1).

You want to find the last day that it is possible to walk from the top to the bottom by only walking on land cells. You can start from any cell in the top row and end at any cell in the bottom row. You can only travel in the four cardinal directions (left, right, up, and down).

Return the last day where it is possible to walk from the top to the bottom by only walking on land cells.

마지막으로 건널 수 있는 날 찾기 (Last Day to Walk Across)

0은 땅을 나타내고 1은 물을 나타내는 '1-기반(1-based)' 이진 행렬이 있습니다. 행렬의 행과 열의 개수를 나타내는 정수 row와 col이 주어집니다.
처음 0일차에는 행렬의 전체가 땅입니다. 하지만 매일 새로운 칸 하나가 물에 잠기게 됩니다. 당신에게는 '1-기반' 2차원 배열 cells가 주어지며, 여기서 cells[i] = [ri, ci]는 $i$번째 날에 $r_i$행 $c_i$열(1-기반 좌표)에 있는 칸이 물로 덮임(즉, 1로 변경됨)을 의미합니다.
당신은 오직 땅(0)으로만 이동하여 맨 윗줄(top)에서 맨 아랫줄(bottom)까지 걸어갈 수 있는 마지막 날이 언제인지 찾고 싶습니다. 맨 윗줄의 어느 칸에서든 시작할 수 있으며, 맨 아랫줄의 어느 칸에서든 끝낼 수 있습니다. 이동은 오직 상, 하, 좌, 우 네 방향으로만 가능합니다.
땅으로만 걸어서 맨 윗줄에서 맨 아랫줄까지 횡단할 수 있는 마지막 날을 반환하세요.

입출력 예

Example 1:

Input: row = 2, col = 2, cells = [[1,1],[2,1],[1,2],[2,2]]
Output: 2
Explanation: The above image depicts how the matrix changes each day starting from day 0.
The last day where it is possible to cross from top to bottom is on day 2.

Example 2:

Input: row = 2, col = 2, cells = [[1,1],[1,2],[2,1],[2,2]]
Output: 1
Explanation: The above image depicts how the matrix changes each day starting from day 0.
The last day where it is possible to cross from top to bottom is on day 1.

Example 3:

Input: row = 3, col = 3, cells = [[1,2],[2,1],[3,3],[2,2],[1,1],[1,3],[2,3],[3,2],[3,1]]
Output: 3
Explanation: The above image depicts how the matrix changes each day starting from day 0.
The last day where it is possible to cross from top to bottom is on day 3.

Constraints

2 <= row, col <= 2 * 104
4 <= row * col <= 2 * 104
cells.length == row * col
1 <= ri <= row
1 <= ci <= col
All the values of cells are unique.

내 솔루션

/**
 * https://leetcode.com/problems/last-day-where-you-can-still-cross
 * @param {number} row - 전체 행의 수
 * @param {number} col - 전체 열의 수
 * @param {number[][]} cells - 매일 물에 잠기는 좌표 리스트 (1-based)
 * @return {number} - 건널 수 있는 마지막 날짜
 */
var latestDayToCross = function (row, col, cells) {
    let answerDay = 0;
    // 이진 탐색을 위한 범위 설정 (0일부터 마지막 날까지)
    let left = 0;
    let right = cells.length - 1;

    /**
     * 특정 날짜(day)에 위에서 아래로 건널 수 있는지 확인하는 함수 (BFS)
     */
    const canCross = (day) => {
        // 1. 해당 날짜의 격자 상태 생성 (0: 땅, 1: 물)
        const grid = Array.from({ length: row }, () => new Array(col).fill(0));
        
        // 2. 0일부터 day일까지의 cells를 바탕으로 격자에 물 채우기
        // i < day 이므로, day가 3이면 cells[0], [1], [2] (3일치)를 채움
        for (let i = 0; i < day; i++) {
            const [r, c] = cells[i];
            grid[r - 1][c - 1] = 1; // 1-based 좌표를 0-based 인덱스로 변환
        }

        // 3. BFS 탐색 준비
        const queue = [];
        const visited = Array.from({ length: row }, () => new Array(col).fill(false));
        
        // 4. 시작 지점 설정: 맨 윗줄(row 0)에서 땅(0)인 곳을 모두 큐에 삽입
        for (let i = 0; i < col; i++) {
            if (grid[0][i] === 0) {
                queue.push([0, i]);
                visited[0][i] = true; // 중복 방문 방지
            }
        }

        // 5. 탐색 시작 (상하좌우 방향 설정)
        const direction = [[0, 1], [0, -1], [1, 0], [-1, 0]]; 
        
        while (queue.length > 0) {
            const [curR, curC] = queue.shift();
            
            // 목적지 도착: 맨 아랫줄(row - 1)에 도달하면 건너기 성공
            if (curR === row - 1) return true; 

            for (const [dirR, dirC] of direction) {
                const nextR = curR + dirR;
                const nextC = curC + dirC;
                
                // 격자 범위 내에 있고, 물이 아니며(0), 아직 방문하지 않은 경우만 이동
                if (nextR >= 0 && nextC >= 0 && nextR < row && nextC < col &&
                    grid[nextR][nextC] === 0 && !visited[nextR][nextC]) {
                    
                    visited[nextR][nextC] = true; // 방문 표시 (중요: nextR, nextC 사용)
                    queue.push([nextR, nextC]); // 다음 탐색 후보로 큐에 추가
                }
            }
        }

        // 모든 경로를 탐색했으나 아랫줄에 도달하지 못한 경우
        return false;
    }

    /**
     * 이진 탐색(Binary Search) 수행
     * 매일 BFS를 돌리면 느리기 때문에, '건널 수 있는 날'의 경계선을 Up/Down 게임처럼 탐색
     */
    while (left <= right) {
        // 중간 날짜(mid)를 선택
        const mid = Math.floor((left + right) / 2);
        
        if (canCross(mid)) {
            // 해당 날짜에 건널 수 있다면, 더 늦은 날짜가 가능한지 확인
            answerDay = mid; // 현재 날짜를 정답 후보로 저장
            left = mid + 1;  // 범위를 뒤쪽(더 큰 날짜)으로 좁힘
        } else {
            // 해당 날짜에 건널 수 없다면, 너무 많이 잠긴 것이므로 더 앞선 날짜 확인
            right = mid - 1; // 범위를 앞쪽(더 작은 날짜)으로 좁힘
        }
    }
    
    return answerDay;
};

감상평

처음엔 day 1 -> day end 까지 순회하려고 했는데, 너무 오래 걸릴 것 같아서 바이너리 서치로 변경
BFS + 바이너리 서치 2가지 조합이 필요한 문제. 역시 Hard는 달라
최적화는 못하겠다. 너무 힘듦.. 이거 1시간 짜리 코테에서 나오면 바로 맨붕인데 ㅋㅋㅋ
최소 4시간 급 코테에서 1문제 정도 등장할 가능성이 있어보임..

[leetCode/JS] 3074. Apple Redistribution into Boxes

쭘봉 — Mon, 29 Dec 2025 16:39:40 +0900

난이도 [ ] Easy

문제 설명

You are given an array apple of size n and an array capacity of size m. There are n packs where the ith pack contains apple[i] apples. There are m boxes as well, and the ith box has a capacity of capacity[i] apples. Return the minimum number of boxes you need to select to redistribute these n packs of apples into boxes. Note that, apples from the same pack can be distributed into different boxes.

당신에게는 크기가 n인 apple 배열과 크기가 m인 capacity 배열이 주어집니다.
n개의 팩이 있으며, i번째 팩에는 apple[i]개의 사과가 들어있습니다. 또한 m개의 상자가 있으며, i번째 상자는 capacity[i]개의 사과를 담을 수 있는 용량을 가지고 있습니다.
이 n팩의 사과들을 상자들에 다시 나누어 담기 위해 선택해야 하는 상자의 최소 개수를 반환하세요.
단, 같은 팩에 들어있던 사과들이라도 서로 다른 상자에 나누어서 담을 수 있다는 점에 유의하세요.

어렵게 설명 되어있는데, 사과의 Array는 의미가 없음. 총 사과가 몇개고, 몇개의 상자(capacity)로 담을 수 있느냐가 문제.

입출력 예

Example 1:

Input: apple = [1,3,2], capacity = [4,3,1,5,2]
Output: 2 Explanation: We will use boxes with capacities 4 and 5.
It is possible to distribute the apples as the total capacity is greater than or equal to the total number of apples.

입출력 예

Example 2:

Input: apple = [5,5,5], capacity = [2,4,2,7]
Output: 4 Explanation: We will need to use all the boxes.

Constraints

1 <= n == apple.length <= 50
1 <= m == capacity.length <= 50
1 <= apple[i], capacity[i] <= 50
The input is generated such that it's possible to redistribute packs of apples into boxes.

여기서 사과나 용량 배열은 숫자가 작구나를 파악하면 굿

내 솔루션

/**
 * https://leetcode.com/problems/apple-redistribution-into-boxes
 * @param {number[]} apple
 * @param {number[]} capacity
 * @return {number}
 */
 
// 처음 푼 문제
var minimumBoxes = function(apple, capacity) {
    const apples = apple.reduce((cur, acc) => acc += cur, 0)
    let sum = 0;
    let answer = 0;
    const sorted = capacity.sort((a, b) => b - a);
    
    for(let i = 0; i < sorted.length; i++){
        sum += sorted[i];
        if(sum >= apples) {
            answer = (i+1);
            break;
        }
    }
    return answer;
};


// While과 sum으로 더하는 방식이 빼는 방식으로 최적화
var minimumBoxes = function(apple, capacity) {
    let apples = apple.reduce((cur, acc) => acc + cur, 0)
    capacity.sort((a, b) => b - a);
    
    let idx = 0;
    while(apples > 0) {
        apples -= capacity[idx++]
    }
    return idx;
};

감상평

코테에서 나오면 5분컷 내야하는 문제긴한데, 좀 더 걸림