.Zzumbong

행성과 별을 죽이는 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분컷 내야하는 문제긴한데, 좀 더 걸림

[leetCode/JS] 756. Pyramid Transition Matrix

쭘봉 — Mon, 29 Dec 2025 11:07:52 +0900

난이도 [ ] Medium

문제 설명

You are stacking blocks to form a pyramid. Each block has a color, which is represented by a single letter. Each row of blocks contains one less block than the row beneath it and is centered on top.

To make the pyramid aesthetically pleasing, there are only specific triangular patterns that are allowed. A triangular pattern consists of a single block stacked on top of two blocks. The patterns are given as a list of three-letter strings allowed, where the first two characters of a pattern represent the left and right bottom blocks respectively, and the third character is the top block.

For example, "ABC" represents a triangular pattern with a 'C' block stacked on top of an 'A' (left) and 'B' (right) block. Note that this is different from "BAC" where 'B' is on the left bottom and 'A' is on the right bottom.

You start with a bottom row of blocks bottom, given as a single string, that you must use as the base of the pyramid.

Given bottom and allowed, return true if you can build the pyramid all the way to the top such that every triangular pattern in the pyramid is in allowed, or false otherwise.

당신은 블록을 쌓아 피라미드를 만들고 있습니다. 각 블록은 하나의 알파벳 문자로 표시되는 색깔을 가지고 있습니다. 각 블록 층은 바로 아래층보다 블록이 하나 적으며, 아래층의 중앙 위에 놓입니다.
피라미드를 미적으로 아름답게 만들기 위해 허용되는 특정한 '삼각형 패턴'이 정해져 있습니다. 삼각형 패턴은 두 개의 블록 위에 하나의 블록을 쌓는 방식입니다. 이 패턴들은 allowed라는 세 글자 문자열 리스트로 제공되는데, 처음 두 글자는 각각 아래층의 왼쪽과 오른쪽 블록을 나타내고, 세 번째 글자는 그 위에 쌓이는 블록을 나타냅니다.
예를 들어 "ABC"라는 패턴은 왼쪽 'A'와 오른쪽 'B' 블록 위에 'C' 블록을 쌓는 것을 의미합니다. 이는 'B'가 왼쪽이고 'A'가 오른쪽인 "BAC"와는 다르다는 점에 유의하세요.
당신은 bottom이라는 문자열로 주어진 맨 아랫줄 블록들을 피라미드의 기초로 사용해야 합니다.
bottom과 allowed가 주어졌을 때, 피라미드의 모든 삼각형 패턴이 allowed에 포함된 규칙을 따르면서 꼭대기까지 피라미드를 완성할 수 있으면 true를, 그렇지 않으면 false를 반환하세요.

주어진 바닥(bottom)에서 시작해서, 허용된 규칙(allowed)에 맞는 블록들만 쌓아 올려 결국 꼭대기(블록 1개)까지 도달할 수 있는지 묻는 문제

입출력 예

Example 1:

Input: bottom = "BCD", allowed = ["BCC","CDE","CEA","FFF"]
Output: true
Explanation: The allowed triangular patterns are shown on the right. Starting from the bottom (level 3),
we can build "CE" on level 2 and then build "A" on level 1. There are three triangular patterns in the pyramid,
which are "BCC", "CDE", and "CEA". All are allowed.

Example 2:

Input: bottom = "AAAA", allowed = ["AAB","AAC","BCD","BBE","DEF"]
Output: false Explanation: The allowed triangular patterns are shown on the right.
Starting from the bottom (level 4), there are multiple ways to build level 3, but trying all the possibilites, you will get always stuck before building level 1.

Constraints

2 <= bottom.length <= 6
0 <= allowed.length <= 216
allowed[i].length == 3 The letters in all input strings are from the set {'A', 'B', 'C', 'D', 'E', 'F'}.
All the values of allowed are unique.

내 솔루션

층별 재귀와 다음 피라미드를 만드는 재귀를 2개 만들어야 한다는 생각을 하는게 정말 오래 걸렸다.
AAAA의 경우의 수가 AA -> B, C 중 1개를 선택해서 만들어야 하는 예시2를 안보여줬다면 영원히 걸렸을 지도 모른다ㅋㅋ
마지막에 Map()인 memo를 만든다면 속도 100% 달성 가능하다. 아니면 70%대

/**
 * https://leetcode.com/problems/pyramid-transition-matrix
 * @param {string} bottom - 피라미드의 맨 아랫줄 문자열
 * @param {string[]} allowed - 사용 가능한 [왼쪽, 오른쪽, 위] 패턴 리스트
 * @return {boolean} - 꼭대기까지 쌓을 수 있는지 여부
 */
