728x90
반응형
SMALL

DFS(깊이 우선 탐색, Depth-First Search)는 그래프나 트리를 탐색하는 알고리즘 중 하나이다. 이 방법은 주어진 그래프의 모든 정점(Vertex)을 방문하는 경로를 찾을 때 사용한다.

DFS는 이름에서 알 수 있듯이, 깊이 방향으로 우선 탐색하는 것을 기본 원리로 한다. 즉, 시작 노드에서 가능한 한 깊숙히 들어가면서 노드를 탐색하고, 더 이상 탐색할 자식 노드가 없을 경우 이전 노드로 돌아와서 그 다음 노드를 탐색하는 방식이다.

DFS의 동작 과정은 다음과 같다:

  1. 시작 노드를 선택하여 방문하고 방문한 노드를 스택에 push한다.
  2. 현재 방문한 노드에 인접한 노드 중에서 아직 방문하지 않은 노드가 있다면 그 노드를 방문하고 방문한 노드를 스택에 push한다. 만약 방문하지 않은 인접 노드가 없다면 스택에서 최상단 노드를 pop한다.
  3. 더 이상 2번의 과정을 반복할 수 없을 때까지 계속 반복한다.

DFS는 스택 또는 재귀 호출을 이용하여 구현할 수 있으며, 그래프의 모든 노드를 방문하고 싶을 때, 경로 탐색을 해야할 때 주로 사용된다.

import java.util.*;

class Graph {
    private int numOfNodes;  // 노드의 수를 저장
    private LinkedList<Integer> adjListArray[];  // 인접 리스트 배열

    // 생성자
    Graph(int numOfNodes) {
        this.numOfNodes = numOfNodes;  // 노드의 수 설정
        // 배열의 크기를 노드의 수로 설정
        adjListArray = new LinkedList[numOfNodes];

        // 각 노드마다 인접 노드를 저장할 리스트 생성
        for (int i = 0; i < numOfNodes; i++) {
            adjListArray[i] = new LinkedList<>();
        }
    }

    // 무방향 그래프에 간선 추가
    void addEdge(int src, int dest) {
        // src에서 dest로의 간선 추가
        adjListArray[src].add(dest);
        // dest에서 src로의 간선 추가
        adjListArray[dest].add(src);
    }

    // 노드 u에서 시작하는 그래프의 DFS를 실행하는 함수
    void DFSUtil(int node, boolean[] visited) {
        // 현재 노드를 방문했다고 표시하고 노드 출력
        visited[node] = true;
        System.out.print(node + " ");

        // 이 정점과 인접한 모든 정점에 대해 재귀적으로 탐색
        Iterator<Integer> iterator = adjListArray[node].listIterator();
        while (iterator.hasNext()) {
            int n = iterator.next();
            if (!visited[n])
                DFSUtil(n, visited);
        }
    }

    // DFS 순회를 수행하는 함수. 재귀적인 DFSUtil()을 사용함.
    void DFS(int startNode) {
        // 모든 정점을 방문하지 않았다고 표시
        boolean[] visited = new boolean[numOfNodes];

        // 재귀적 도우미 함수를 호출하여 모든 정점에서 DFS 순회를 출력
        DFSUtil(startNode, visited);
    }
}

public class Main {
    public static void main(String args[]) {
        Graph graph = new Graph(5);  // 5개의 노드를 가진 그래프 생성
        graph.addEdge(0, 1);  // 노드 0과 1 사이에 간선 추가
        graph.addEdge(0, 4);  // 노드 0과 4 사이에 간선 추가
        graph.addEdge(1, 2);  // 노드 1과 2 사이에 간선 추가
        graph.addEdge(1, 3);  // 노드 1과 3 사이에 간선 추가
        graph.addEdge(1, 4);  // 노드 1과 4 사이에 간선 추가
        graph.addEdge(2, 3);  // 노드 2와 3 사이에 간선 추가
        graph.addEdge(3, 4);  // 노드 3과 4 사이에 간선 추가

        System.out.println("DFS traversal of the graph starting from node 0: ");
        graph.DFS(0);  // 노드 0에서 시작하는 그래프의 DFS 순회 시작
    }
}

