diff --git "a/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-10266] \354\213\234\352\263\204 \354\202\254\354\247\204\353\223\244.java" "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-10266] \354\213\234\352\263\204 \354\202\254\354\247\204\353\223\244.java"
new file mode 100644
index 00000000..8d1b66aa
--- /dev/null
+++ "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-10266] \354\213\234\352\263\204 \354\202\254\354\247\204\353\223\244.java"	
@@ -0,0 +1,84 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+	
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	    
+        //입력 값
+        int n = Integer.parseInt(br.readLine());
+        int[] a = new int[n];
+        int[] b = new int[n];
+        
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        for(int i=0; i<n; i++) {
+        	a[i] = Integer.parseInt(st.nextToken());
+        }
+        st = new StringTokenizer(br.readLine());
+        for(int i=0; i<n; i++) {
+        	b[i] = Integer.parseInt(st.nextToken());
+        }
+        
+        //바늘의 각도가 특정 순서대로 주어지지 않아, 정렬
+        Arrays.sort(a);
+        Arrays.sort(b);
+        
+        //a 배열의 각 바늘 간 사잇각을 저장하는 배열
+        int[] da = new int[n];
+        int pre = 0;
+        for(int i=1; i<n; i++) {
+        	da[i-1] = a[i]-a[pre++];
+        }
+        //첫 바늘과 마지막 바늘의 사잇각
+        da[n-1] = a[0]+360000 - a[n-1];
+        
+        //b 배열의 각 바늘 간 사잇각을 저장하는 배열
+        int[] db = new int[n];
+        pre = 0;
+        for(int i=1; i<n; i++) {
+        	db[i-1] = b[i]-b[pre++];
+        }
+        //첫 바늘과 마지막 바늘의 사잇각
+        db[n-1] = b[0]+360000 - b[n-1];
+        
+        //실패 함수: pi배열
+        //pi[i]: 0~i까지의 부분 문자열에서 접두사와 접미사의 최대 길이
+        int[] pi = new int[n];
+        
+        int j=0;
+        for(int i=1; i<n; i++) {
+        	while(j>0 && da[i] != da[j]) {
+        		j = pi[j-1];
+        	}
+        	if(da[i] == da[j]) {
+        		pi[i] = ++j;
+        	}
+        }
+        
+        //모든 점을 시작점으로 비교하기 위한 배열
+        int[] target = new int[2*n];
+        for(int i=0; i<2*n; i++){
+        	target[i] = db[i%n];
+        }
+        
+        //kmp
+        j=0;
+        for(int i=0; i<2*n; i++) {
+        	while(j>0 && target[i] != da[j]) {
+        		j = pi[j-1];
+        	}
+        	
+        	if(target[i] == da[j]) {
+        		//찾았다면 종료
+        		if(j == n-1) {
+        			System.out.println("possible");
+        			return;
+        		}
+        		j++;
+        	}
+        }
+        
+        System.out.println("impossible");
+    }
+}
diff --git "a/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-1507] \352\266\201\352\270\210\355\225\234 \353\257\274\355\230\270.java" "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-1507] \352\266\201\352\270\210\355\225\234 \353\257\274\355\230\270.java"
new file mode 100644
index 00000000..5ed7476d
--- /dev/null
+++ "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-1507] \352\266\201\352\270\210\355\225\234 \353\257\274\355\230\270.java"	
@@ -0,0 +1,79 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        int n = Integer.parseInt(br.readLine());
+        //최소 거리 정보
+        int[][] map = new int[n][n];
+        //현재 도로 정보
+        int[][] graph = new int[n][n];
+        for(int i=0; i<n; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            for(int j=0; j<n; j++) {
+                map[i][j] = graph[i][j] = Integer.parseInt(st.nextToken());
+            }
+        }
+
+        //필수 도로의 시간의 합 = 결과 값
+        int result = 0;
+        //다익스트라를 위한 자료 구조
+        int[] dist = new int[n];
+        PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> Integer.compare(dist[o1], dist[o2]));
+        //모든 도로를 하나씩 제거해보며 해당 도로가 최소한 있어야 하는 필수 도로인지 판별
+        //i와 j를 잇는 도로를 제거했을 때 i -> j로 가는 최단 거리를 계산
+        for(int i=0; i<n; i++) {
+            for(int j=i+1; j<n; j++) {
+                //다익스트라를 위한 초기화
+                pq.clear();
+                Arrays.fill(dist, (int) 1e9);
+                //i에서 출발
+                dist[i] = 0;
+                boolean[] visited = new boolean[n];
+                pq.offer(i);
+
+                while(!pq.isEmpty()) {
+                    int current = pq.poll();
+
+                    if(visited[current]) continue;
+                    visited[current] = true;
+                    //j까지의 최단거리만 구하면 됨
+                    if(current == j) break;
+
+                    for(int node=0; node<n; node++) {
+                        if(visited[node]) continue;
+                        //i와 j를 잇는 도로는 없다는 가정
+                        if(current==i && node==j) continue;
+                        if(current==j && node==i) continue;
+
+                        if(dist[node] <= dist[current] + graph[current][node]) continue;
+                        dist[node] = dist[current] + graph[current][node];
+
+                        pq.offer(node);
+                    }
+                }
+
+                //i와 j를 잇는 도로를 제거했을 때 i -> j로 가는 최단 거리가 다음과 같을 때
+                //1. 제거 전보다 클 때 해당 도로는 필수 도로이다.
+                if(dist[j] > map[i][j]) {
+                    result += map[i][j];
+//        			System.out.println((i+1)+"->"+(j+1));
+                    continue;
+                }
+                //2. 제거 전보다 작다면 문제가 잘못됨.
+                if(dist[j] < map[i][j]) {
+                    System.out.println(-1);
+                    return;
+                }
+                //3. 제거 전과 같다면 해당 도로는 필수 도로가 아니므로 도로 정보를 INF 값으로 설정하여 없는 도로로 설정
+                graph[i][j] = (int) 1e9;
+                graph[j][i] = (int) 1e9;
+            }
+        }
+
+        System.out.println(result);
+    }
+}
diff --git "a/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-1561] \353\206\200\354\235\264 \352\263\265\354\233\220.java" "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-1561] \353\206\200\354\235\264 \352\263\265\354\233\220.java"
new file mode 100644
index 00000000..0ef23649
--- /dev/null
+++ "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-1561] \353\206\200\354\235\264 \352\263\265\354\233\220.java"	
@@ -0,0 +1,92 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    private static int n, m;
+    private static int[] cost;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        n = Integer.parseInt(st.nextToken());
+        m = Integer.parseInt(st.nextToken());
+
+        st = new StringTokenizer(br.readLine());
+
+        //cost[i]: i번 놀이기구 운행 시간
+        cost = new int[m+1];
+        long min = Integer.MAX_VALUE; //가장 작은 운행 시간
+        for(int i=1; i<=m; i++) {
+            cost[i] = Integer.parseInt(st.nextToken());
+            min = Math.min(min, cost[i]);
+        }
+
+        //놀이기구 개수보다 사람이 적다면 바로 반환
+        if(n <= m) {
+            System.out.println(n);
+            return;
+        }
+
+        //이분 탐색(모든 사람이 탈 수 있는 최소 시간)
+        long left = 0;
+        long right = n*min;//모두 운행시간이 가장 작은 놀이기구를 탔을 때의 시간
+        long minTime = right;//찾고자 하는 최소 시간
+
+        while(left <= right) {
+            long mid = left + (right-left)/2;
+
+            long count = counting(mid);
+            if(count >= n) {
+                minTime = Math.min(minTime, mid);
+                right = mid-1;
+                continue;
+            }
+            left = mid+1;
+        }
+
+        //모든 사람이 탈 수 있는 시간의 1분 전에 총 몇 명이 탑승할 수 있는지
+        long count = 0;
+        long time = minTime-1;
+        //wait[i]: 다음 사람이 i번 놀이기구를 타기 위해 기다려야 하는 대기 시간
+        long[] wait = new long[m+1];
+        for(int i=1; i<=m; i++) {
+            //사람 수 계산
+            if(time/cost[i] == 0) count += 1;
+            else if(time%cost[i] == 0) count += time/cost[i];
+            else count += time/cost[i]+1;
+            //대기 시간 계산
+            wait[i] = time%cost[i] == 0 ? 0 : cost[i] - time%cost[i];
+        }
+
+        //남은 사람 수
+        long rest = n-count;
+        //대기 시간이 가장 짧은 순으로 놀이기구 번호 정렬
+        PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> {
+            if(wait[o1] == wait[o2]) return Integer.compare(o1, o2);
+            return Long.compare(wait[o1], wait[o2]);
+        });
+        for(int i=1; i<=m; i++) {
+            pq.add(i);
+        }
+
+        //마지막 사람이 타는 놀이기구 번호
+        long result = 0;
+        for(int i=0; i<rest; i++) {
+            result = pq.poll();
+        }
+        System.out.println(result);
+    }
+
+    private static long counting(long time) {
+        //time 동안 탈 수 있는 총 사람 수 계산
+        long count = 0;
+        for(int i=1; i<=m; i++) {
+            if(time/cost[i] == 0) count += 1;
+            else if(time%cost[i] == 0) count += time/cost[i];
+            else count += time/cost[i]+1;
+        }
+
+        return count;
+    }
+}
diff --git "a/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-16940] BFS \354\212\244\355\216\230\354\205\234 \354\240\200\354\247\200.java" "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-16940] BFS \354\212\244\355\216\230\354\205\234 \354\240\200\354\247\200.java"
new file mode 100644
index 00000000..760f709c
--- /dev/null
+++ "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-16940] BFS \354\212\244\355\216\230\354\205\234 \354\240\200\354\247\200.java"	
@@ -0,0 +1,67 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        //초기화
+        int n = Integer.parseInt(br.readLine());
+
+        List<Set<Integer>> graph = new ArrayList<>();
+        for(int i=0; i<=n; i++) {
+            graph.add(new HashSet<>());
+        }
+        for(int i=0; i<n-1; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int a = Integer.parseInt(st.nextToken());
+            int b = Integer.parseInt(st.nextToken());
+            graph.get(a).add(b);
+            graph.get(b).add(a);
+        }
+
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int[] order = new int[n];
+        for(int i=0; i<n; i++) {
+            order[i] = Integer.parseInt(st.nextToken());
+        }
+
+        //result: 나올 수 있는 순서 집합
+        List<Set<Integer>> result = new ArrayList<>();
+        for(int i=0; i<=n; i++) {
+            result.add(new HashSet<>());
+        }
+        // 이 문제는 1부터 시작
+        result.get(0).add(1);
+        //result 채우기
+        boolean[] visited = new boolean[n+1];
+        visited[1] = true;
+        for(int i=0,idx=1; i<n; i++,idx++) {
+            Set<Integer> set = graph.get(order[i]);
+            for(int node : set) {
+                if(visited[node]) continue;
+                visited[node] = true;
+                result.get(idx).add(node);
+            }
+        }
+
+        //result(순서 집합)에 맞게 나오는지 체크
+        int idx = 0;
+        for(int i=0; i<n; i++) {
+            Set<Integer> set = result.get(i);
+            if(set.size() == 0) break;
+            for(int j=0; j<set.size(); j++) {
+                if(set.contains(order[idx])) {
+                    idx++;
+                    continue;
+                }
+                //만약 해당 순서에 나올 수 없는 숫자라면 0을 리턴
+                System.out.println(0);
+                return;
+            }
+        }
+        //전부 통과했다면 1을 리턴
+        System.out.println(1);
+    }
+}
diff --git "a/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-19236] \354\262\255\354\206\214\353\205\204 \354\203\201\354\226\264.java" "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-19236] \354\262\255\354\206\214\353\205\204 \354\203\201\354\226\264.java"
new file mode 100644
index 00000000..50bf0d71
--- /dev/null
+++ "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-19236] \354\262\255\354\206\214\353\205\204 \354\203\201\354\226\264.java"	
@@ -0,0 +1,150 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    private static int n = 4;
+    private static int[][] d = {{-1,0},{-1,-1},{0,-1},{1,-1},{1,0},{1,1},{0,1},{-1,1}};
+    private static Fish[][] map;
+    private static List<Fish> fishes;
+    private static int max;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        map = new Fish[n][n];
+        fishes = new ArrayList<>();
+        for(int i=0; i<n; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            for(int j=0; j<n; j++) {
+                int num = Integer.parseInt(st.nextToken());
+                int dir = Integer.parseInt(st.nextToken())-1;
+
+                Fish fish = new Fish(i, j, num, dir, true);
+                map[i][j] = fish;
+                fishes.add(fish);
+            }
+        }
+
+        max = map[0][0].num;
+
+        int[] shark = {0, 0, map[0][0].die()};
+        dfs(shark, map[0][0].num);
+
+        System.out.println(max);
+    }
+
+    private static void dfs(int[] shark, int current) {
+        // 물고기 상태 저장 (깊은 복사)
+        Fish[][] tempMap = new Fish[4][4];
+        List<Fish> tempFishes = new ArrayList<>();
+        for(int i=0; i<n; i++) {
+            for(int j=0; j<n; j++) {
+                Fish newFish = new Fish(i, j, map[i][j].num, map[i][j].dir, map[i][j].alive);
+                tempFishes.add(newFish);
+                tempMap[i][j] = newFish;
+            }
+        }
+
+        // 물고기 이동
+        Collections.sort(fishes);
+        for(Fish fish : fishes) {
+            if(!fish.isAlive()) continue;
+
+            for(int i=0; i<d.length; i++) {
+                int dir = (fish.dir+i)%8;
+                int nx = fish.x + d[dir][0];
+                int ny = fish.y + d[dir][1];
+
+                if(nx<0 || nx>=n || ny<0 || ny>=n) continue;
+                if(nx==shark[0] && ny==shark[1]) continue;
+
+                fish.dir = dir;
+                Fish temp = map[nx][ny];
+                map[nx][ny] = fish;
+                map[fish.x][fish.y] = temp;
+                temp.move(fish.x, fish.y);
+                fish.move(nx, ny);
+                break;
+            }
+        }
+
+        // 상어 먹방
+        boolean moved = false;
+        for(int idx=1; idx<=3; idx++) {
+            int nx = shark[0] + d[shark[2]][0] * idx;
+            int ny = shark[1] + d[shark[2]][1] * idx;
+            if(nx<0 || nx>=n || ny<0 || ny>=n) break;
+
+            if(!map[nx][ny].isAlive()) continue;
+
+            // 물고기를 잡아먹음
+            int fishDir = map[nx][ny].die();
+            moved = true;
+
+            // 다음 단계로 진행
+            dfs(new int[] {nx, ny, fishDir}, current + map[nx][ny].num);
+
+            // 물고기 부활
+            map[nx][ny].alive = true;
+        }
+
+        // 상어가 더 이상 이동할 곳이 없을 때
+        if(!moved) {
+            max = Math.max(max, current);
+        }
+
+        // 맵 상태 복원
+        map = tempMap;
+        fishes = tempFishes;
+    }
+
+    private static class Fish implements Comparable<Fish>{
+        int x, y;
+        int num;
+        int dir;
+        boolean alive;
+
+        public Fish(int x, int y, int num, int dir, boolean alive) {
+            this.x = x;
+            this.y = y;
+            this.num = num;
+            this.dir = dir;
+            this.alive = alive;
+        }
+
+        public int die() {
+            this.alive = false;
+            return this.dir;
+        }
+
+        public boolean isAlive() {
+            return this.alive;
+        }
+
+        public void move(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        public int compareTo(Fish o) {
+            return Integer.compare(this.num, o.num);
+        }
+
+        @Override
+        public String toString() {
+            String t = "";
+            switch(dir) {
+                case 0: t = "↑"; break;
+                case 1: t = "↖"; break;
+                case 2: t = "←"; break;
+                case 3: t = "↙"; break;
+                case 4: t = "↓"; break;
+                case 5: t = "↘"; break;
+                case 6: t = "→"; break;
+                case 7: t = "↗"; break;
+            }
+            return this.alive ? "["+this.num+","+t+"]" : "[ X ]";
+        }
+    }
+}
diff --git "a/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-23290] \353\247\210\353\262\225\354\202\254 \354\203\201\354\226\264\354\231\200 \353\263\265\354\240\234.java" "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-23290] \353\247\210\353\262\225\354\202\254 \354\203\201\354\226\264\354\231\200 \353\263\265\354\240\234.java"
new file mode 100644
index 00000000..db95252d
--- /dev/null
+++ "b/\354\234\240\353\263\221\352\267\234_13\354\243\274\354\260\250/[BOJ-23290] \353\247\210\353\262\225\354\202\254 \354\203\201\354\226\264\354\231\200 \353\263\265\354\240\234.java"	
@@ -0,0 +1,172 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+    private static int[][] fd = {{0,-1},{-1,-1},{-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1}};
+    private static int[][] sd = {{-1,0},{0,-1},{1,0},{0,1}};
+    private static int max;
+    private static int[][] map;
+    private static Node[] path;
+
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int n = 4;
+
+        map = new int[n][n];
+        int[][] smallMap = new int[n][n];
+
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int m = Integer.parseInt(st.nextToken());
+        int s = Integer.parseInt(st.nextToken());
+
+        Set<Fish> fishes = new HashSet<>();
+        for(int i=0; i<m; i++) {
+            st = new StringTokenizer(br.readLine());
+            int x = Integer.parseInt(st.nextToken())-1;
+            int y = Integer.parseInt(st.nextToken())-1;
+            int dir = Integer.parseInt(st.nextToken())-1;
+
+            fishes.add(new Fish(x, y, dir));
+            map[x][y]++;
+        }
+
+        st = new StringTokenizer(br.readLine());
+        int x = Integer.parseInt(st.nextToken())-1;
+        int y = Integer.parseInt(st.nextToken())-1;
+        int[] shark = {x, y};
+
+        //풀이 시작
+        int time = 0;
+        while(time < s) {
+            //물고기 냄새 시간 증가
+            for(int i=0; i<4; i++) {
+                for(int j=0; j<4; j++) {
+                    if(smallMap[i][j] > 0) smallMap[i][j]++;
+                }
+            }
+
+            //기존 물고기 저장
+            Queue<Fish> q = new LinkedList<>();
+
+            //물고기 이동
+            for(Fish fish : fishes) {
+                q.add(new Fish(fish.x, fish.y, fish.dir));
+
+                for(int i=0; i<fd.length; i++) {
+                    int idx = (fish.dir-i) < 0 ? fish.dir-i+8 : fish.dir-i;
+                    int nx = fish.x + fd[idx][0];
+                    int ny = fish.y + fd[idx][1];
+
+                    if(nx<0 || nx>=n || ny<0 || ny>=4 || smallMap[nx][ny] > 0) continue;
+                    if(nx==shark[0] && ny==shark[1]) continue;
+
+                    map[fish.x][fish.y]--;
+                    map[nx][ny]++;
+                    fish.x = nx;
+                    fish.y = ny;
+                    fish.dir = idx;
+                    break;
+                }
+
+            }
+
+            //상어 이동
+            max = -1;
+            path = new Node[3];
+            dfs(0, shark[0], shark[1], 0, new Node(shark[0], shark[1], null));
+            List<Fish> remove = new ArrayList<>();
+            for(int i=0; i<3; i++) {
+                Node node = path[i];
+                if(map[node.x][node.y] == 0) continue;
+                map[node.x][node.y] = 0;
+                for(Fish fish : fishes) {
+                    if(fish.x == node.x && fish.y == node.y) remove.add(fish);
+                }
+                smallMap[node.x][node.y] = 1;
+            }
+            fishes.removeAll(remove);
+            shark[0] = path[2].x;
+            shark[1] = path[2].y;
+
+            //물고기 냄새 제거
+            for(int i=0; i<n; i++) {
+                for(int j=0; j<n; j++) {
+                    if(smallMap[i][j] > 2) smallMap[i][j] = 0;
+                }
+            }
+
+            //물고기 복사
+            while(!q.isEmpty()) {
+                Fish fish = q.poll();
+                fishes.add(fish);
+                map[fish.x][fish.y]++;
+            }
+
+            time++;
+        }
+
+        int count = 0;
+        for(int i=0; i<n; i++) {
+            for(int j=0; j<n; j++) {
+                count += map[i][j];
+            }
+        }
+
+        System.out.println(count);
+    }
+
+    private static void dfs(int dept, int x, int y, int count, Node node) {
+        if(dept == 3) {
+            if(count <= max) return;
+            max = count;
+            Node current = node;
+            for(int i=2; i>=0; i--) {
+                path[i] = current;
+                current = current.pre;
+            }
+            return;
+        }
+
+        for(int i=0; i<sd.length; i++) {
+            int nx = x + sd[i][0];
+            int ny = y + sd[i][1];
+
+            if(nx<0 || nx>=4 || ny<0 || ny>=4) continue;
+            int nCount = count+map[nx][ny];
+            Node temp = node;
+            while(temp.pre != null) {
+                if(temp.x == nx && temp.y == ny) {
+                    nCount = count;
+                    break;
+                }
+                temp = temp.pre;
+            }
+            dfs(dept+1, nx, ny, nCount, new Node(nx, ny, node));
+        }
+    }
+
+    private static class Fish{
+        int x;
+        int y;
+        int dir;
+
+        public Fish(int x, int y, int dir) {
+            this.x = x;
+            this.y = y;
+            this.dir = dir;
+        }
+    }
+
+    private static class Node{
+        int x;
+        int y;
+        Node pre;
+
+        public Node(int x, int y, Node pre) {
+            this.x = x;
+            this.y = y;
+            this.pre = pre;
+        }
+    }
+}