[백준] 2644. 촌수계산

Tree 구조를 사용해서 풀이

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.StringTokenizer;

public class Main {
    private static List<Node> list = new ArrayList<>();
    private static boolean[] visit;

    private static int N;
    private static int me;
    private static int outher;
    private static Node meNode;

    private static int count = 0;

    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        N = Integer.parseInt(br.readLine());
        visit = new boolean[N + 1];

        StringTokenizer st = new StringTokenizer(br.readLine());

        me = Integer.parseInt(st.nextToken());
        outher = Integer.parseInt(st.nextToken());

        int m = Integer.parseInt(br.readLine());

        for (int i = 0; i < m; i++) {
            StringTokenizer st2 = new StringTokenizer(br.readLine());
            childOf(Integer.parseInt(st2.nextToken()), Integer.parseInt(st2.nextToken()));
        }

        meNode = list.stream().filter(node -> node.data == me).findAny().get();

        dfs(meNode, 0);

        int answer = count == 0 ? -1 : count;
        System.out.println(answer);
    }


    private static void dfs(Node node, int depth) {
        if (node == null || visit[node.data]) {
            return;
        }

        visit[node.data] = true;
        List<Node> child = node.child;
        Node parent = node.parent;

        if (node.data == outher) {
            count = depth;
            return;
        }

        child.forEach(childNode -> {
            dfs(childNode, depth + 1);
        });

        dfs(parent, depth + 1);

    }


    static class Node {
        Node parent;
        List<Node> child = new ArrayList<>();
        int data;

        @Override
        public String toString() {
            // TODO Auto-generated method stub
            return "data::" + data;
        }
    }


    public static Node childOf(int parentData, int childData) {
        Optional<Node> optParentNode =
                list.stream().filter(node -> node.data == parentData).findAny();
        Optional<Node> optChildNode =
                list.stream().filter(node -> node.data == childData).findAny();

        Node parentNode = optParentNode.orElseGet(() -> {
            Node node = new Node();
            list.add(node);
            return node;
        });

        Node childNode = optChildNode.orElseGet(() -> {
            Node node = new Node();
            list.add(node);
            return node;
        });

        childNode.data = childData;
        childNode.parent = parentNode;


        parentNode.data = parentData;
        parentNode.child.add(childNode);


        return childNode;
    }
}