2025년 14주차 문제 풀이 (#39)

sangrimlee · web-flow · commit 6f3a03a63855 · 2025-04-08T23:18:36.000+09:00
## 문제 풀이 목록 - [LeetCode 2551. Put Marbles in Bags](https://leetcode.com/problems/put-marbles-in-bags) ✨ - [LeetCode 2140. Solving Questions With Brainpower](https://leetcode.com/problems/solving-questions-with-brainpower) - [LeetCode 2873. Maximum Value of an Ordered Triplet I](https://leetcode.com/problems/maximum-value-of-an-ordered-triplet-i) - [LeetCode 2874. Maximum Value of an Ordered Triplet II](https://leetcode.com/problems/maximum-value-of-an-ordered-triplet-ii) :sparkles: - [LeetCode 1123. Lowest Common Ancestor of Deepest Leaves](https://leetcode.com/problems/lowest-common-ancestor-of-deepest-leaves) - [LeetCode 1863. Sum of All Subset XOR Totals](https://leetcode.com/problems/sum-of-all-subset-xor-totals) - [LeetCode 368. Largest Divisible Subset](https://leetcode.com/problems/largest-divisible-subset)
diff --git a/solution/src/leetcode/0368/0368.ts b/solution/src/leetcode/0368/0368.ts
@@ -4,30 +4,29 @@
  */
 export function largestDivisibleSubset(nums: number[]): number[] {
   nums.sort((a, b) => a - b);
+
   const n = nums.length;
   const dp = new Array<number>(n).fill(1);
+  const prev = new Array<number>(n).fill(-1);
 
-  let maxSize = 1;
   let maxIndex = 0;
-  for (let i = 0; i < n; i++) {
+  for (let i = 1; i < n; i++) {
     for (let j = 0; j < i; j++) {
-      if (nums[i] % nums[j] !== 0) continue;
-      dp[i] = Math.max(dp[i], dp[j] + 1);
-      if (maxSize < dp[i]) {
-        maxSize = dp[i];
-        maxIndex = i;
+      if (nums[i] % nums[j] === 0 && dp[i] < dp[j] + 1) {
+        dp[i] = dp[j] + 1;
+        prev[i] = j;
       }
     }
+    if (dp[maxIndex] < dp[i]) {
+      maxIndex = i;
+    }
   }
 
-  const answer = [];
-  let maxNum = nums[maxIndex];
-  for (let i = maxIndex; 0 <= i; i--) {
-    if (maxNum % nums[i] === 0 && dp[i] === maxSize) {
-      answer.push(nums[i]);
-      maxNum = nums[i];
-      maxSize -= 1;
-    }
+  const answer: number[] = [];
+  let currentIndex = maxIndex;
+  while (currentIndex !== -1) {
+    answer.push(nums[currentIndex]);
+    currentIndex = prev[currentIndex];
   }
   return answer;
 }
diff --git a/solution/src/leetcode/1123/1123.ts b/solution/src/leetcode/1123/1123.ts
@@ -19,6 +19,7 @@ export function lcaDeepestLeaves(root: TreeNode | null): TreeNode | null {
     }
     return Math.max(leftMaxDepth, rightMaxDepth);
   }
+
   traverse(root, 0);
   return answer;
 }
diff --git a/solution/src/leetcode/1863/1863.ts b/solution/src/leetcode/1863/1863.ts
@@ -3,15 +3,7 @@
  * https://leetcode.com/problems/sum-of-all-subset-xor-totals
  */
 export function subsetXORSum(nums: number[]): number {
-  function backtrack(prev: number, i: number): number {
-    if (i === nums.length) {
-      return prev;
-    }
-    let ret = 0;
-    const num = nums[i];
-    ret += backtrack(prev ^ num, i + 1);
-    ret += backtrack(prev, i + 1);
-    return ret;
-  }
-  return backtrack(0, 0);
+  const n = nums.length;
+  const totalOR = nums.reduce((prev, num) => prev | num, 0);
+  return totalOR << (n - 1);
 }
diff --git a/solution/src/leetcode/2140/2140.ts b/solution/src/leetcode/2140/2140.ts
@@ -4,19 +4,11 @@
  */
 export function mostPoints(questions: number[][]): number {
   const n = questions.length;
-  const dp = new Array<number>(n).fill(0);
+  const dp = new Array<number>(n + 1).fill(0);
 
-  const dfs = (i: number) => {
-    if (n <= i) {
-      return 0;
-    }
-    if (dp[i] !== 0) {
-      return dp[i];
-    }
-    const [point, brainPower] = questions[i];
-    dp[i] = Math.max(dfs(i + 1), point + dfs(i + brainPower + 1));
-    return dp[i];
-  };
-
-  return dfs(0);
+  for (let i = n - 1; i >= 0; i--) {
+    const [points, brainpower] = questions[i];
+    dp[i] = Math.max(points + dp[Math.min(n, brainpower + i + 1)], dp[i + 1]);
+  }
+  return dp[0];
 }
diff --git a/solution/src/leetcode/2551/2551.test.ts b/solution/src/leetcode/2551/2551.test.ts
@@ -0,0 +1,10 @@
+import { putMarbles } from './2551';
+
+describe('LeetCode 2551', () => {
+  test('Example 1', () => {
+    expect(putMarbles([1, 3, 5, 1], 2)).toBe(4);
+  });
+  test('Example 2', () => {
+    expect(putMarbles([1, 3], 2)).toBe(0);
+  });
+});
diff --git a/solution/src/leetcode/2551/2551.ts b/solution/src/leetcode/2551/2551.ts
@@ -0,0 +1,18 @@
+/**
+ * 2551. Put Marbles in Bags
+ * https://leetcode.com/problems/put-marbles-in-bags
+ */
+export function putMarbles(weights: number[], k: number): number {
+  const n = weights.length;
+  const pairWeights: number[] = [];
+  for (let i = 0; i < n - 1; i++) {
+    pairWeights.push(weights[i] + weights[i + 1]);
+  }
+  pairWeights.sort((a, b) => a - b);
+
+  let answer = 0;
+  for (let i = 0; i < k - 1; i++) {
+    answer += pairWeights[n - i - 2] - pairWeights[i];
+  }
+  return answer;
+}
diff --git a/solution/src/leetcode/2551/meta.json b/solution/src/leetcode/2551/meta.json
@@ -0,0 +1,8 @@
+{
+  "id": "2551",
+  "url": "https://leetcode.com/problems/put-marbles-in-bags",
+  "title": "Put Marbles in Bags",
+  "category": "Algorithms",
+  "difficulty": "Hard",
+  "tags": ["Array", "Greedy", "Sorting", "Heap (Priority Queue)"]
+}
diff --git a/solution/src/leetcode/2873/2873.ts b/solution/src/leetcode/2873/2873.ts
@@ -6,12 +6,12 @@ export function maximumTripletValue(nums: number[]): number {
   const n = nums.length;
 
   let answer = 0;
-  let maxi = Math.max(nums[0], nums[1]);
-  let maxij = nums[0] - nums[1];
+  let maxI = Math.max(nums[0], nums[1]);
+  let maxDiff = nums[0] - nums[1];
   for (let k = 2; k < n; k++) {
-    answer = Math.max(answer, maxij * nums[k]);
-    maxi = Math.max(maxi, nums[k - 1]);
-    maxij = Math.max(maxij, maxi - nums[k]);
+    answer = Math.max(answer, maxDiff * nums[k]);
+    maxDiff = Math.max(maxDiff, maxI - nums[k]);
+    maxI = Math.max(maxI, nums[k]);
   }
   return answer;
 }
diff --git a/solution/src/leetcode/2874/2874.test.ts b/solution/src/leetcode/2874/2874.test.ts
@@ -0,0 +1,13 @@
+import { maximumTripletValue } from './2874';
+
+describe('LeetCode 2874', () => {
+  test('Example 1', () => {
+    expect(maximumTripletValue([12, 6, 1, 2, 7])).toBe(77);
+  });
+  test('Example 2', () => {
+    expect(maximumTripletValue([1, 10, 3, 4, 19])).toBe(133);
+  });
+  test('Example 3', () => {
+    expect(maximumTripletValue([1, 2, 3])).toBe(0);
+  });
+});
diff --git a/solution/src/leetcode/2874/2874.ts b/solution/src/leetcode/2874/2874.ts
@@ -0,0 +1,17 @@
+/**
+ * 2874. Maximum Value of an Ordered Triplet II
+ * https://leetcode.com/problems/maximum-value-of-an-ordered-triplet-ii
+ */
+export function maximumTripletValue(nums: number[]): number {
+  const n = nums.length;
+
+  let answer = 0;
+  let maxI = Math.max(nums[0], nums[1]);
+  let maxDiff = nums[0] - nums[1];
+  for (let k = 2; k < n; k++) {
+    answer = Math.max(answer, maxDiff * nums[k]);
+    maxDiff = Math.max(maxDiff, maxI - nums[k]);
+    maxI = Math.max(maxI, nums[k]);
+  }
+  return answer;
+}
diff --git a/solution/src/leetcode/2874/meta.json b/solution/src/leetcode/2874/meta.json
@@ -0,0 +1,8 @@
+{
+  "id": "2874",
+  "url": "https://leetcode.com/problems/maximum-value-of-an-ordered-triplet-ii",
+  "title": "Maximum Value of an Ordered Triplet II",
+  "category": "Algorithms",
+  "difficulty": "Medium",
+  "tags": ["Array"]
+}
diff --git a/website/src/contents/solutions/leetcode/1123.mdx b/website/src/contents/solutions/leetcode/1123.mdx
@@ -12,11 +12,32 @@ tags:
 url: https://leetcode.com/problems/lowest-common-ancestor-of-deepest-leaves
 ---
 
-## Solution
+## 문제 설명
 
-```typescript showLineNumbers
-import { TreeNode } from '@algorithm/lib';
+- 주어진 이진 트리에서 가장 깊은 리프 노드들의 **최소 공통 조상(Lowest Common Ancestor, LCA)를** 반환합니다.
+  - **리프 노드**: 자식이 없는 노드
+  - **최소 공통 조상**: 모든 노드가 속한 서브트리의 루트 중 가장 깊은 노드
+
+## 문제 풀이
+
+### `Lowest Common Ancestor (LCA)`
+
+**DFS(Depth-First Search)를** 활용하여, 각 서브트리의 최대 깊이를 계산하면서, 가장 깊은 리프 노드들의 공통 조상을 추적하여, 최소 공통 조상을 찾습니다.
 
+1. 최대 깊이 추적
+   - `maxDepth`는 트리에서 현재 까지 탐색한 최대 깊이를 저장합니다.
+   - DFS를 통해 각 노드의 깊이를 계산하며, 최대 깊이를 업데이트합니다.
+2. DFS 탐색
+   - `traverse` 함수는 재귀적으로 트리를 탐색하며, 다음을 수행합니다.
+     - 왼쪽과 오른쪽 서브트리를 각각 탐색하여 최대 깊이를 계산합니다.
+     - 현재 노드가 `maxDepth`에 해당하는 **가장 깊은 리프 노드들의 공통 조상인지 확인**합니다.
+3. **LCA** 조건
+   - **왼쪽과 오른쪽 서브트리의 최대 깊이가 같고, 그 깊이가 `maxDepth`와 동일하다면, 현재 노드는 가장 깊은 리프 노드들의 최소 공통 조상입니다.**
+   - 이를 통해, `answer`에 LCA를 저장합니다.
+4. 결과 반환
+   - DFS 탐색이 끝나면, `answer`에 저장된 최소 공통 조상을 반환합니다.
+
+```typescript showLineNumbers
 export function lcaDeepestLeaves(root: TreeNode | null): TreeNode | null {
   let maxDepth = 0;
   let answer: TreeNode | null = null;
@@ -32,12 +53,14 @@ export function lcaDeepestLeaves(root: TreeNode | null): TreeNode | null {
     }
     return Math.max(leftMaxDepth, rightMaxDepth);
   }
+
   traverse(root, 0);
   return answer;
 }
 ```
 
-### Complexity
+#### 복잡도
 
-- Time: `O(N)`
-- Space: `O(H)`
+- 시간 복잡도: $O(n)$
+- 공간 복잡도: $O(H)$
+  - $H$: 주어진 트리의 높이
diff --git a/website/src/contents/solutions/leetcode/1863.mdx b/website/src/contents/solutions/leetcode/1863.mdx
@@ -13,20 +13,60 @@ tags:
 url: https://leetcode.com/problems/sum-of-all-subset-xor-totals
 ---
 
-## Solution
+## 문제 설명
+
+- 주어진 배열 `nums`의 **모든 부분집합**에 대해 **XOR total의 합을 반환**해야 합니다.
+  - **부분집합이 중복**되어도 (같은 원소를 가지는 다른 조합) 각각 따로 계산해야 합니다.
+- **XOR total**이란, 배열에 있는 **모든 원소의 XOR 연산 결과**입니다.
+  - 빈 배열의 **XOR total**은 `0`입니다.
+
+## 문제 풀이
+
+### `Backtracking`
+
+**모든 부분집합을 백트래킹을 통해 순회**하면서, 각 부분집합의 XOR 값을 계산하고, 그 값을 모두 더하여 반환합니다.
 
 ```typescript showLineNumbers
 export function subsetXORSum(nums: number[]): number {
-  function backtrack(prev: number, i: number): number {
+  function sumXOR(i: number, curr: number): number {
     if (i === nums.length) {
-      return prev;
+      return curr;
     }
-    let ret = 0;
-    const num = nums[i];
-    ret += backtrack(prev ^ num, i + 1);
-    ret += backtrack(prev, i + 1);
-    return ret;
+    return sumXOR(i + 1, curr) + sumXOR(i + 1, curr ^ nums[i]);
   }
-  return backtrack(0, 0);
+  return sumXOR(0, 0);
+}
+```
+
+#### 복잡도
+
+- 시간 복잡도: $O(2^n)$
+- 공간 복잡도: $O(n)$
+
+---
+
+### `Bit Manipulation`
+
+> 💡 아이디어
+>
+> - 어떤 비트가 전체 부분집합 XOR 합에 포함되기 위해선, 해당 비트가 홀수 번 등장해야합니다.
+> - `nums`에 `n`개의 숫자가 있다면, 전체 부분집합의 개수는 $2^n$개 입니다.
+> - 이 중 절반인 $2^{n-1}$**개의 부분집합이 각 원소를 포함**합니다.
+> - 어떤 **비트가 한 번이라도 등장했다면**, 이 비트는 **전체 부분집합의 절반,** 즉 $2^{n-1}$개의 부분 집합에서 XOR 결과에 포함됩니다.
+
+1. `nums`의 모든 값을 OR 연산 → 모든 숫자에 홀수 번 나타난 비트를 전부 포함합니다. (`totalOR`)
+2. 이 비트들은 $2^{n-1}$번 XOR 합에 기여합니다.
+   - $\text{XOR 합계} = \text{totalOR} \times 2^{n - 1} = \text{totalOR} \ll (n - 1)$
+
+```typescript showLineNumbers
+export function subsetXORSum(nums: number[]): number {
+  const n = nums.length;
+  const totalOR = nums.reduce((prev, num) => prev | num, 0);
+  return totalOR << (n - 1);
 }
 ```
+
+#### 복잡도
+
+- 시간 복잡도: $O(n)$
+- 공간 복잡도: $O(1)$
diff --git a/website/src/contents/solutions/leetcode/2140.mdx b/website/src/contents/solutions/leetcode/2140.mdx
@@ -9,25 +9,54 @@ tags:
 url: https://leetcode.com/problems/solving-questions-with-brainpower
 ---
 
-## Solution
+## 문제 설명
+
+- 2차원 정수 배열 `questions`가 주어지며, 각 문제는 `[points, brainpower]`의 형태입니다.
+  - `points`: 해당 문제를 풀었을 때 얻는 점수
+  - `brainpower`: 문제를 풀었을 경우 건너뛰어야 하는 다음 문제 개수
+- 제한 사항
+  - **문제를 순서대로 진행**하며, **각 문제마다 풀지 않을지 결정**해야 합니다.
+  - 문제를 풀 경우, **지정된 개수만큼 다음 문제를 건너뛰어야 합니다.**
+  - 문제를 풀지 않으면, 다음 문제로 넘어갑니다.
+  - **최대로 얻을 수 있는 점수를 계산**해야 합니다.
+
+## 문제 풀이
+
+### `Dynamic Programming`
+
+**동적 계획법(Dynamic Programming)을** 활용하여, 각 문제를 풀거나 건너뛰는 선택을 통해 최적의 점수를 찾습니다.
+
+1. `dp` 배열 정의
+   - `dp[i]`는 문제 `i`부터 시작했을 때 얻을 수 있는 최대 점수를 저장합니다.
+   - 배열의 크기를 `n + 1`로 설정하여 마지막 질문 이후의 경우를 처리합니다.
+2. 점화식
+   - 각 질문에 대해 두 가지 선택지가 있습니다.
+   - 현재 질문을 풀고, 이후 `i + brainpower + 1`번째 문제로 이동:
+     - `i + brainpower + 1`이 `n`보다 큰 경우를 방지
+     - **`dp[i] = points + dp[Math.min(i + brainpower + 1, n)]`**
+   - 현재 문제를 건너뛰고, 다음 질문으로 이동:
+     - **`dp[i] = dp[i + 1]`**
+   - 최종적으로, 두 가지 선택지 중 더 큰 점수를 저장
+     - **`dp[i] = Math.max(points + dp[Math.min(i + brainpower + 1, n)], dp[i + 1])`**
+3. 역순으로 탐색
+   - `dp` 배열은 뒤에서부터 순회하며 값을 채웁니다.
+4. 결과 반환
+   - 첫 번째 질문부터 시작했을 때의 최대 점수인 `dp[0]`를 반환합니다.
 
 ```typescript showLineNumbers
 export function mostPoints(questions: number[][]): number {
   const n = questions.length;
-  const dp = new Array<number>(n).fill(0);
-
-  const dfs = (i: number) => {
-    if (n <= i) {
-      return 0;
-    }
-    if (dp[i] !== 0) {
-      return dp[i];
-    }
-    const [point, brainPower] = questions[i];
-    dp[i] = Math.max(dfs(i + 1), point + dfs(i + brainPower + 1));
-    return dp[i];
-  };
-
-  return dfs(0);
+  const dp = new Array<number>(n + 1).fill(0);
+
+  for (let i = n - 1; i >= 0; i--) {
+    const [points, brainpower] = questions[i];
+    dp[i] = Math.max(points + dp[Math.min(n, brainpower + i + 1)], dp[i + 1]);
+  }
+  return dp[0];
 }
 ```
+
+#### 복잡도
+
+- 시간 복잡도: $O(n)$
+- 공간 복잡도: $O(n)$
diff --git a/website/src/contents/solutions/leetcode/2551.mdx b/website/src/contents/solutions/leetcode/2551.mdx
diff --git a/website/src/contents/solutions/leetcode/2873.mdx b/website/src/contents/solutions/leetcode/2873.mdx
diff --git a/website/src/contents/solutions/leetcode/2874.mdx b/website/src/contents/solutions/leetcode/2874.mdx
diff --git a/website/src/contents/solutions/leetcode/368.mdx b/website/src/contents/solutions/leetcode/368.mdx

Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@ export function lcaDeepestLeaves(root: TreeNode \| null): TreeNode \| null {`
`19`	`19`	`}`
`20`	`20`	`return Math.max(leftMaxDepth, rightMaxDepth);`
`21`	`21`	`}`
	`22`	`+`
`22`	`23`	`traverse(root, 0);`
`23`	`24`	`return answer;`
`24`	`25`	`}`