DFS는 그래프의 모든 노드를 방문하는 알고리즘 중 하나로, 현재 정점에서 가능한 한 깊숙이 들어가서 노드를 방문한 후, 더 이상 방문할 노드가 없을 때 이전 노드로 돌아가 다음 노드를 방문하는 방식을 취한다. 이러한 방식은 스택의 LIFO(Last In First Out) 원칙을 따르는데, 이는 재귀 함수의 호출 스택으로 쉽게 구현할 수 있다.

위 코드에서는 Graph 클래스 내에 DFSUtil 메소드를 통해 실제 DFS 알고리즘이 구현되어 있다. DFSUtil 메소드는 인접 노드를 찾아서 아직 방문하지 않은 노드를 재귀적으로 탐색한다. DFS 메소드에서는 방문 여부를 저장하는 boolean 배열 **visited**를 초기화하고 시작 노드를 지정하여 DFS를 시작한다.

이 예제에서 그래프는 다음과 같이 구성된다.

  0
 / \\
1---4
| \\ |
|  \\|
2---3

그래프에 대해 DFS 함수를 호출하면 노드 **0**에서 시작하는 DFS 탐색 결과를 콘솔에 출력하게 됩니다. 출력된 결과는 DFS 탐색 순서에 따른 노드 번호이다.


예를 들어, 아래와 같은 그래프가 있다고 가정하면

  A
 / \\
B---C
| \\ |
|  \\|
D---E

이 그래프에 DFS를 적용한다면 다음과 같은 순서로 노드를 방문하게 된다.

  1. 먼저 시작 노드인 **A**를 방문한다. (방문 노드: A)
  2. **A**에 인접한 노드 중 하나인 B를 방문한다. (A -> B)
  3. 다음으로 **B**에 인접한 노드 중 하나인 C를 방문한다. (A -> B -> C)
  4. **C**에 인접한 노드 중 **A**와 **B**는 이미 방문한 상태이므로 E를 방문한다.(A -> B -> C -> E)
  5. **E**에 인접한 노드 중 **B**와 **C**는 이미 방문했으므로 D를 방문한다. (A -> B -> C -> E -> D)
  6. 모든 노드를 방문했으므로 탐색을 종료한다.

위와 같이 깊이를 우선적으로 탐색하게 되면, 처음 시작 노드에서 가장 멀리 있는 노드를 먼저 방문하게 된다. DFS는 이와 같은 특성 때문에 미로 찾기, 경로 탐색 등에서 많이 활용된다.

 


왜... \을 쓰면 \\로 기록될까요....ㅠㅠㅠ

728x90
반응형
LIST

'CS > 알고리즘' 카테고리의 다른 글

동적 계산법  (0) 2023.06.07
큐(Queue)  (0) 2023.06.07
스택(Stack)  (0) 2023.06.07
이진 검색 트리(Binary Search Tree, BST)  (0) 2023.05.30
해싱(Hashing)  (0) 2023.05.30
728x90
반응형
SMALL

문제 설명

n개의 송전탑이 전선을 통해 하나의 트리 형태로 연결되어 있습니다. 당신은 이 전선들 중 하나를 끊어서 현재의 전력망 네트워크를 2개로 분할하려고 합니다. 이때, 두 전력망이 갖게 되는 송전탑의 개수를 최대한 비슷하게 맞추고자 합니다.

송전탑의 개수 n, 그리고 전선 정보 wires가 매개변수로 주어집니다. 전선들 중 하나를 끊어서 송전탑 개수가 가능한 비슷하도록 두 전력망으로 나누었을 때, 두 전력망이 가지고 있는 송전탑 개수의 차이(절대값)를 return 하도록 solution 함수를 완성해주세요.


제한사항

  • n은 2 이상 100 이하인 자연수입니다.
  • wires는 길이가 n-1인 정수형 2차원 배열입니다.
    • wires의 각 원소는 [v1, v2] 2개의 자연수로 이루어져 있으며, 이는 전력망의 v1번 송전탑과 v2번 송전탑이 전선으로 연결되어 있다는 것을 의미합니다.
    • 1 ≤ v1 < v2 ≤ n 입니다.
    • 전력망 네트워크가 하나의 트리 형태가 아닌 경우는 입력으로 주어지지 않습니다.

입출력 예

n wires result

9 [[1,3],[2,3],[3,4],[4,5],[4,6],[4,7],[7,8],[7,9]] 3
4 [[1,2],[2,3],[3,4]] 0
7 [[1,2],[2,7],[3,7],[3,4],[4,5],[6,7]] 1

입출력 예 설명

