[moonjonghoo]25.02.20

[Moonjonghoo]

📌 푼 문제

• DFS와 BFS
• 게임 맵 최단거리
• 전력망을 둘로 나누기
• 타겟 넘버

---

📝 간단한 풀이 과정

DFS와 BFS

• 그래프 탐색을 DFS(깊이 우선 탐색)와 BFS(너비 우선 탐색)로 구현하는 문제
• 입력된 간선을 통해 그래프를 생성 후, DFS와 BFS를 각각 수행
• DFS는 재귀적으로 방문 처리하며, BFS는 큐를 이용해 방문 처리

const fs = require("fs");
const input = fs.readFileSync("/dev/stdin").toString().trim().split("\n");

const [N, M, V] = input[0].split(" ").map(Number);
const edges = input.slice(1).map((line) => line.split(" ").map(Number));

const graph = Array.from({ length: N + 1 }, () => []);
edges.forEach(([a, b]) => {
  graph[a].push(b);
  graph[b].push(a);
});
graph.forEach((node) => node.sort((a, b) => a - b));

const dfs = (v, visited = []) => {
  if (visited.includes(v)) return;
  visited.push(v);
  graph[v].forEach((n) => dfs(n, visited));
  return visited;
};

const bfs = (v) => {
  let queue = [v],
    visited = [];
  while (queue.length) {
    let node = queue.shift();
    if (!visited.includes(node)) {
      visited.push(node);
      queue.push(...graph[node].filter((n) => !visited.includes(n)));
    }
  }
  return visited;
};

console.log(dfs(V, []).join(" "));
console.log(bfs(V).join(" "));

---

게임 맵 최단거리

• BFS(너비 우선 탐색)로 최단 거리를 구하는 문제
• 이동 가능한 방향(상, 하, 좌, 우)을 정의하고 큐를 활용해 탐색
• 도착 지점까지 가는 최단 경로를 반환, 도달 불가능하면 -1 반환

function solution(maps) {
  let n = maps.length;
  let m = maps[0].length;
  let answer = 1;
  let visited = maps;
  const dx = [-1, 1, 0, 0];
  const dy = [0, 0, -1, 1];
  let queue = [];
  queue.push([0, 0]);
  visited[0][0] = 0;

  while (queue.length > 0) {
    let size = queue.length;

    for (let i = 0; i < size; i++) {
      let [x, y] = queue.shift();

      for (let j = 0; j < 4; j++) {
        let nx = x + dx[j];
        let ny = y + dy[j];

        if (nx >= 0 && nx < n && ny >= 0 && ny < m && visited[nx][ny] === 1) {
          if (nx == n - 1 && ny == m - 1) {
            return ++answer;
          }
          queue.push([nx, ny]);
          visited[nx][ny] = 0;
        }
      }
    }
    answer++;
  }
  return -1;
}

---

전력망을 둘로 나누기

• DFS로 전력망을 나눠 각각의 송전탑 개수 차이를 최소화하는 문제
• 간선을 하나씩 제거하면서 두 개의 서브 그래프를 만들고, DFS로 크기를 구함
• 각 경우의 차이를 구해 최소값을 갱신

function solution(n, wires) {
  let answer = Infinity;

  function dfs(graph, start, visited) {
    visited[start] = true;
    let count = 1;

    for (let i = 0; i < graph[start].length; i++) {
      const neighbor = graph[start][i];
      if (!visited[neighbor]) {
        count += dfs(graph, neighbor, visited);
      }
    }

    return count;
  }

  for (let i = 0; i < n - 1; i++) {
    const graph = Array(n)
      .fill(null)
      .map(() => []);
    for (let j = 0; j < n - 1; j++) {
      if (i === j) continue;
      const [a, b] = wires[j];
      graph[a - 1].push(b - 1);
      graph[b - 1].push(a - 1);
    }

    const visited = Array(n).fill(false);
    let count1 = 0;
    let count2 = 0;

    for (let j = 0; j < n; j++) {
      if (!visited[j]) {
        if (count1 === 0) {
          count1 = dfs(graph, j, visited);
        } else {
          count2 = dfs(graph, j, visited);
        }
      }
    }

    const diff = Math.abs(count1 - count2);
    answer = Math.min(answer, diff);
  }

  return answer;
}

---

타겟 넘버

• DFS를 활용하여 모든 경우의 수를 탐색해 타겟 값을 만드는 문제
• 각 숫자를 + 또는 -로 설정하여 가능한 모든 조합을 탐색
• 최종적으로 타겟 넘버를 만들 수 있는 경우의 수를 반환

function solution(numbers, target) {
  let n = numbers.length;
  let check = Array.from({ length: n }, () => false);
  let answer = 0;
  function DFS(v) {
    if (v === n) {
      let sum = 0;
      for (let i = 0; i < n; i++) {
        if (check[i] === true) {
          sum += numbers[i];
        } else if (check[i] === false) {
          sum -= numbers[i];
        }
      }
      if (sum === target) answer++;
    } else {
      check[v] = true;
      DFS(v + 1);
      check[v] = false;
      DFS(v + 1);
    }
  }
  DFS(0);
  return answer;
}

---