var pyramidTransition = function (bottom, allowed) {
    
    // 1. [데이터 구조화] "왼쪽+오른쪽" 2글자를 키로, 위에 올 수 있는 "후보 문자들"을 배열로 저장
    // 예: "AA": ["B", "C"] 형태
    const patterns = allowed.reduce((acc, [left, right, top]) => {
        const key = left + right;
        acc[key] = (acc[key] || []);
        acc[key].push(top);
        return acc;
    }, {});

    // 2. [메모이제이션] 이미 확인한 '층(문자열)'의 결과를 저장해 중복 계산 방지
    // 키: "AAB", 값: true/false
    const memo = new Map();

    /**
     * [층 단위 재귀 함수]
     * 현재 층을 완성하고, 그 다음 윗층으로 올라가는 역할
     */
    const canSolve = (curr) => {
        // 꼭대기(길이 1)에 도달했다면 피라미드 건설 성공!
        if (curr.length === 1) return true;
        
        // 이 층 구성은 이미 검사해본 적이 있다면 저장된 결과를 반환
        if (memo.has(curr)) return memo.get(curr);

        // 현재 층(curr)을 기반으로 다음 층(nextRow)을 한 칸씩 쌓기 시작
        const result = buildRow(curr, "", 0);
        
        // 현재 층에서 꼭대기까지 갈 수 있는지 여부를 메모리에 기록
        memo.set(curr, result);
        return result;
    }

    /**
     * [칸 단위 재귀 함수] - 백트래킹의 핵심
     * 현재 층(curr)의 블록들을 조합해 바로 윗층(nextRow) 한 줄을 만드는 역할
     * @param {string} curr - 기준이 되는 아래층
     * @param {string} nextRow - 현재 만들어지고 있는 윗층 문자열
     * @param {number} idx - 아래층에서 검사할 블록의 시작 인덱스
     */
    const buildRow = (curr, nextRow, idx) => {
        // 윗층의 길이가 아래층보다 1 작게 완성되었다면 (한 줄 완성)
        if (nextRow.length === curr.length - 1) {
            // 완성된 줄을 '현재 층'으로 삼아 다시 윗층 쌓기 시도 (층 단위 재귀 호출)
            return canSolve(nextRow);
        }

        // 현재 검사 중인 두 블록(왼쪽, 오른쪽)으로 만들 수 있는 패턴 키 생성
        const key = curr[idx] + curr[idx + 1];
        const currentPattens = patterns[key] || [];

        // 가능한 모든 후보 문자('char')를 하나씩 대입해보며 탐색
        for (const char of currentPattens) {
            // 후보 문자를 윗층에 추가하고, 다음 칸(idx + 1)을 채우러 이동
            if (buildRow(curr, nextRow + char, idx + 1)) {
                // 이 경로로 끝까지 도달하는 데 성공했다면 즉시 true 반환 (가지치기)
                return true;
            }
        }
        
        // 모든 후보를 써봤지만 윗층을 완성할 수 없다면 false
        return false;
    }

    // 맨 처음 바닥(bottom)부터 피라미드 쌓기 시작
    return canSolve(bottom);
};

감상평

왐마 준내 어렵다.
리트코드 미디엄 수준으로 코테가 나오면 1시간에 1개도 못풀지도 모른다.

[leetCode/JS] 1351. Count Negative Numbers in a Sorted Matrix

쭘봉 — Mon, 29 Dec 2025 09:07:01 +0900

난이도 [ ] Easy

문제 설명

Given a m x n matrix grid which is sorted in non-increasing order both row-wise and column-wise,

return the number of negative numbers in grid.

여기서 non-increasing order는 내림차순(값이 같거나 작아짐)을 의미함.
그리고 이게 row-wise(가로)와 column-wise 모두에 적용된다는 것이 핵심.

입출력 예

Example 1:

Input: grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
Output: 8
Explanation: There are 8 negatives number in the matrix.

Example 2:

Input: grid = [[3,2],[1,0]]
Output: 0

Constraints

m == grid.length
n == grid[i].length
1 <= m, n <= 100
-100 <= grid[i][j] <= 100

Follow up: Could you find an O(n + m) solution?

내 솔루션

/**
 * @param {number[][]} grid
 * @return {number}
 */
var countNegatives = function(grid) {
    let row = grid.length - 1; // --
    let col = 0; // ++

    const n = grid[0].length;

    let count = 0;

    while(row >= 0 && col < n){
        if(grid[row][col] < 0) {
            count += (n - col)
            row--;
        } else {
            col++;
        }
    }
    return count;
};


// [[4,3,2,-1],
//  [3,2,1,-1],
//  [1,1,-1,-2],
//  [-1,-1,-2,-3]]

감상평

2차원 m * n 에서 n만 내림 차순인줄 알고 바이너리 서치를 통해 해결하려다가
O(n+m)이 가능하다 Follow up 힌트에서 가로 세로 모두 정렬 되어 있구나! 를 알아 차림.
영문을 너무 띄엄 띄엄 읽는게 문제야