입출력 예 #1

  • 다음 그림은 주어진 입력을 해결하는 방법 중 하나를 나타낸 것입니다.

!https://grepp-programmers.s3.ap-northeast-2.amazonaws.com/files/production/5b8a0dcd-cba0-47ca-b5e3-d3bafc81f9d6/ex1.png

  • 4번과 7번을 연결하는 전선을 끊으면 두 전력망은 각 6개와 3개의 송전탑을 가지며, 이보다 더 비슷한 개수로 전력망을 나눌 수 없습니다.
  • 또 다른 방법으로는 3번과 4번을 연결하는 전선을 끊어도 최선의 정답을 도출할 수 있습니다.

입출력 예 #2

  • 다음 그림은 주어진 입력을 해결하는 방법을 나타낸 것입니다.

!https://grepp-programmers.s3.ap-northeast-2.amazonaws.com/files/production/b28865e1-a18e-429d-ae7a-14e77e801539/ex2.png

  • 2번과 3번을 연결하는 전선을 끊으면 두 전력망이 모두 2개의 송전탑을 가지게 되며, 이 방법이 최선입니다.

입출력 예 #3

  • 다음 그림은 주어진 입력을 해결하는 방법을 나타낸 것입니다.

!https://grepp-programmers.s3.ap-northeast-2.amazonaws.com/files/production/0a7f21af-1e07-4015-8ad3-c06155c613b3/ex3.png

  • 3번과 7번을 연결하는 전선을 끊으면 두 전력망이 각각 4개와 3개의 송전탑을 가지게 되며, 이 방법이 최선입니다.

트리에 대한 이해와 탐색 알고리즘을 요구하는 문제이다. 문제를 해결하는 한 가지 방법은 전선을 하나씩 끊어보면서 두 개의 서브트리로 나누고, 각 서브트리에 속하는 노드(송전탑)의 수를 세어보는 것이다. 이때 두 서브트리의 노드 수 차이가 가장 작은 경우를 찾으면 된다.

package LV2;

import java.util.ArrayList;
import java.util.Arrays;

public class H86971 {
    private boolean[] visited;  // 방문 여부를 저장하는 배열
    private ArrayList<Integer>[] adjList;  // 인접 리스트

    // DFS로 연결된 노드 수 세기
    private int countNodes(int node) {
        int count = 1;  // 현재 노드를 포함하므로 시작은 1
        visited[node] = true;  // 현재 노드를 방문했음을 표시

        // 인접한 노드를 순회
        for (int adjNode : adjList[node]) {
            // 아직 방문하지 않은 노드라면
            if (!visited[adjNode]) {
                // DFS를 재귀적으로 호출하며 연결된 노드 수를 증가
                count += countNodes(adjNode);
            }
        }

        return count;  // 연결된 노드의 수 반환
    }

    public int solution(int n, int[][] wires) {
        int answer = n;  // 초기 답변값은 전체 노드의 수로 설정
        visited = new boolean[n+1];  // 방문 배열 크기를 노드의 수+1로 초기화
        adjList = new ArrayList[n+1];  // 인접 리스트 크기를 노드의 수+1로 초기화

        // 인접 리스트 초기화
        for (int i = 1; i <= n; i++) {
            adjList[i] = new ArrayList<>();
        }

        // 인접 리스트 구성
        for (int[] wire : wires) {
            adjList[wire[0]].add(wire[1]);
            adjList[wire[1]].add(wire[0]);
        }

        // 각 전선을 끊어볼 때마다 두 그룹의 노드 수 차이 계산
        for (int[] wire : wires) {
            // 해당 전선을 인접 리스트에서 제거
            adjList[wire[0]].remove((Integer)wire[1]);
            adjList[wire[1]].remove((Integer)wire[0]);

            // 방문 배열 초기화
            Arrays.fill(visited, false);

            // DFS를 이용하여 노드 수 계산
            int count = countNodes(wire[0]);

            // 노드 수 차이를 계산하여 최소값을 찾음
            answer = Math.min(answer, Math.abs(n - 2 * count));

            // 끊었던 전선을 다시 연결
            adjList[wire[0]].add(wire[1]);
            adjList[wire[1]].add(wire[0]);
        }

        // 최소 노드 수 차이 반환
        return answer;
    }
}

