KingDonggyu: Week22 ~ Week25

Programmers/[118668] 코딩 테스트 공부/KingDonggyu/118668.js

@@ -0,0 +1,58 @@
+function solution(alp, cop, problems) {
+  let maxAlp = alp;
+  let maxCop = cop;
+
+  for (let i = 0; i < problems.length; i++) {
+    if (maxAlp < problems[i][0]) {
+      maxAlp = problems[i][0];
+    }
+
+    if (maxCop < problems[i][1]) {
+      maxCop = problems[i][1];
+    }
+  }
+
+  const dp = Array.from(Array(maxAlp + 1), () =>
+    Array(maxCop + 1).fill(Infinity)
+  );
+
+  dp[alp][cop] = 0;
+
+  for (let x = alp; x <= maxAlp; x++) {
+    for (let y = cop; y <= maxCop; y++) {
+      if (x < maxAlp) {
+        dp[x + 1][y] =
+          dp[x][y] + 1 < dp[x + 1][y] ? dp[x][y] + 1 : dp[x + 1][y];
+      }
+
+      if (y < maxCop) {
+        dp[x][y + 1] =
+          dp[x][y] + 1 < dp[x][y + 1] ? dp[x][y] + 1 : dp[x][y + 1];
+      }
+
+      for (const [alpReq, copReq, alpRwd, copRwd, cost] of problems) {
+        if (x < alpReq || y < copReq) {
+          continue;
+        }
+
+        let anotherX = x + alpRwd;
+        let anotherY = y + copRwd;
+
+        if (anotherX > maxAlp) {
+          anotherX = maxAlp;
+        }
+
+        if (anotherY > maxCop) {
+          anotherY = maxCop;
+        }
+
+        dp[anotherX][anotherY] =
+          dp[anotherX][anotherY] < dp[x][y] + cost
+            ? dp[anotherX][anotherY]
+            : dp[x][y] + cost;
+      }
+    }
+  }
+
+  return dp[maxAlp][maxCop];
+}

Programmers/[118669] 등산코스 정하기/KingDonggyu/118669.js

@@ -0,0 +1,51 @@
+function solution(n, paths, gates, summits) {
+  const graph = Array.from(Array(n + 1), () => []);
+  const isSummit = Array(n + 1).fill(false);
+
+  paths.forEach(([a, b, time]) => {
+    graph[a].push([b, time]);
+    graph[b].push([a, time]);
+  });
+
+  summits.forEach((summit) => {
+    isSummit[summit] = true;
+  });
+
+  const queue = [];
+  const visited = Array(n + 1).fill(Infinity);
+
+  gates.forEach((gate) => {
+    queue.push(gate);
+    visited[gate] = 0;
+  });
+
+  while (queue.length) {
+    const now = queue.shift();
+
+    if (isSummit[now]) {
+      continue;
+    }
+
+    graph[now].forEach(([next, time]) => {
+      const intensity = Math.max(time, visited[now]);
+
+      if (intensity < visited[next]) {
+        visited[next] = intensity;
+        queue.push(next);
+      }
+    });
+  }
+
+  let answer = [0, Infinity];
+
+  for (let i = 1; i < n + 1; i++) {
+    if (!isSummit[i]) {
+      continue;
+    }
+    if (answer[1] > visited[i]) {
+      answer = [i, visited[i]];
+    }
+  }
+
+  return answer;
+}

Programmers/[12905] 가장 큰 정사각형 찾기/KingDonggyu/12905.js

@@ -0,0 +1,29 @@
+function checkIsOutOfBounds(x, y, n, m) {
+  return x < 0 || y < 0;
+}
+
+function solution(board) {
+  let answer = 0;
+  const N = board.length;
+  const M = board[0].length;
+
+  board.forEach((row, x) => {
+    row.forEach((_, y) => {
+      if (
+        !board[x][y] ||
+        checkIsOutOfBounds(x - 1, y - 1, N, M) ||
+        checkIsOutOfBounds(x - 1, y, N, M) ||
+        checkIsOutOfBounds(x, y - 1, N, M)
+      ) {
+        return;
+      }
+
+      board[x][y] =
+        Math.min(board[x - 1][y - 1], board[x - 1][y], board[x][y - 1]) + 1;
+
+      answer = Math.max(answer, board[x][y]);
+    });
+  });
+
+  return answer * answer;
+}

Programmers/[12907] 거스름돈/KingDonggyu/12907.js

@@ -0,0 +1,17 @@
+const DIVIDER = 1000000007;
+
+function solution(n, money) {
+  const dp = Array(n + 1).fill(0);
+
+  dp[0] = 1;
+
+  money.forEach((m) => {
+    for (let change = 0; change <= n; change++) {
+      if (change >= m) {
+        dp[change] += dp[change - m] % DIVIDER;
+      }
+    }
+  });
+
+  return dp[n];
+}

