Ksg2388 : [19week]

BOJ/[15565] 귀여운 라이언/ksg2388/Main.js

@@ -0,0 +1,58 @@
+const fs = require('fs');
+const filePath = process.platform === 'linux' ? '/dev/stdin' : 'input.txt';
+let input = fs.readFileSync(filePath).toString().trim().split('\n');
+
+const [N, K] = input.shift().split(' ').map(Number);
+const list = input.shift().split(' ').map(Number);
+let minLength = Infinity;
+let start = 0;
+let end = -1;
+let count = 0;
+
+// 초기 위치 찾기
+for (let i = 0; i < list.length; i++) {
+  if (list[i] === 1) {
+    if (count === 0) {
+      start = i;
+    }
+    count++;
+  }
+
+  if (count === K) {
+    end = i;
+    minLength = end - start + 1;
+    break;
+  }
+}
+
+console.log(findMinLength(start, end));
+
+function findMinLength(start, end) {
+  // K개 이상을 만족하는 집합이 없는 경우
+  if (end === -1) {
+    return -1;
+  }
+
+  // 다음 구간 탐색
+  while (end < list.length) {
+    if (list[start] === 1) {
+      count--;
+    }
+    start += 1;
+    end += 1;
+    if (list[end] === 1) count++;
+    // 구간 집합 안에 K개의 라이언 인형이 있는 경우
+    if (count === K) {
+      // 범위 재조정
+      if (list[start] === 2) {
+        while (list[start] !== 1 && start < end) {
+          start++;
+        }
+      }
+      // console.log(start, end);
+      minLength = end - start + 1;
+    }
+  }
+
+  return minLength;
+}

BOJ/[15565] 귀여운 라이언/ksg2388/README.md

@@ -0,0 +1,46 @@
+# [15565] 귀여운 라이언
+
+## :pushpin: **Algorithm**
+
+투포인터, 슬라이딩 윈도우
+
+## :round_pushpin: **Logic**
+
+```javascript
+function findMinLength(start, end) {
+  // K개 이상을 만족하는 집합이 없는 경우
+  if (end === -1) {
+    return -1;
+  }
+
+  // 다음 구간 탐색
+  while (end < list.length) {
+    if (list[start] === 1) {
+      count--;
+    }
+    start += 1;
+    end += 1;
+    if (list[end] === 1) count++;
+    // 구간 집합 안에 K개의 라이언 인형이 있는 경우
+    if (count === K) {
+      // 범위 재조정
+      if (list[start] === 2) {
+        while (list[start] !== 1 && start < end) {
+          start++;
+        }
+      }
+      minLength = end - start + 1;
+    }
+  }
+
+  return minLength;
+}
+```
+
+- start와 end를 한칸씩 뒤로 밀면서 라이언의 개수를 확인한다.
+- 라이언의 개수가 k개가 되는 경우 start가 라이언이 아니라면 start가 라이언이 될때까지 범위를 좁힌다.
+- 이후 end가 끝에 도달하기전까지 이 과정을 반복한다.
+
+## :black_nib: **Review**
+
+- 슬라이딩 윈도우와 투 포인터를 같이 사용해 해결할 수 있는 문제였다.

BOJ/[1563] 개근상/ksg2388/Main.js

@@ -0,0 +1,39 @@
+const fs = require('fs');
+const filePath = process.platform === 'linux' ? '/dev/stdin' : 'input.txt';
+let input = fs.readFileSync(filePath).toString().trim().split('\n');
+
+const N = Number(input);
+
+const dp = Array.from({ length: 1001 }, () =>
+  Array.from({ length: 2 }, () => Array.from({ length: 3 }, () => 0))
+);
+
+dp[1][0][0] = 1;
+dp[1][0][1] = 1;
+dp[1][1][0] = 1;
+
+for (let i = 1; i < N; i++) {
+  dp[i + 1][0][0] = (dp[i][0][0] + dp[i][0][1] + dp[i][0][2]) % 1000000;
+  dp[i + 1][0][1] = dp[i][0][0];
+  dp[i + 1][0][2] = dp[i][0][1];
+  dp[i + 1][1][0] =
+    (dp[i][1][0] +
+      dp[i][1][1] +
+      dp[i][1][2] +
+      dp[i][0][0] +
+      dp[i][0][1] +
+      dp[i][0][2]) %
+    1000000;
+  dp[i + 1][1][1] = dp[i][1][0];
+  dp[i + 1][1][2] = dp[i][1][1];
+}
+
+const sum =
+  dp[N][0][0] +
+  dp[N][0][1] +
+  dp[N][0][2] +
+  dp[N][1][0] +
+  dp[N][1][1] +
+  dp[N][1][2];
+
+console.log(sum % 1000000);