입력으로 주어진 전선 정보를 이용해 인접 리스트를 구성한 후, 각 전선을 하나씩 끊어보면서 두 개의 서브트리로 나눈다. 그런 다음, 각 서브트리에 속하는 노드의 수를 세어 노드 수 차이를 계산하고, 그 중 최소값을 찾아 반환한다. 노드의 수는 DFS를 이용해 계산한다.

728x90
반응형
LIST

'알고리즘 > 프로그래머스 JAVA LV.2' 카테고리의 다른 글

숫자 카드 나누기  (0) 2023.06.20
무인도 여행  (0) 2023.06.20
테이블 해시 함수  (0) 2023.06.19
줄 서는 방법  (0) 2023.06.16
가장 큰 정사각형 찾기  (0) 2023.06.15
728x90
반응형
SMALL

문제 설명

철수와 영희는 선생님으로부터 숫자가 하나씩 적힌 카드들을 절반씩 나눠서 가진 후, 다음 두 조건 중 하나를 만족하는 가장 큰 양의 정수 a의 값을 구하려고 합니다.

  1. 철수가 가진 카드들에 적힌 모든 숫자를 나눌 수 있고 영희가 가진 카드들에 적힌 모든 숫자들 중 하나도 나눌 수 없는 양의 정수 a
  2. 영희가 가진 카드들에 적힌 모든 숫자를 나눌 수 있고, 철수가 가진 카드들에 적힌 모든 숫자들 중 하나도 나눌 수 없는 양의 정수 a

예를 들어, 카드들에 10, 5, 20, 17이 적혀 있는 경우에 대해 생각해 봅시다. 만약, 철수가 [10, 17]이 적힌 카드를 갖고, 영희가 [5, 20]이 적힌 카드를 갖는다면 두 조건 중 하나를 만족하는 양의 정수 a는 존재하지 않습니다. 하지만, 철수가 [10, 20]이 적힌 카드를 갖고, 영희가 [5, 17]이 적힌 카드를 갖는다면, 철수가 가진 카드들의 숫자는 모두 10으로 나눌 수 있고, 영희가 가진 카드들의 숫자는 모두 10으로 나눌 수 없습니다. 따라서 철수와 영희는 각각 [10, 20]이 적힌 카드, [5, 17]이 적힌 카드로 나눠 가졌다면 조건에 해당하는 양의 정수 a는 10이 됩니다.

철수가 가진 카드에 적힌 숫자들을 나타내는 정수 배열 arrayA와 영희가 가진 카드에 적힌 숫자들을 나타내는 정수 배열 arrayB가 주어졌을 때, 주어진 조건을 만족하는 가장 큰 양의 정수 a를 return하도록 solution 함수를 완성해 주세요. 만약, 조건을 만족하는 a가 없다면, 0을 return 해 주세요.


제한사항

제한사항

  • 1 ≤ arrayA의 길이 = arrayB의 길이 ≤ 500,000
  • 1 ≤ arrayA의 원소, arrayB의 원소 ≤ 100,000,000
  • arrayA와 arrayB에는 중복된 원소가 있을 수 있습니다.

입출력 예

arrayA arrayB result

[10, 17] [5, 20] 0
[10, 20] [5, 17] 10
[14, 35, 119] [18, 30, 102] 7

입출력 예 설명

입출력 예 #1

  • 문제 예시와 같습니다.

입출력 예 #2

  • 문제 예시와 같습니다.

입출력 예 #3

  • 철수가 가진 카드에 적힌 숫자들은 모두 3으로 나눌 수 없고, 영희가 가진 카드에 적힌 숫자는 모두 3으로 나눌 수 있습니다. 따라서 3은 조건에 해당하는 양의 정수입니다. 하지만, 철수가 가진 카드들에 적힌 숫자들은 모두 7로 나눌 수 있고, 영희가 가진 카드들에 적힌 숫자는 모두 7로 나눌 수 없습니다. 따라서 최대값인 7을 return 합니다.

정답

