问题 C: 世界那么大，我想去看看

题目描述

河南省实验中学的一名教师T的一封辞职信引发热评，辞职的理由仅有10个字：“世界那么大，我想去看看”。网友评这是“史上最具情怀的辞职信，没有之一”。经采访得知，作者为2004年7月入职河南省实验中学的一名女心理教师，已经任职11年之久。如此任性的辞职信，领导最后还真批准了。 


现在假设世界上有n个城市（用1~n标识 ），有m个高铁线路ei 格式为 xi yi ;   T的开始城市 f, 结束城市 e，她希望把所有的道路 都不重复的访问一遍，如果可以做到就输出YES 否则输出 NO

输入

城市数n和铁路m  
开始城市 f 和目的城市e 
每条铁路的起止城市 xi  yi   

输出

如果可以从开始城市 f,结束城市 e ，并把所有路径都不重复的访问一遍，就输出YES 否则输出NO

样例输入

3 2
1 3
1 2
2 3

样例输出

YES

提示

路线没有方向性，但是两个城市之间可能有多个线路 数据保证图一定是联通的

import java.util.*;
public class Main {
    static int n;
    static int m;
    static Set<Integer> set1;
    static Scanner cin=new Scanner(System.in);
    public static void main(String[] args) {
        n=cin.nextInt();
        m=cin.nextInt();
        int f=cin.nextInt();
        int e=cin.nextInt();
        Graph G=new Graph();
        List<Integer> list1=new LinkedList<>();
        List<Integer> list2=new LinkedList<>();
        Paths search=new Paths(G,f);
        if (search.hasPathTo(e)) {
            for (int x : search.pathTo(e)) {
                list1.add(x);
            }
        }
        Collections.sort(list1);
        for(int i:set1){
            list2.add(i);
        }
        if(list1.equals(list2)){
            System.out.println("YES");
        }
        else{
            System.out.println("NO");
        }
        cin.close();
    }
    private static class Graph {
        static int V;
        int E;
        static LinkedList<Integer>[] adj;
        public Graph() {
            this.V=n;
            this.E=m;
            adj=new LinkedList[V+1];
            for(int v=1;v<V+1;v++){
                adj[v]=new LinkedList<>();
            }
            set1=new HashSet<>();
            for(int i=0;i<E;i++){
                int v=cin.nextInt();
                int w=cin.nextInt();
                set1.add(v);
                set1.add(w);
                addEdge(v,w);
            }
        }
        private void addEdge(int v, int w) {
            adj[v].add(w);
            adj[w].add(v);
        }
        public Iterable<Integer> adj(int v){
            return adj[v];
        }
        public int V(){
            return V;
        }
    }
    private static class Paths {
        private boolean[] marked;
        private int[] edgeto;
        private final int s;
        public Paths(Graph G, int f) {
            marked=new boolean[G.V()+1];
            edgeto=new int[G.V()+1];
            this.s = f;
            dfs(G,s);
        }
        private void dfs(Graph G, int v) {
            marked[v]=true;
            for(int w:G.adj(v)){
                if(!marked[w]){
                    edgeto[w]=v;
                    dfs(G,w);
                }
            }
        }
        public boolean hasPathTo(int v){
            return marked[v];
        }
        public Iterable<Integer> pathTo(int v){
            if(!hasPathTo(v)) return null;
            Stack<Integer> path=new Stack<>();
            for(int x=v;x!=s;x=edgeto[x])
                path.push(x);
            path.push(s);
            return path;
        }
    }
}