BOJ/[1563] 개근상/ksg2388/README.md

@@ -0,0 +1,33 @@
+# [1563] 개근상
+
+## :pushpin: **Algorithm**
+
+DP
+
+## :round_pushpin: **Logic**
+
+```javascript
+for (let i = 1; i < N; i++) {
+  dp[i + 1][0][0] = (dp[i][0][0] + dp[i][0][1] + dp[i][0][2]) % 1000000;
+  dp[i + 1][0][1] = dp[i][0][0];
+  dp[i + 1][0][2] = dp[i][0][1];
+  dp[i + 1][1][0] =
+    (dp[i][1][0] +
+      dp[i][1][1] +
+      dp[i][1][2] +
+      dp[i][0][0] +
+      dp[i][0][1] +
+      dp[i][0][2]) %
+    1000000;
+  dp[i + 1][1][1] = dp[i][1][0];
+  dp[i + 1][1][2] = dp[i][1][1];
+}
+```
+
+- 배열의 첫번째 인덱스에 현재 날짜를 저장하고, 첫번째에 지각, 두번째에 결석일을 저장해둔다.
+- 각각의 경우가 될 수 있는 모든 경우의 수를 저장한다.
+
+## :black_nib: **Review**
+
+- 보마자마 DP로 풀어야 한다는 생각이 들었는데 도저히 생각이 떠오르지 않았다...
+- 간단하게 생각한대로 식을 세우면 됬었는데 너무 어렵게 생각한 것 같다.

BOJ/[3584] 가장 가까운 공통 조상/ksg2388/Main.js

@@ -0,0 +1,86 @@
+const fs = require('fs');
+const filePath = process.platform === 'linux' ? '/dev/stdin' : 'input.txt';
+let input = fs.readFileSync(filePath).toString().trim().split('\n');
+
+const T = Number(input.shift());
+
+for (let tc = 0; tc < T; tc++) {
+  const N = Number(input.shift());
+  const visited = Array.from({ length: N + 1 }, () => 0); // root 노드를 찾기 위한 배열
+  const node = Array.from({ length: N + 1 }, () => []); // 자식 노드의 정보 저장
+  const parents = Array.from({ length: N + 1 }, () => 0);
+  const level = Array.from({ length: N + 1 }, () => 0);
+  let root = 0;
+
+  for (let i = 1; i < N; i++) {
+    const [parent, child] = input.shift().split(' ').map(Number);
+    node[parent].push(child);
+    parents[child] = parent;
+    visited[child] = 1;
+  }
+
+  // root node 찾기
+  for (let i = 1; i <= N; i++) {
+    if (visited[i] === 0) {
+      root = i;
+      break;
+    }
+  }
+  // level 설정
+  setTreeLevel(root, node, level);
+
+  const [target1, target2] = input.shift().split(' ').map(Number);
+
+  console.log(findCommonAncestor(target1, target2, parents, level));
+}
+
+function setTreeLevel(root, node, level) {
+  const start = root;
+  let count = 1;
+  level[start] = count++;
+  const q = [];
+
+  for (let item of node[start]) {
+    q.push(item);
+  }
+
+  while (q.length) {
+    const size = q.length;
+
+    for (let i = 0; i < size; i++) {
+      const cur = q.shift();
+      level[cur] = count;
+      for (let item of node[cur]) {
+        q.push(item);
+      }
+    }
+    count++;
+  }
+}
+
+function findCommonAncestor(a, b, parents, level) {
+  let lvA = level[a];
+  let lvB = level[b];
+  // a가 더 높은 레벨인 경우
+  if (lvA > lvB) {
+    const diff = lvA - lvB;
+    // 레벨 맞추기
+    for (let i = 0; i < diff; i++) {
+      a = parents[a];
+    }
+  }
+  // b가 더 높은 레벨인 경우
+  else if (lvA < lvB) {
+    const diff = lvB - lvA;
+    // 레벨 맞추기
+    for (let i = 0; i < diff; i++) {
+      b = parents[b];
+    }
+  }
+
+  while (a !== b) {
+    a = parents[a];
+    b = parents[b];
+  }
+  return a;
+}