package LV2;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class H135807 {
    private int getMin(int[] array) {
        int min = Integer.MAX_VALUE;
        for (int num : array) {
            min = Math.min(min, num);
        }
        return min;
    }

    // 주어진 숫자의 약수들을 반환하는 함수
    private List<Integer> getDivisors(int num) {
        List<Integer> divisors = new ArrayList<>();
        for (int i = 1; i * i <= num; i++) {
            if (num % i == 0) {
                divisors.add(i);
                if (i * i != num) {
                    divisors.add(num / i);
                }
            }
        }
        // 약수들을 큰 숫자부터 작은 숫자 순서로 정렬
        divisors.sort(Collections.reverseOrder());
        return divisors;
    }

    // 주어진 배열의 모든 숫자들이 주어진 약수로 나누어 떨어지는지 확인하는 함수
    private boolean canDivideAll(int[] array, int divisor) {
        for (int num : array) {
            if (num % divisor != 0) {
                return false;
            }
        }
        return true;
    }

    // 주어진 배열의 숫자 중 하나라도 주어진 약수로 나누어 떨어지는지 확인하는 함수
    private boolean canDivideAny(int[] array, int divisor) {
        for (int num : array) {
            if (num % divisor == 0) {
                return true;
            }
        }
        return false;
    }

    // 철수와 영희가 가지고 있는 카드에서 조건을 만족하는 최대 약수를 찾는 함수
    private int getAnswer(int[] arrayA, int[] arrayB) {
        int minA = getMin(arrayA);
        List<Integer> divisors = getDivisors(minA);
        for (int divisor : divisors) {
            // 철수의 카드 숫자들이 모두 약수로 나누어 떨어지고, 영희의 카드 숫자들 중 어느 것도 약수로 나누어 떨어지지 않을 때
            if (canDivideAll(arrayA, divisor) && !canDivideAny(arrayB, divisor)) {
                return divisor;
            }
        }
        return 0;
    }

    // 철수와 영희가 갖고 있는 카드에 적힌 숫자들로부터 조건을 만족하는 최대 약수를 찾는 함수
    public int solution(int[] arrayA, int[] arrayB) {
        // 철수와 영희의 역할을 바꿔서 계산한 결과 중에서 더 큰 값을 반환
        return Math.max(getAnswer(arrayA, arrayB), getAnswer(arrayB, arrayA));
    }
}

각각 철수와 영희의 카드 숫자들을 기반으로 약수를 찾아내고, 이 중에서 문제에서 요구하는 조건을 만족하는 최대 약수를 찾아내는 방식으로 작동한다. 마지막으로, 철수와 영희의 역할을 바꿔서 계산한 두 가지 경우 중에서 더 큰 결과값을 반환한다.


틀린 이유

import java.util.*;

class Solution {
    private int getMin(int[] array) {
        int min = Integer.MAX_VALUE;
        for (int num : array) {
            min = Math.min(min, num);
        }
        return min;
    }

    private List<Integer> getDivisors(int num) {
        List<Integer> divisors = new ArrayList<>();
        for (int i = 1; i * i <= num; i++) {
            if (num % i == 0) {
                divisors.add(i);
                if (i * i != num) {
                    divisors.add(num / i);
                }
            }
        }
        divisors.sort(Collections.reverseOrder());
        return divisors;
    }

    private boolean canDivideAll(int[] array, int divisor) {
        for (int num : array) {
            if (num % divisor != 0) {
                return false;
            }
        }
        return true;
    }

    private int getAnswer(int[] arrayA, int[] arrayB) {
        int minA = getMin(arrayA);
        List<Integer> divisors = getDivisors(minA);
        for (int divisor : divisors) {
            if (canDivideAll(arrayA, divisor) && !canDivideAll(arrayB, divisor)) {
                return divisor;
            }
        }
        return 0;
    }

    public int solution(int[] arrayA, int[] arrayB) {
        return Math.max(getAnswer(arrayA, arrayB), getAnswer(arrayB, arrayA));
    }
}

최대 공약수를 찾는 대신 각 배열에서 가장 작은 숫자의 약수를 찾는 부분이 정확히 반영되지 않은 것 같다.

문제에서, "모든 숫자들 중 하나도 나눌 수 없는 양의 정수"라는 말은 그 숫자가 반드시 두 번째 배열의 모든 원소들의 약수가 아니어야 한다는 것을 의미하기에 따라서, 만약 그 숫자가 두 번째 배열의 어떤 원소를 나눌 수 있다면, 그 숫자를 제외해야 한다.

728x90
반응형
LIST

'알고리즘 > 프로그래머스 JAVA LV.2' 카테고리의 다른 글

전력망을 둘로 나누기  (0) 2023.06.20
무인도 여행  (0) 2023.06.20
테이블 해시 함수  (0) 2023.06.19
줄 서는 방법  (0) 2023.06.16
가장 큰 정사각형 찾기  (0) 2023.06.15

+ Recent posts