[JustDevRae] 25.02.22 (#47)

* remove smallest number / 以�

* divisible numbers array / 以�

* duplicate number count / 湲곗�

* matrix addition / 以�

* array element length / 湲곗�

* rotate array / 湲곗�

* slice array / 湲곗�

* array algorithm md file

* reverse string / 기초

* control Z / 기초

* dart game / 중급

* valid parentheses / 중급

* crane claw game / 중급

* pair count / 湲곗�

* find point position / 湲곗�

* login success / 湲곗�

* card bundle / 以�

* make hamburger / 以�

* process / �ы�

* morse code / 湲곗�

* make B with A / 湲곗�

* setting order care / 湲곗�

* not finish runner / 以�

* rank order / 湲곗�

* sameTree / 湲곗�

* invert binary tree / 湲곗�

* maximum depth of binary / 湲곗�

* binary tree inorder traversal / 湲곗�

* binary tree level order traversal / 以�

* 以났�� 臾몄� �帷굅 / 湲곗�

* �� 踰�留� �깆媓�� 臾몄� / 湲곗�

* 臾댁��¦濡� K媛黝� �� 戮린 / 湲곗�

* ���몄���� / 以�

* Contains Duplicate / 湲곗�

* 寃��¦ 留� 理蕤�④굅由� / 以�

* �¢寃� �� / 以�

* 諛곕�� / �ы�

* Find if Path Exists in Graph / 湲곗�

* Find the Town Judge / 湲곗�

Author: JustDevRae

JustDevRae/Graph/delivery.js

@@ -0,0 +1,33 @@
+function solution(N, road, K) {
+  const graph = Array.from({ length: N + 1 }, () => []);
+  for (const [a, b, c] of road) {
+    graph[a].push({ node: b, cost: c });
+    graph[b].push({ node: a, cost: c });
+  }
+
+  const distance = new Array(N + 1).fill(Infinity);
+  distance[1] = 0;
+
+  const visited = new Array(N + 1).fill(false);
+
+  for (let i = 1; i <= N; i++) {
+    let current = -1;
+
+    for (let j = 1; j <= N; j++) {
+      if (!visited[j] && (current === -1 || distance[j] < distance[current])) {
+        current = j;
+      }
+    }
+
+    if (current === -1) break;
+
+    visited[current] = true;
+
+    for (const { node, cost } of graph[current]) {
+      if (distance[node] > distance[current] + cost) {
+        distance[node] = distance[current] + cost;
+      }
+    }
+  }
+  return distance.filter((time) => time <= K).length;
+}

JustDevRae/Graph/find_if_path_exists_in_graph.js

@@ -0,0 +1,25 @@
+var validPath = function (n, edges, source, destination) {
+  const adjacencyList = new Array(n).fill(0).map(() => []);
+  for (const [nodeA, nodeB] of edges) {
+    adjacencyList[nodeA].push(nodeB);
+    adjacencyList[nodeB].push(nodeA);
+  }
+
+  const visitedNodes = new Array(n).fill(false);
+  const bfsQueue = [source];
+  visitedNodes[source] = true;
+
+  while (bfsQueue.length) {
+    const currentNode = bfsQueue.shift();
+    if (currentNode === destination) return true;
+
+    for (const adjacentNode of adjacencyList[currentNode]) {
+      if (!visitedNodes[adjacentNode]) {
+        visitedNodes[adjacentNode] = true;
+        bfsQueue.push(adjacentNode);
+      }
+    }
+  }
+
+  return false;
+};

JustDevRae/Graph/find_the_town_judge.js

@@ -0,0 +1,16 @@
+var findJudge = function (n, trust) {
+  if (n === 1) return 1;
+
+  const trustScore = new Array(n + 1).fill(0);
+
+  for (const [a, b] of trust) {
+    trustScore[a]--;
+    trustScore[b]++;
+  }
+
+  for (let i = 1; i <= n; i++) {
+    if (trustScore[i] === n - 1) return i;
+  }
+
+  return -1;
+};

JustDevRae/Graph/game_map_shortest_distance.js

@@ -0,0 +1,30 @@
+function solution(maps) {
+  const n = maps.length;
+  const m = maps[0].length;
+
+  const dx = [0, 0, 1, -1];
+  const dy = [1, -1, 0, 0];
+
+  let queue = [];
+  queue.push([0, 0]);
+
+  while (queue.length) {
+    const [y, x] = queue.shift();
+
+    if (y === n - 1 && x === m - 1) {
+      return maps[y][x];
+    }
+
+    for (let i = 0; i < 4; i++) {
+      const ny = y + dy[i];
+      const nx = x + dx[i];
+
+      if (ny >= 0 && ny < n && nx >= 0 && nx < m && maps[ny][nx] === 1) {
+        maps[ny][nx] = maps[y][x] + 1;
+        queue.push([ny, nx]);
+      }
+    }
+  }
+
+  return -1;
+}

JustDevRae/Graph/target_number.js

@@ -0,0 +1,17 @@
+function solution(numbers, target) {
+  let count = 0;
+
+  function DFS(index, currentSum) {
+    if (index === numbers.length) {
+      if (currentSum === target) count++;
+      return;
+    }
+
+    DFS(index + 1, currentSum + numbers[index]);
+    DFS(index + 1, currentSum - numbers[index]);
+  }
+
+  DFS(0, 0);
+
+  return count;
+}