BOJ/[3584] 가장 가까운 공통 조상/ksg2388/README.md

@@ -0,0 +1,50 @@
+# [3584] 가장 가까운 공통 조상
+
+## :pushpin: **Algorithm**
+
+LCA
+
+## :round_pushpin: **Logic**
+
+```javascript
+const visited = Array.from({ length: N + 1 }, () => 0); // root 노드를 찾기 위한 배열
+const node = Array.from({ length: N + 1 }, () => []); // 자식 노드의 정보 저장
+const parents = Array.from({ length: N + 1 }, () => 0);
+const level = Array.from({ length: N + 1 }, () => 0);
+```
+
+- root 노드를 찾을때 사용할 배열인 `visited`와 자식 노드와 부모 노드의 정보를 저장할 배열, 각 노드의 레벨을 저장할 배열을 각각 만든다.
+
+```javascript
+function setTreeLevel(root, node, level) {
+  const start = root;
+  let count = 1;
+  level[start] = count++;
+  const q = [];
+
+  for (let item of node[start]) {
+    q.push(item);
+  }
+
+  while (q.length) {
+    const size = q.length;
+
+    for (let i = 0; i < size; i++) {
+      const cur = q.shift();
+      level[cur] = count;
+      for (let item of node[cur]) {
+        q.push(item);
+      }
+    }
+    count++;
+  }
+}
+```
+
+- 두 노드의 높이를 같게 맞춘다.
+- 이후 노드의 값이 같아 질때까지 노드의 레벨을 한 칸씩 올린다.
+
+## :black_nib: **Review**
+
+- 어디서 들어본 적이 있는 알고리즘이라서 참고 자료를 보지 않고 비슷하게 구현을 하려고 노력했다.
+- 그러다보니 배열을 너무 여러개 사용한 것이 좀 신경쓰여서 추가로 다른 사람들의 풀이를 봐야겠다는 생각이 들었다.

Programmers/[155651] 호텔 대실/ksg2388/README.md

@@ -0,0 +1,48 @@
+# [155651] 호텔 대실
+
+## :pushpin: **Algorithm**
+
+그리디, 우선순위 큐
+
+## :round_pushpin: **Logic**
+
+```javascript
+const change_time = book_time.map((time) => {
+  const startTime = time[0].split(':').map(Number);
+  const endTime = time[1].split(':').map(Number);
+  return [startTime[0] * 60 + startTime[1], endTime[0] * 60 + endTime[1]];
+});
+```
+
+- 시작 시간별로 정렬을 하기위해 문자열을 분으로 변경했다.
+
+```javascript
+change_time.forEach((time) => {
+  if (!q.length) {
+    q.push(time[1] + 10);
+  }
+
+  // 대실 가능한 빈 방이 없는 경우
+  else if (q[q.length - 1] > time[0]) {
+    q.push(time[1] + 10);
+  } else {
+    // 대실 가능한 경우
+    while (q.length) {
+      if (q[q.length - 1] <= time[0]) {
+        q.pop();
+      } else break;
+    }
+    q.push(time[1] + 10);
+  }
+  q.sort((a, b) => b - a);
+  answer = Math.max(answer, q.length);
+});
+```
+
+- 다음 사람의 입실 시간과 가장 이른 퇴실 시간을 비교하여 입실 시간이 더 늦다면 새로운 방을 배정해준다.
+
+## :black_nib: **Review**
+
+- 예전에 비슷한 문제를 풀어서 우선순위 큐를 이용해야겠다고 생각했다.
+- 문자열이 정렬이 되지 않아서 일일히 분을 시간으로 치환해서 정렬을 했다.
+- 문자열을 다루는데 시간을 너무 잡아먹은 것 같다...