Merge pull request #672 from eric-hjh/main

[황장현] 101차 라이브 코테 제출

Author: github-actions[bot]

live10/test101/문제1/황장현.js

@@ -0,0 +1,30 @@
+const input = require('fs')
+  .readFileSync(process.platform === 'linux' ? '/dev/stdin' : './input.txt')
+  .toString()
+  .trim()
+  .split('\n')
+  .map((el) => el.split(' ').map(Number));
+
+function solution(input) {
+  const T = input[0][0];
+  const dp = Array(12).fill(0);
+  const result = [];
+  dp[1] = 1;
+  dp[2] = 2;
+  dp[3] = 4;
+
+  function 재귀(n) {
+    if (dp[n] !== 0) return dp[n];
+
+    dp[n] = 재귀(n - 1) + 재귀(n - 2) + 재귀(n - 3);
+    return dp[n];
+  }
+
+  for (let i = 1; i <= T; i++) {
+    const currentIndex = input[i][0];
+    result.push(재귀(currentIndex));
+  }
+  return result.join('\n');
+}
+
+console.log(solution(input));

live10/test101/문제2/황장현.js

@@ -0,0 +1,26 @@
+const input = require('fs')
+  .readFileSync(process.platform === 'linux' ? '/dev/stdin' : './input.txt')
+  .toString()
+  .trim()
+  .split('\n')
+  .map((el) => el.split(' ').map(Number));
+
+function solution(input) {
+  const N = input[0][0];
+  const cost = input.slice(1);
+  const dp = Array.from({ length: N + 1 }, () => Array(3).fill(0));
+
+  dp[1][0] = cost[0][0];
+  dp[1][1] = cost[0][1];
+  dp[1][2] = cost[0][2];
+
+  for (let i = 2; i <= N; i++) {
+    dp[i][0] = cost[i - 1][0] + Math.min(dp[i - 1][1], dp[i - 1][2]);
+    dp[i][1] = cost[i - 1][1] + Math.min(dp[i - 1][0], dp[i - 1][2]);
+    dp[i][2] = cost[i - 1][2] + Math.min(dp[i - 1][0], dp[i - 1][1]);
+  }
+
+  return Math.min(dp[N][0], dp[N][1], dp[N][2]);
+}
+
+console.log(solution(input));

live10/test101/문제3/황장현.js

@@ -0,0 +1,36 @@
+function solution(n, edge) {
+  const connects = new Array(n).fill().map((_) => []);
+  for (const e of edge) {
+    connects[e[0] - 1].push(e[1] - 1);
+    connects[e[1] - 1].push(e[0] - 1);
+  }
+
+  const visited = [1];
+  const queue = [0];
+  while (queue.length) {
+    const cur = queue.shift();
+
+    for (const next of connects[cur]) {
+      if (!visited[next]) {
+        visited[next] = visited[cur] + 1;
+        queue.push(next);
+      }
+    }
+  }
+
+  const max = Math.max(...visited);
+
+  return visited.filter((el) => el === max).length;
+}
+
+console.log(
+  solution(6, [
+    [3, 6],
+    [4, 3],
+    [3, 2],
+    [1, 3],
+    [1, 2],
+    [2, 4],
+    [5, 2],
+  ])
+);

live9/test100/문제2/황장현.js

@@ -3,38 +3,40 @@ const input = +require('fs')
   .toString()
   .trim();
 
-function solution(input) {
-  const N = input;
+function solution(N) {
   let count = 0;
+  const column = Array(N).fill(false);
+  const diagonal1 = Array(2 * N - 1).fill(false);
+  const diagonal2 = Array(2 * N - 1).fill(false);
 
-  function backTrack(y, x, idx, map) {
-    if (idx === N) {
+  function backTrack(row) {
+    if (row === N) {
       count++;
       return;
     }
 
-    for (let i = 0; i < N; i++) {
-      map[y][i] = 1;
-      map[i][x] = 1;
-      if (y + i < N && x + i < N) map[y + i][x + i] = 1;
-      if (y - i >= 0 && x - i >= 0) map[y - i][x - i] = 1;
-      if (y + i < N && x - i >= 0) map[y + i][x - i] = 1;
-      if (y - i >= 0 && x + i < N) map[y - i][x + i] = 1;
-    }
+    for (let col = 0; col < N; col++) {
+      if (
+        column[col] ||
+        diagonal1[row + col] ||
+        diagonal2[row - col + (N - 1)]
+      ) {
+        continue;
+      }
 
-    for (let i = 0; i < N; i++) {
-      const nextY = y + 1;
-      if (nextY < N && map[nextY][i] === 0) backTrack(nextY, i, idx + 1, map);
-      else break;
-    }
-  }
+      column[col] = true;
+      diagonal1[row + col] = true;
+      diagonal2[row - col + (N - 1)] = true;
 
-  for (let i = 0; i < N; i++) {
-    for (let j = 0; j < N; j++) {
-      const chessMap = Array.from({ length: N }, () => Array(N).fill(0));
-      backTrack(i, j, 1, chessMap);
+      backTrack(row + 1);
+
+      column[col] = false;
+      diagonal1[row + col] = false;
+      diagonal2[row - col + (N - 1)] = false;
     }
   }
+
+  backTrack(0);
   return count;
 }
 

live9/test100/문제3/황장현.js

@@ -0,0 +1,33 @@
+function solution(queue1, queue2) {
+  let sum1 = queue1.reduce((acc, cur) => acc + cur, 0);
+  let sum2 = queue2.reduce((acc, cur) => acc + cur, 0);
+
+  let count = 0;
+  let maxOperations = queue1.length * 3;
+
+  let idx1 = 0;
+  let idx2 = 0;
+  let totalQueue = [...queue1, ...queue2];
+
+  while (sum1 !== sum2) {
+    if (count > maxOperations) return -1;
+
+    if (sum1 < sum2) {
+      const popNum = totalQueue[idx2 + queue1.length];
+      sum2 -= popNum;
+      sum1 += popNum;
+      idx2++;
+    } else {
+      const popNum = totalQueue[idx1];
+      sum1 -= popNum;
+      sum2 += popNum;
+      idx1++;
+    }
+    count++;
+  }
+
+  return count;
+}
+
+console.log(solution([3, 2, 7, 2], [4, 6, 5, 1]));
+console.log(solution([1, 2, 1, 2], [1, 10, 1, 2]));