2025년 13주차 문제 풀이 (#38)

## 문제 풀이 목록

- [LeetCode 3169. Count Days Without
Meetings](https://leetcode.com/problems/count-days-without-meetings) ✨
- [LeetCode 3394. Check if Grid can be Cut into
Sections](https://leetcode.com/problems/check-if-grid-can-be-cut-into-sections)
✨
- [LeetCode 2033. Minimum Operations to Make a Uni-Value
Grid](https://leetcode.com/problems/minimum-operations-to-make-a-uni-value-grid)
✨
- [LeetCode 2780. Minimum Index of a Valid
Split](https://leetcode.com/problems/minimum-index-of-a-valid-split) ✨
- [LeetCode 2503. Maximum Number of Points From Grid
Queries](https://leetcode.com/problems/maximum-number-of-points-from-grid-queries)
✨
- [LeetCode 2818. Apply Operations to Maximize
Score](https://leetcode.com/problems/apply-operations-to-maximize-score)
✨
- [LeetCode 763. Partition
Labels](https://leetcode.com/problems/partition-labels)


## 변경사항

- LeetCode 문제 풀이에 사용되는 의존성 추가
-
[`@datastructures-js/deque`](https://github.com/datastructures-js/deque)
-
[`@datastructures-js/priority-queue`](https://github.com/datastructures-js/priority-queue)
-
[`@datastructures-js/queue`](https://github.com/datastructures-js/queue)

Author: sangrimlee

pnpm-lock.yaml

@@ -15,7 +15,10 @@
   },
   "prettier": "@algorithm/prettier-config",
   "dependencies": {
-    "@algorithm/lib": "workspace:*"
+    "@algorithm/lib": "workspace:*",
+    "@datastructures-js/deque": "^1.0.5",
+    "@datastructures-js/priority-queue": "^6.3.2",
+    "@datastructures-js/queue": "^4.2.3"
   },
   "devDependencies": {
     "@algorithm/eslint-config": "workspace:*",

solution/package.json

@@ -0,0 +1,51 @@
+import { minOperations } from './2033';
+
+describe('LeetCode 2033', () => {
+  test('Example 1', () => {
+    expect(
+      minOperations(
+        [
+          [2, 4],
+          [6, 8],
+        ],
+        2,
+      ),
+    ).toBe(4);
+  });
+  test('Example 2', () => {
+    expect(
+      minOperations(
+        [
+          [1, 5],
+          [2, 3],
+        ],
+        1,
+      ),
+    ).toBe(5);
+  });
+  test('Example 3', () => {
+    expect(
+      minOperations(
+        [
+          [1, 2],
+          [3, 4],
+        ],
+        2,
+      ),
+    ).toBe(-1);
+  });
+  test('Example 4', () => {
+    expect(
+      minOperations(
+        [
+          [454, 328, 160, 286, 664],
+          [496, 538, 748, 244, 286],
+          [34, 244, 454, 706, 790],
+          [496, 538, 832, 958, 328],
+          [370, 874, 370, 874, 286],
+        ],
+        42,
+      ),
+    ).toBe(122);
+  });
+});

solution/src/leetcode/2033/2033.test.ts

@@ -0,0 +1,18 @@
+/**
+ * 2033. Minimum Operations to Make a Uni-Value Grid
+ * https://leetcode.com/problems/minimum-operations-to-make-a-uni-value-grid
+ */
+export function minOperations(grid: number[][], x: number): number {
+  const values = grid.flat().sort((a, b) => a - b);
+  const midValue = values[Math.floor(values.length / 2)];
+
+  let operations = 0;
+  for (const value of values) {
+    const diff = Math.abs(midValue - value);
+    if (diff % x !== 0) {
+      return -1;
+    }
+    operations += diff / x;
+  }
+  return operations;
+}

solution/src/leetcode/2033/2033.ts

@@ -0,0 +1,8 @@
+{
+  "id": "2033",
+  "url": "https://leetcode.com/problems/minimum-operations-to-make-a-uni-value-grid",
+  "title": "Minimum Operations to Make a Uni-Value Grid",
+  "category": "Algorithms",
+  "difficulty": "Medium",
+  "tags": ["Array", "Math", "Sorting", "Matrix"]
+}

solution/src/leetcode/2033/meta.json

@@ -0,0 +1,56 @@
+import { maxPoints } from './2503';
+
+describe('LeetCode 2503', () => {
+  test('Example 1', () => {
+    expect(
+      maxPoints(
+        [
+          [1, 2, 3],
+          [2, 5, 7],
+          [3, 5, 1],
+        ],
+        [5, 6, 2],
+      ),
+    ).toEqual([5, 8, 1]);
+  });
+  test('Example 2', () => {
+    expect(
+      maxPoints(
+        [
+          [5, 2, 1],
+          [1, 1, 2],
+        ],
+        [3],
+      ),
+    ).toEqual([0]);
+  });
+  test('Example 3', () => {
+    expect(
+      maxPoints(
+        [
+          [420766, 806051, 922751],
+          [181527, 815280, 904568],
+          [952102, 4037, 140319],
+          [324081, 17907, 799523],
+          [176688, 90257, 83661],
+          [932477, 621193, 623068],
+          [135839, 554701, 511427],
+          [227575, 450848, 178065],
+          [785644, 204668, 835141],
+          [313774, 167359, 501496],
+          [641317, 620688, 74989],
+          [324499, 122376, 270369],
+          [2121, 887154, 848859],
+          [456704, 7763, 662087],
+          [286827, 145349, 468865],
+          [277137, 858176, 725551],
+          [106131, 93684, 576512],
+          [372563, 944355, 497187],
+          [884187, 600892, 268120],
+          [576578, 515031, 807686],
+        ],
+        [352655, 586228, 169685, 541073, 584647, 413832, 576537, 616413],
+      ),
+    ).toEqual([0, 2, 0, 2, 2, 0, 2, 2]);
+  });
+});

solution/src/leetcode/2503/2503.test.ts

@@ -0,0 +1,75 @@
+/**
+ * 2503. Maximum Number of Points From Grid Queries
+ * https://leetcode.com/problems/maximum-number-of-points-from-grid-queries
+ */
+export function maxPoints(grid: number[][], queries: number[]): number[] {
+  const [m, n, k] = [grid.length, grid[0].length, queries.length];
+  const directions = [
+    [0, 1],
+    [1, 0],
+    [0, -1],
+    [-1, 0],
+  ];
+  const sortedQueries = queries.map((query, i) => [query, i]).sort((a, b) => a[0] - b[0]);
+  const sortedCells = grid
+    .flat()
+    .map((value, i) => [value, Math.floor(i / n), i % n])
+    .sort((a, b) => a[0] - b[0]);
+
+  const unionFind = new UnionFind(m * n);
+  const result = new Array<number>(k).fill(0);
+
+  let cellIndex = 0;
+  for (const [query, queryIndex] of sortedQueries) {
+    while (cellIndex < m * n && sortedCells[cellIndex][0] < query) {
+      const [_, y, x] = sortedCells[cellIndex];
+      const cellId = y * n + x;
+
+      for (const [dy, dx] of directions) {
+        const [ny, nx] = [y + dy, x + dx];
+        if (0 <= ny && ny < m && 0 <= nx && nx < n && grid[ny][nx] < query) {
+          unionFind.union(cellId, ny * n + nx);
+        }
+      }
+      cellIndex += 1;
+    }
+    result[queryIndex] = query > grid[0][0] ? unionFind.getSize(0) : 0;
+  }
+
+  return result;
+}
+
+class UnionFind {
+  private readonly parents: number[];
+  private readonly sizes: number[];
+  constructor(n: number) {
+    this.parents = Array.from({ length: n }, (_, i) => i);
+    this.sizes = new Array<number>(n).fill(1);
+  }
+
+  find(x: number): number {
+    if (this.parents[x] !== x) {
+      this.parents[x] = this.find(this.parents[x]);
+    }
+    return this.parents[x];
+  }
+
+  union(x: number, y: number): void {
+    const parentX = this.find(x);
+    const parentY = this.find(y);
+    if (parentX === parentY) {
+      return;
+    }
+    if (this.sizes[parentX] > this.sizes[parentY]) {
+      this.parents[parentY] = parentX;
+      this.sizes[parentX] += this.sizes[parentY];
+    } else {
+      this.parents[parentX] = parentY;
+      this.sizes[parentY] += this.sizes[parentX];
+    }
+  }
+
+  getSize(x: number): number {
+    return this.sizes[this.find(x)];
+  }
+}

solution/src/leetcode/2503/2503.ts

@@ -0,0 +1,16 @@
+{
+  "id": "2503",
+  "url": "https://leetcode.com/problems/maximum-number-of-points-from-grid-queries",
+  "title": "Maximum Number of Points From Grid Queries",
+  "category": "Algorithms",
+  "difficulty": "Hard",
+  "tags": [
+    "Array",
+    "Two Pointers",
+    "Breadth-First Search",
+    "Union Find",
+    "Sorting",
+    "Heap (Priority Queue)",
+    "Matrix"
+  ]
+}

solution/src/leetcode/2503/meta.json

@@ -0,0 +1,16 @@
+import { minimumIndex } from './2780';
+
+describe('LeetCode 2780', () => {
+  test('Example 1', () => {
+    expect(minimumIndex([1, 2, 2, 2])).toBe(2);
+  });
+  test('Example 2', () => {
+    expect(minimumIndex([2, 1, 3, 1, 1, 1, 7, 1, 2, 1])).toBe(4);
+  });
+  test('Example 3', () => {
+    expect(minimumIndex([3, 3, 3, 3, 7, 2, 2])).toBe(-1);
+  });
+  test('Example 4', () => {
+    expect(minimumIndex([9, 5, 5, 1, 1, 1, 1, 8, 1])).toBe(-1);
+  });
+});

solution/src/leetcode/2780/2780.test.ts

@@ -0,0 +1,34 @@
+/**
+ * 2780. Minimum Index of a Valid Split
+ * https://leetcode.com/problems/minimum-index-of-a-valid-split
+ */
+export function minimumIndex(nums: number[]): number {
+  const n = nums.length;
+  const dominantElement = findDominantElement(nums);
+  const totalCount = nums.reduce((count, num) => (num === dominantElement ? count + 1 : count), 0);
+
+  let leftCount = 0;
+  for (let i = 0; i < n; i++) {
+    if (nums[i] === dominantElement) {
+      leftCount += 1;
+    }
+
+    const rightCount = totalCount - leftCount;
+    if (2 * leftCount > i + 1 && 2 * rightCount > n - i - 1) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function findDominantElement(nums: number[]): number {
+  let count = 0;
+  let candidate = 0;
+  for (const num of nums) {
+    if (count === 0) {
+      candidate = num;
+    }
+    count += candidate === num ? 1 : -1;
+  }
+  return candidate;
+}