Programmers/[12927] 야근 지수/KingDonggyu/12927.js

@@ -0,0 +1,24 @@
+function solution(n, works) {
+  const sorted = works.sort((a, b) => b - a);
+
+  while (n) {
+    const max = sorted[0];
+
+    for (let i = 0; i < sorted.length; i++) {
+      if (max <= sorted[i]) {
+        sorted[i] -= 1;
+        n -= 1;
+      }
+      if (!n) {
+        break;
+      }
+    }
+  }
+
+  return sorted.reduce((acc, cur) => {
+    if (cur < 0) {
+      return acc;
+    }
+    return acc + cur ** 2;
+  }, 0);
+}

Programmers/[12936] 줄 서는 방법/KingDonggyu/12936.js

@@ -0,0 +1,28 @@
+function factorial(number) {
+  if (number === 1) {
+    return 1;
+  }
+
+  const result = number * factorial(number - 1);
+  return result;
+}
+
+function solution(n, k) {
+  const answer = [];
+  let caseCount = factorial(n);
+  let people = Array(n)
+    .fill(0)
+    .map((_, i) => i + 1);
+
+  while (answer.length < n) {
+    caseCount = Math.floor(caseCount / people.length);
+
+    const index = Math.floor((k - 1) / caseCount);
+    const selectedPerson = people.splice(index, 1)[0];
+
+    answer.push(selectedPerson);
+    k = k % caseCount;
+  }
+
+  return answer;
+}

Programmers/[12938] 최고의 집합/KingDonggyu/12938.js

@@ -0,0 +1,16 @@
+function solution(n, s) {
+  if (n > s) {
+    return [-1];
+  }
+
+  const answer = [];
+
+  while (n) {
+    const value = Math.floor(s / n);
+    answer.push(value);
+    s -= value;
+    n--;
+  }
+
+  return answer;
+}

Programmers/[131703] 2차원 동전 뒤집기/KingDonggyu/131703.js

@@ -0,0 +1,70 @@
+function filpRow(coins, row) {
+  for (let col = 0; col < coins[0].length; col++) {
+    coins[row][col] = coins[row][col] ? 0 : 1;
+  }
+}
+
+function flipColumn(coins, col) {
+  for (let row = 0; row < coins.length; row++) {
+    coins[row][col] = coins[row][col] ? 0 : 1;
+  }
+}
+
+function solution(beginning, target) {
+  const N = beginning.length;
+  const M = beginning[0].length;
+  const MAX = N * M + 1;
+
+  let answer = MAX;
+  const visited = Array(N + M).fill(false);
+
+  function dfs(count) {
+    if (answer <= count) {
+      return;
+    }
+
+    for (let row = 0; row < N; row++) {
+      for (let col = 0; col < M; col++) {
+        if (beginning[row][col] === target[row][col]) {
+          continue;
+        }
+
+        // 행 뒤집기
+        if (!visited[row]) {
+          visited[row] = true;
+          filpRow(beginning, row);
+
+          dfs(count + 1);
+
+          visited[row] = false;
+          filpRow(beginning, row);
+        }
+
+        // 열 뒤집기
+        if (!visited[N + col]) {
+          visited[N + col] = true;
+          flipColumn(beginning, col);
+
+          dfs(count + 1);
+
+          visited[N + col] = false;
+          flipColumn(beginning, col);
+        }
+
+        // 실패
+        return;
+      }
+    }
+
+    // 성공
+    answer = count;
+  }
+
+  dfs(0);
+
+  if (answer < MAX) {
+    return answer;
+  }
+
+  return -1;
+}

Programmers/[132266] 부대복귀/KingDonggyu/132266.js

@@ -0,0 +1,30 @@
+function solution(n, roads, sources, destination) {
+  const graph = Array.from(Array(n + 1), () => []);
+
+  roads.forEach(([a, b]) => {
+    graph[a].push(b);
+    graph[b].push(a);
+  });
+
+  const queue = [destination];
+  const visited = Array(n + 1).fill(Infinity);
+
+  visited[destination] = 0;
+
+  while (queue.length) {
+    const started = queue.shift();
+
+    graph[started].forEach((arrived) => {
+      const time = visited[started] + 1;
+
+      if (visited[arrived] <= time) {
+        return;
+      }
+
+      visited[arrived] = time;
+      queue.push(arrived);
+    });
+  }
+
+  return sources.map((s) => (visited[s] === Infinity ? -1 : visited[s]));
+}