diff --git a/Basic_Of_Algorithm/src/Today22_05_11/bfs.java b/Basic_Of_Algorithm/src/Today_22_05_11/bfs.java
similarity index 98%
rename from Basic_Of_Algorithm/src/Today22_05_11/bfs.java
rename to Basic_Of_Algorithm/src/Today_22_05_11/bfs.java
index 1d7af4b..117d37f 100644
--- a/Basic_Of_Algorithm/src/Today22_05_11/bfs.java
+++ b/Basic_Of_Algorithm/src/Today_22_05_11/bfs.java
@@ -1,4 +1,4 @@
-package Today22_05_11;
+package Today_22_05_11;
 
 import java.util.LinkedList;
 import java.util.Queue;
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/bfsAgain.java b/Basic_Of_Algorithm/src/Today_22_05_11/bfsAgain.java
similarity index 98%
rename from Basic_Of_Algorithm/src/Today22_05_11/bfsAgain.java
rename to Basic_Of_Algorithm/src/Today_22_05_11/bfsAgain.java
index 0a1800b..bca547d 100644
--- a/Basic_Of_Algorithm/src/Today22_05_11/bfsAgain.java
+++ b/Basic_Of_Algorithm/src/Today_22_05_11/bfsAgain.java
@@ -1,4 +1,4 @@
-package Today22_05_11;
+package Today_22_05_11;
 
 import java.util.LinkedList;
 import java.util.Queue;
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/combi_dfs.java b/Basic_Of_Algorithm/src/Today_22_05_11/combi_dfs.java
similarity index 97%
rename from Basic_Of_Algorithm/src/Today22_05_11/combi_dfs.java
rename to Basic_Of_Algorithm/src/Today_22_05_11/combi_dfs.java
index 693874f..4d9802b 100644
--- a/Basic_Of_Algorithm/src/Today22_05_11/combi_dfs.java
+++ b/Basic_Of_Algorithm/src/Today_22_05_11/combi_dfs.java
@@ -1,4 +1,4 @@
-package Today22_05_11;
+package Today_22_05_11;
 
 public class combi_dfs {
 
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/dfs.java b/Basic_Of_Algorithm/src/Today_22_05_11/dfs.java
similarity index 97%
rename from Basic_Of_Algorithm/src/Today22_05_11/dfs.java
rename to Basic_Of_Algorithm/src/Today_22_05_11/dfs.java
index 3190a0d..f468513 100644
--- a/Basic_Of_Algorithm/src/Today22_05_11/dfs.java
+++ b/Basic_Of_Algorithm/src/Today_22_05_11/dfs.java
@@ -1,4 +1,4 @@
-package Today22_05_11;
+package Today_22_05_11;
 
 public class dfs {
 	
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/test.java b/Basic_Of_Algorithm/src/Today_22_05_11/test.java
similarity index 98%
rename from Basic_Of_Algorithm/src/Today22_05_11/test.java
rename to Basic_Of_Algorithm/src/Today_22_05_11/test.java
index d86f3b7..82b89ad 100644
--- a/Basic_Of_Algorithm/src/Today22_05_11/test.java
+++ b/Basic_Of_Algorithm/src/Today_22_05_11/test.java
@@ -1,4 +1,4 @@
-package Today22_05_11;
+package Today_22_05_11;
 
 import java.util.*;
 
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/twoPointer.java b/Basic_Of_Algorithm/src/Today_22_05_11/twoPointer.java
similarity index 98%
rename from Basic_Of_Algorithm/src/Today22_05_11/twoPointer.java
rename to Basic_Of_Algorithm/src/Today_22_05_11/twoPointer.java
index 202e7d6..9fc63d5 100644
--- a/Basic_Of_Algorithm/src/Today22_05_11/twoPointer.java
+++ b/Basic_Of_Algorithm/src/Today_22_05_11/twoPointer.java
@@ -1,4 +1,4 @@
-package Today22_05_11;
+package Today_22_05_11;
 
 import java.util.Arrays;
 
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/twoPointerRangeSum.java b/Basic_Of_Algorithm/src/Today_22_05_11/twoPointerRangeSum.java
similarity index 96%
rename from Basic_Of_Algorithm/src/Today22_05_11/twoPointerRangeSum.java
rename to Basic_Of_Algorithm/src/Today_22_05_11/twoPointerRangeSum.java
index e515221..802aa0a 100644
--- a/Basic_Of_Algorithm/src/Today22_05_11/twoPointerRangeSum.java
+++ b/Basic_Of_Algorithm/src/Today_22_05_11/twoPointerRangeSum.java
@@ -1,4 +1,4 @@
-package Today22_05_11;
+package Today_22_05_11;
 
 import java.util.Arrays;
 
diff --git a/Basic_Of_Algorithm/src/Today_22_05_12/RankingSearch.java b/Basic_Of_Algorithm/src/Today_22_05_12/RankingSearch.java
new file mode 100644
index 0000000..df087e1
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_12/RankingSearch.java
@@ -0,0 +1,86 @@
+package Today_22_05_12;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class RankingSearch {
+
+	static HashMap<String,ArrayList<Integer>> map = new HashMap<>();
+	
+	
+	public static void main(String[] args) {
+		
+		
+		String [] info = {"java backend junior pizza 150","python frontend senior chicken 210","python frontend senior chicken 150","cpp backend senior pizza 260","java backend junior chicken 80","python backend senior chicken 50"};
+		
+		String [] query = {"java and backend and junior and pizza 100","python and frontend and senior and chicken 200","cpp and - and senior and pizza 250","- and backend and senior and - 150","- and - and - and chicken 100","- and - and - and - 150"};
+		
+		int[]result = new int[query.length];
+		
+		
+		for(int i=0;i<info.length;i++) {
+		
+			String[]temp = info[i].split(" ");
+			dfs(temp,0,"");
+			
+		}
+		for(String key : map.keySet()) {
+			Collections.sort(map.get(key));
+		}
+		
+		for(int i=0;i<query.length;i++) {
+			
+			query[i] = query[i].replaceAll(" and ", "");
+			
+			String [] temp = query[i].split(" ");
+			
+			result[i] = map.containsKey(temp[0]) ? binarySearch(temp[0],temp[1]) : 0;  
+		}
+		
+		for(int i : result)System.out.println(i);
+		
+	}
+	
+	static int binarySearch(String key,String value) {
+		
+		int score = Integer.parseInt(value);
+		
+		ArrayList<Integer> list = map.get(key);
+		
+		int start = 0;
+		
+		int end = list.size()-1;
+		
+		
+		while(start<=end) {
+			
+			int mid = (start+end)/2;
+			
+			if(score<=list.get(mid)) end = mid-1;
+			else if(score>list.get(mid)) start = mid+1;
+			
+			
+		}
+		
+		return list.size()-start;
+		
+		
+	}
+	
+	static void dfs(String[]temp,int count,String now) {
+		
+		
+		if(count==4) {
+			if(!map.containsKey(now)) {
+				map.put(now, new ArrayList<>());
+			}
+			map.get(now).add(Integer.parseInt(temp[4]));
+			return;
+		}
+		
+		dfs(temp,count+1,now+"-");
+		dfs(temp,count+1,now+temp[count]);
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_12/apchuck.java b/Basic_Of_Algorithm/src/Today_22_05_12/apchuck.java
new file mode 100644
index 0000000..7e9a852
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_12/apchuck.java
@@ -0,0 +1,57 @@
+package Today_22_05_12;
+
+public class apchuck {
+
+	public static void main(String[] args) {
+		
+		String s = "ababcdcdababcdcd";
+		
+		
+		int answer = Integer.MAX_VALUE;
+		
+		
+		for(int i=1;i<=s.length()/2;i++) {
+			
+			
+			String result = "";
+			String now = ""; String next = "";
+			int count = 1;
+			
+			for(int j=0;j<=s.length()/i;j++) {
+				
+				
+				int start = j*i;
+				
+				int end = s.length() > i * (j+1) ? i * (j+1) : s.length();
+				
+				now = next;
+				
+				next = s.substring(start,end);
+				
+				if(now.equals(next)) {
+					count++;
+				}else {
+					result += check(count) + now;	
+					count = 1;
+				}
+				
+				
+				
+			}
+			
+			result += check(count) + next;
+			
+			System.out.println(result + " -> 갯수 : "+ result.length());
+			
+			answer = Math.min(answer, result.length());
+			
+		}
+		System.out.println();
+		System.out.println("답 : " + answer);
+		
+	}
+	
+	static String check(int count) {
+		return count > 1 ? String.valueOf(count) : ""; 
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_12/changebracket.java b/Basic_Of_Algorithm/src/Today_22_05_12/changebracket.java
new file mode 100644
index 0000000..ba24c08
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_12/changebracket.java
@@ -0,0 +1,68 @@
+package Today_22_05_12;
+
+public class changebracket {
+
+	
+	public static void main(String[] args) {
+		
+		String p = ")(";
+		
+		if(p.isEmpty())System.out.println("nope");
+		else {
+			
+			String answer = change(p);
+			System.out.println(answer);
+		}
+	
+		
+		
+	}
+	
+	static String change(String w) {
+		
+		if(w.isEmpty()) return "";
+		
+		String u = "";
+		String v = "";
+		
+		int l = 0;
+		int r = 0;
+		int i;
+		
+		for(i=0;i<w.length();i++) {
+			
+			char ch = w.charAt(i);
+			
+			if(ch=='(')l++;
+			else r++;
+			
+			
+			if(l==r) break;
+			
+		}
+		
+		u = w.substring(0,i+1);
+		v = w.substring(i+1);
+		
+		if(isRight(u)) {
+			u += change(v);
+		}else {
+			String str = "(" + change(v) + ")";
+			u = u.substring(1,u.length()-1);
+			u = u.replaceAll("\\(", ".");
+			u = u.replaceAll("\\)", "(");
+			u = u.replaceAll("\\.", ")");
+			str += u;
+			return str;
+		}
+		return u;
+		
+	}
+	static boolean isRight(String u) {
+		
+		if(u.charAt(0)==')') return false;
+		u = u.replaceAll("\\(\\)", "");
+		
+		return true;
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_12/fef.java b/Basic_Of_Algorithm/src/Today_22_05_12/fef.java
new file mode 100644
index 0000000..84cd39f
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_12/fef.java
@@ -0,0 +1,51 @@
+package Today_22_05_12;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Stack;
+
+public class fef {
+
+	public static void main(String[] args) {
+		
+		
+		int[][] rooms = {{1,4},{3,5},{0,6},{5,7},{3,8},
+				{5,9},{6,10},{8,11},{8,12},{2,13},
+				{12,14},{11,14}};
+	
+	int answer = 0;
+	
+	Arrays.sort(rooms,new Comparator<int[]>() {
+
+		@Override
+		public int compare(int[] o1, int[] o2) {
+			
+			if(o1[1]==o2[1]) {
+				return o1[0] - o2[0];
+			}
+			return o1[1]-o2[1];
+		}
+		
+	});
+	
+	for(int i=0;i<rooms.length;i++) {
+		System.out.println(rooms[i][0]+" : " + rooms[i][1]);
+	}
+	
+	int end_time = 0;
+	int count = 0;
+	
+	for(int i=0;i<rooms.length;i++) {
+		
+		if(rooms[i][0]>=end_time) {
+			end_time = rooms[i][1];
+			count++;
+		}
+		
+		
+	}
+	
+	System.out.println("답 : " + count);
+	
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_12/gameMap.java b/Basic_Of_Algorithm/src/Today_22_05_12/gameMap.java
new file mode 100644
index 0000000..97469a7
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_12/gameMap.java
@@ -0,0 +1,52 @@
+package Today_22_05_12;
+
+import java.util.*;
+
+public class gameMap {
+
+	public static void main(String[] args) {
+		
+		int[][]maps = {{1,0,1,1,1},{1,0,1,0,1},{1,0,1,1,1},{1,1,1,0,1},{0,0,0,0,1}};
+		
+		int answer = 0;
+		
+		Queue<int[]> q = new LinkedList<>();
+		
+		
+		int[][]temp = new int[maps.length][maps[0].length];
+		
+		int [][] move = {{0,1},{1,0},{0,-1},{-1,0}};
+		
+		
+		temp[0][0] = 1;
+		
+		q.add(new int[] {0,0});
+		
+		while(!q.isEmpty()) {
+			
+			int[]cur = q.poll();
+			
+			int i = cur[0];
+			int j = cur[1];
+			
+			for(int d=0;d<4;d++) {
+				
+				int ni = i + move[d][0]; 
+				int nj = j + move[d][1];
+				
+				if(ni<0||nj<0||maps.length-1<ni||maps[0].length-1<nj) continue;
+				
+				if(maps[ni][nj]==1&&temp[ni][nj]==0) {
+					temp[ni][nj] = temp[i][j] + 1;
+					q.add(new int[] {ni,nj});
+				}
+				
+			}
+			
+		}
+		
+		System.out.println(temp[maps.length-1][maps[0].length-1]);
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_12/hide.java b/Basic_Of_Algorithm/src/Today_22_05_12/hide.java
new file mode 100644
index 0000000..02f5737
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_12/hide.java
@@ -0,0 +1,57 @@
+package Today_22_05_12;
+
+import java.util.*;
+
+public class hide {
+	
+	public static void main(String[] args) {
+		
+		
+		int sb = 5;
+		int bro = 17;
+		
+		
+		
+		Queue<Integer> q = new LinkedList<>();
+		
+		int[] position = new int[100001];
+		
+		
+		position[sb] = 0;
+		
+		q.add(sb);
+		
+		while(!q.isEmpty()) {
+			
+			
+			int p = q.poll();
+			
+			if(position[bro]!=0) break;
+			
+			if(position[p-1] ==0 && p-1>=0) {
+				position[p-1] = position[p] + 1;
+				q.add(p-1);
+			}
+			
+			if(position[p+1] ==0 && p+1<=position.length) {
+				position[p+1] = position[p] + 1;
+				q.add(p+1);
+				
+			}	
+			if(position[p*2] ==0 && p*2<=position.length) {
+				position[p*2] = position[p] + 1;
+				q.add(p*2);
+				
+			}	
+			
+			
+		}
+		
+		if(sb==bro) position[bro] = 0;
+		System.out.println(position[bro] + " 초");
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_12/hideAndFind.java b/Basic_Of_Algorithm/src/Today_22_05_12/hideAndFind.java
new file mode 100644
index 0000000..a8bbb4e
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_12/hideAndFind.java
@@ -0,0 +1,66 @@
+package Today_22_05_12;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class hideAndFind {
+
+	public static void main(String[] args) {
+	
+		int[][]jobs = {{0, 3}, {1, 9}, {2, 6}};
+		
+		int answer = 0;
+		
+		Arrays.sort(jobs, new Comparator<int[]>() {
+
+			@Override
+			public int compare(int[] o1, int[] o2) {
+				if(o1[0]==o2[0]) {
+					return o1[1] - o2[1];
+				}
+				return o1[0] - o2[0];
+			}
+		
+		});
+		
+		
+		for(int i=0;i<jobs.length;i++) {
+			System.out.println(jobs[i][0]+" : "+jobs[i][1]);
+		}
+		
+		PriorityQueue<int[]> q = new PriorityQueue<int[]>(new Comparator<int[]>() {
+
+			@Override
+			public int compare(int[] o1, int[] o2) {
+				// TODO Auto-generated method stub
+				return o1[1]-o2[1];
+			}
+		
+		});
+		
+		q.offer(jobs[0]);
+		int end = jobs[0][0];
+		int sum = 0;
+		int idx = 1;
+		
+		while(!q.isEmpty()) {
+			int [] cur = q.poll();
+			end += cur[1];
+			sum += end - cur[0];
+			System.out.println(sum);
+			
+			while(idx < jobs.length && jobs[idx][0] <= end) {
+				q.offer(jobs[idx++]);
+			}
+			
+			if(idx < jobs.length && q.isEmpty()) {
+				end = jobs[idx][0];
+				q.offer(jobs[idx++]);
+			}
+		}
+		
+		
+		System.out.println(sum/jobs.length);
+	}
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/Today_22_05_12/rightbiggersoo.java b/Basic_Of_Algorithm/src/Today_22_05_12/rightbiggersoo.java
new file mode 100644
index 0000000..924108d
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_12/rightbiggersoo.java
@@ -0,0 +1,37 @@
+package Today_22_05_12;
+
+import java.util.*;
+
+public class rightbiggersoo {
+	
+	public static void main(String[] args) {
+		
+		int []A = {3,5,2,7};
+		int[]answer = new int[A.length];
+		
+		Stack<Integer> ans = new Stack<>();
+		Stack<Integer> tmp = new Stack<>();
+		
+		for(int i = A.length-1; i > -1 ; i--) {
+			
+			int num = A[i];
+			
+			while(!tmp.isEmpty() && (num >= tmp.peek())) {
+				tmp.pop();
+			}
+			
+			if(tmp.isEmpty()) {
+				ans.add(-1);
+			}else {
+				ans.add(tmp.peek());
+			}
+			
+			tmp.add(num);
+			
+		}
+		
+		for(int i = 0 ; i < answer.length;i++) System.out.println(ans.pop());
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_12/rooms.java b/Basic_Of_Algorithm/src/Today_22_05_12/rooms.java
new file mode 100644
index 0000000..3801026
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_12/rooms.java
@@ -0,0 +1,46 @@
+package Today_22_05_12;
+
+import java.util.*;
+
+public class rooms {
+
+	static int answer = Integer.MAX_VALUE;
+	
+	public static void main(String[] args) {
+		
+		int[][] rooms = {{1,4},{3,5},{0,6},{5,7},{3,8},
+						{5,9},{6,10},{8,11},{8,12},{2,13},
+						{12,14}};
+		
+		
+		
+		Arrays.sort(rooms, new Comparator<int[]>() {
+			public int compare(int[]o1,int[]o2) {
+				
+				if(o1[1]==o2[1]) {
+					
+					return o1[0] - o2[0];
+				}
+				return o1[1]-o2[1];
+				
+			}
+		});
+		
+		for(int i=0;i<rooms.length;i++) {
+			System.out.print(rooms[i][0]+",");
+			System.out.println(rooms[i][1]);
+		}
+		int count = 0;
+		int end_time = 0;
+		
+		for(int i=0;i<rooms.length;i++) {
+			if(rooms[i][0]>=end_time) {
+				end_time = rooms[i][1];
+				count++;
+				}
+			}
+		
+		System.out.println(count);
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_13/dictionary.java b/Basic_Of_Algorithm/src/Today_22_05_13/dictionary.java
new file mode 100644
index 0000000..5d3c17a
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_13/dictionary.java
@@ -0,0 +1,53 @@
+package Today_22_05_13;
+
+import java.util.ArrayList;
+
+public class dictionary {
+	
+	public static void main(String[] args) {
+		
+		String msg = "KAKAO";
+		
+		ArrayList<String> dic = new ArrayList<>();
+		ArrayList<Integer> ans = new ArrayList<>();
+		
+		String alp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+		
+		dic.add("&&");
+		
+		for(int i=0;i<alp.length();i++) dic.add(""+alp.charAt(i));
+		
+		String now = "";
+		
+		int idx = 0;
+		
+		while(idx<=msg.length()) {
+			
+			if(idx==msg.length()) {
+				ans.add(dic.indexOf(now));
+				break;
+			}
+			
+			String next = ""+msg.charAt(idx);
+			String newOne =now+next;
+			
+			if(dic.contains(newOne)) {
+				now = newOne;
+				idx++;
+				continue;
+			}
+			
+			dic.add(newOne);
+			ans.add(dic.indexOf(now));
+			idx++;
+			now = next;
+			
+		}
+		
+			
+		
+		
+		System.out.println(ans);
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_13/hideAndFind.java b/Basic_Of_Algorithm/src/Today_22_05_13/hideAndFind.java
new file mode 100644
index 0000000..84e7aea
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_13/hideAndFind.java
@@ -0,0 +1,48 @@
+package Today_22_05_13;
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class hideAndFind {
+	
+	public static void main(String[] args) {
+		
+		int hider = 17;
+		int finder = 5;
+		
+		
+		Queue<Integer> q = new LinkedList<>();
+		
+		int[]check = new int[100001];
+		
+		check[finder] = 0;
+		
+		q.add(finder);
+		
+		while(!q.isEmpty()) {
+			
+			int pos = q.poll();
+			
+			if(check[hider]!=0 || pos>100000) break;
+			
+			if(pos-1 >= 0 && check[pos-1] ==0 ) {
+				check[pos-1] = check[pos] + 1;
+				q.add(pos-1);
+			}
+			if(pos+1 < check.length && check[pos-1] ==0 ) {
+				check[pos+1] = check[pos] + 1;
+				q.add(pos+1);
+			}
+			if(pos*2 >= 0 && check[pos*2] ==0 ) {
+				check[pos*2] = check[pos] + 1;
+				q.add(pos*2);
+			}
+			
+		}
+		
+		
+		System.out.println(check[hider]);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_13/practice.java b/Basic_Of_Algorithm/src/Today_22_05_13/practice.java
new file mode 100644
index 0000000..e2bcd16
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_13/practice.java
@@ -0,0 +1,47 @@
+package Today_22_05_13;
+
+import java.util.Comparator;
+import java.util.Arrays;
+
+public class practice {
+	
+	public static void main(String[] args) {
+		
+		int[][] rooms = {{1,4},{3,5},{0,6},{5,7},{3,8},
+				{5,9},{6,10},{8,11},{8,12},{2,13},
+				{12,14}};
+		
+		
+		Arrays.sort(rooms,new Comparator<int[]>() {
+
+			@Override
+			public int compare(int[] o1, int[] o2) {
+				// TODO Auto-generated method stub
+				if(o1[1]==o2[1]) {
+					return o1[0]-o2[0];
+				}
+				return o1[1]-o2[1];
+			}
+			
+		});
+		
+		
+		
+		int end_time = 0;
+		int count = 0;
+		
+		
+		for(int i=0;i<rooms.length;i++) {
+			
+			if(rooms[i][0]>=end_time) {
+				end_time = rooms[i][1];
+				count++;
+			}
+			
+		}
+		
+		
+		System.out.println(count);
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_13/right.java b/Basic_Of_Algorithm/src/Today_22_05_13/right.java
new file mode 100644
index 0000000..b826d66
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_13/right.java
@@ -0,0 +1,41 @@
+package Today_22_05_13;
+
+import java.util.Stack;
+
+public class right {
+
+	public static void main(String[] args) {
+		
+		int [] arr = {3,5,1,7};
+		
+		Stack<Integer> temp = new Stack<>();
+		Stack<Integer> ans = new Stack<>();
+		
+		
+		
+		for(int i=arr.length-1;i>-1;i--) {
+			
+			int num = arr[i];
+			
+			while(!temp.isEmpty() && num>=temp.peek()) {
+				temp.pop();
+			}
+			
+			if(temp.isEmpty()) {
+				ans.add(-1);
+			}else {
+				ans.add(temp.peek());
+			}
+			temp.add(num);
+			
+		}
+		
+		int []result = new int[arr.length];
+		
+		for(int i=0;i<result.length;i++) result[i] = ans.pop();
+		
+		
+		for(int i : result)System.out.print(i+" ");
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_13/soosick.java b/Basic_Of_Algorithm/src/Today_22_05_13/soosick.java
new file mode 100644
index 0000000..c56e0d2
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_13/soosick.java
@@ -0,0 +1,100 @@
+package Today_22_05_13;
+
+import java.util.ArrayList;
+
+public class soosick {
+	
+	static boolean [] visited = new boolean[3];
+	static char[] sick = {'+','-','*'};
+	static long answer = 0;
+	static ArrayList<Character> opArr = new ArrayList<>();
+	static ArrayList<Long> numArr = new ArrayList<>();
+	
+	
+	public static void main(String[] args) {
+		
+		String expression = "100-200*300-500+20";
+		
+		input(expression);
+		
+		dfs(new char[3],0);
+		
+		System.out.println(answer);
+		
+		
+		
+	}
+	
+	static Long change(char ch,long a, long b) {
+		if(ch=='+') return a+b;
+		else if(ch=='-') return a-b;
+		else if(ch=='*') return a*b;
+		else return (long) 0;
+		
+	}
+	
+
+	static void dfs(char[]p,int count) {
+		
+		if(count==3) {
+
+			ArrayList<Long>numList =new ArrayList<>(numArr);
+			ArrayList<Character>opList =new ArrayList<>(opArr);
+			
+			for(int i=0;i<p.length;i++) {
+				for(int j=0;j<opList.size();j++) {
+					if(p[i]==opList.get(j)) {
+						long a = change(opList.get(j),numList.remove(j),numList.remove(j));
+						opList.remove(j);
+						numList.add(j,a);
+						j--;
+					}
+				}
+			}
+
+				answer = Math.max(answer, Math.abs(numList.get(0)));
+				
+				return;
+			
+		}
+		
+			
+		for(int i=0;i<sick.length;i++) {
+			if(!visited[i]) {
+				visited[i] = true;
+				p[count] = sick[i];
+				dfs(p,count+1);
+				visited[i] = false;
+			}
+			
+		}
+		
+		
+	}
+	
+	static void input(String expression) {
+		
+		String num="";
+		
+		for(int i=0;i<expression.length();i++) {
+			
+			char ch = expression.charAt(i);
+			
+			if(ch>='0'&& ch<='9') num += ch;
+			else {
+				numArr.add(Long.parseLong(num));
+				opArr.add(ch);
+				num="";
+			}
+			
+			
+			
+		}
+		
+		numArr.add(Long.parseLong(num));
+		
+		
+	}
+	
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_13/testCode.java b/Basic_Of_Algorithm/src/Today_22_05_13/testCode.java
new file mode 100644
index 0000000..698046c
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_13/testCode.java
@@ -0,0 +1,25 @@
+package Today_22_05_13;
+
+import java.util.Stack;
+
+public class testCode {
+	
+	public static void main(String[] args) {
+		
+		int n = 43674;
+		int k = 3;
+		int answer = 0;
+		
+		String num = "";
+		
+		while(n>0) {
+			
+			num = n%k + num;
+			n /= k;
+			
+		}
+		
+		System.out.println(num);
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_15/bfs.java b/Basic_Of_Algorithm/src/Today_22_05_15/bfs.java
new file mode 100644
index 0000000..949ae98
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_15/bfs.java
@@ -0,0 +1,57 @@
+package Today_22_05_15;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class bfs {
+	
+	public static void main(String[] args) {
+		
+		int sb = 5;
+		int bro = 17;
+		
+		
+		
+		Queue<Integer> q = new LinkedList<>();
+		
+		int[] position = new int[100001];
+		
+		
+		position[sb] = 0;
+		
+		q.add(sb);
+		
+		while(!q.isEmpty()) {
+			
+			
+			int p = q.poll();
+			
+			if(position[bro]!=0) break;
+			
+			if(position[p-1] ==0 && p-1>=0) {
+				position[p-1] = position[p] + 1;
+				q.add(p-1);
+			}
+			
+			if(position[p+1] ==0 && p+1<=position.length) {
+				position[p+1] = position[p] + 1;
+				q.add(p+1);
+				
+			}	
+			if(position[p*2] ==0 && p*2<=position.length) {
+				position[p*2] = position[p] + 1;
+				q.add(p*2);
+				
+			}	
+			
+			
+		}
+		
+		if(sb==bro) position[bro] = 0;
+		System.out.println(position[bro] + " 초");
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_16/test.java b/Basic_Of_Algorithm/src/Today_22_05_16/test.java
new file mode 100644
index 0000000..f01b73d
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_16/test.java
@@ -0,0 +1,51 @@
+package Today_22_05_16;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class test {
+
+	public static void main(String[] args) {
+		
+		int a = 5;
+		int b = 17;
+		
+		int[]visited = new int[10001];
+		
+		
+		Queue<Integer> q = new LinkedList<>();
+		
+		visited[a] = 0;
+		
+		q.add(a);
+		
+		while(!q.isEmpty()) {
+			
+			int now = q.poll();
+			
+			if(visited[b]!=0 || now >=10000) break;
+			
+			if(now-1>=0 && visited[now-1] ==0) {
+				visited[now-1] = visited[now] + 1;
+				q.add(now-1);
+			}
+			
+			if(now+1<=10000 && visited[now+1] ==0) {
+				visited[now+1] = visited[now] + 1;
+				q.add(now+1);
+			}
+			
+			if(now*2<=10000 && visited[now*2] ==0) {
+				visited[now*2] = visited[now] + 1;
+				q.add(now*2);
+			}
+			
+		}
+		
+		
+		
+		System.out.println(visited[b]);
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_16/test2.java b/Basic_Of_Algorithm/src/Today_22_05_16/test2.java
new file mode 100644
index 0000000..6b7cce6
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_16/test2.java
@@ -0,0 +1,56 @@
+package Today_22_05_16;
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class test2 {
+
+	public static void main(String[] args) {
+		
+		
+		int [][] map = {{1,0,1,1,1},{1,0,1,0,1},{1,0,1,1,1},{1,1,1,0,1},{0,0,0,0,1}};
+		
+		
+		Queue<int [] > q = new LinkedList<>();
+		
+		int [][] temp = new int[map.length][map[0].length];
+		
+		temp[0][0] = 1;
+		
+		q.add(new int[] {0,0});
+		
+		int [][] move = {{0,1},{1,0},{0,-1},{-1,0}};
+		
+		while(!q.isEmpty()) {
+			
+			int []c = q.poll();
+			
+			int ci = c[0];
+			int cj = c[1];
+			
+			for(int d=0;d<4;d++) {
+				
+				int ni = ci + move[d][0];
+				int nj = cj + move[d][1];
+				
+				if(ni<0||nj<0||map.length-1<ni||map[0].length-1<nj) continue;
+				
+				if(map[ni][nj]==1 && temp[ni][nj] == 0) {
+					temp[ni][nj] = temp[ci][cj] + 1;
+					q.add(new int[] {ni,nj});				}
+				
+				
+			}
+			
+			
+			
+		}
+		
+		
+		int answer = temp[map.length-1][map[0].length-1];
+		
+		System.out.println(answer);
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_19/menuRenew.java b/Basic_Of_Algorithm/src/Today_22_05_19/menuRenew.java
new file mode 100644
index 0000000..20d1cf6
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_19/menuRenew.java
@@ -0,0 +1,75 @@
+package Today_22_05_19;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+public class menuRenew {
+	
+	static HashMap<String,Integer> map = new HashMap<>();
+	static ArrayList<String> answerList = new ArrayList<>();
+	
+	public static void main(String[] args) {
+		
+		String [] orders = {"ABCFG", "AC", "CDE", "ACDE", "BCFG", "ACDEH"};
+		int [] course = {2,3,4};
+		
+		for(int i=0;i<orders.length;i++) {
+			char[]temp = orders[i].toCharArray();
+			Arrays.sort(temp);
+			orders[i] = String.valueOf(temp);
+		}
+		
+		
+		for(int count : course) {
+			for(String order : orders) {
+				
+				dfs(count,order,"");
+			}
+			
+			
+			if(!map.isEmpty()) {
+				ArrayList<Integer> maxValue = new ArrayList<>(map.values());
+				int max = Collections.max(maxValue);
+				if(max>1) {
+					for(String key : map.keySet()) {
+						if(map.get(key)==max) {
+							answerList.add(key);
+						}
+					}
+				}
+			}
+			
+			
+			map.clear();
+		}
+		
+		Collections.sort(answerList);
+		
+		String[]answer = new String[answerList.size()];
+		
+		for(int i=0;i<answer.length;i++) answer[i] = answerList.get(i);
+		
+		for(String str : answer)System.out.print('"'+str+'"'+",");
+		
+		
+	}
+	
+	
+	static void dfs(int count,String order,String now) {
+		
+		if(count==0) {
+			map.put(now, map.getOrDefault(now, 0)+1);
+			return;
+		}
+		
+		for(int i=0;i<order.length();i++) {
+			
+			dfs(count-1,order.substring(i+1),now+order.charAt(i));
+		}
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_19/rankingSearching.java b/Basic_Of_Algorithm/src/Today_22_05_19/rankingSearching.java
new file mode 100644
index 0000000..f1bc15c
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_19/rankingSearching.java
@@ -0,0 +1,82 @@
+package Today_22_05_19;
+
+import java.util.*;
+
+public class rankingSearching {
+
+	static HashMap<String,ArrayList<Integer>> map = new HashMap<>();
+	
+	
+	public static void main(String[] args) {
+		
+		String [] info = {"java backend junior pizza 150","python frontend senior chicken 210","python frontend senior chicken 150","cpp backend senior pizza 260","java backend junior chicken 80","python backend senior chicken 50"};
+		String [] query = {"java and backend and junior and pizza 100","python and frontend and senior and chicken 200","cpp and - and senior and pizza 250","- and backend and senior and - 150","- and - and - and chicken 100","- and - and - and - 150"};
+		int [] answer = new int[query.length];
+		
+		for(String str : info) {
+			String []temp = str.split(" ");
+			dfs(temp,"",0);	
+		}
+		
+		for(String key:map.keySet()) {
+			Collections.sort(map.get(key));
+		}
+		
+		for(int i =0;i<query.length;i++) {
+			
+			query[i] = query[i].replaceAll(" and ", "");
+			String[]temp = query[i].split(" ");
+			answer[i] = map.containsKey(temp[0]) ? binarySearch(temp[0],temp[1]) : 0;
+			
+		}
+		
+		
+		for(int i : answer)System.out.println(i);
+		
+		
+	
+	}
+	
+	static int binarySearch(String now,String infoScore) {
+		
+		ArrayList<Integer> list = map.get(now);
+		
+		int score = Integer.parseInt(infoScore);
+		
+		int start = 0, end = list.size()-1;
+		
+		while(start<=end) {
+			
+			int mid = (start+end)/2;
+			
+			if(list.get(mid)<score) start = mid+1;
+			else end = mid-1;
+			
+			
+		}
+		
+		return list.size()-start;
+		
+		
+		
+	}
+	
+	static void dfs(String[]temp,String now,int count) {
+		
+		if(count==4) {
+			if(!map.containsKey(now)) {
+				map.put(now, new ArrayList<Integer>());
+			}
+			map.get(now).add(Integer.parseInt(temp[4]));
+			return;
+		}
+		
+		dfs(temp,now+"-",count+1);
+		dfs(temp,now+temp[count],count+1);
+	
+		
+		
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_19/soosick.java b/Basic_Of_Algorithm/src/Today_22_05_19/soosick.java
new file mode 100644
index 0000000..db211b1
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_19/soosick.java
@@ -0,0 +1,85 @@
+package Today_22_05_19;
+
+import java.util.*;
+
+public class soosick {
+
+	static long answer = 0;
+	static ArrayList<Long> numList = new ArrayList<>();
+	static ArrayList<Character> opList = new ArrayList<>();
+	static char [] op = {'+','-','*'};
+	static boolean []visited = new boolean[3];
+	
+	public static void main(String[] args) {
+		
+		String expression = "100-200*300-500+20";
+		
+		String num = "";
+		for(int i=0;i<expression.length();i++) {
+			
+			char ch = expression.charAt(i);
+			
+			if(ch>='0' && ch <= '9') {
+				num += ch;
+			}else {
+				numList.add(Long.parseLong(num));
+				num="";
+				opList.add(ch);
+			}
+		}
+		
+		numList.add(Long.parseLong(num));
+		
+		dfs(new char[3],0);
+		
+		System.out.println(answer);
+	}
+	
+	static Long change(char ch , long a, long b) {
+		if(ch=='+') return a + b;
+		else if(ch=='*') return a * b;
+		else if(ch=='-') return a - b;
+		else return (long)0;
+	}
+	
+	static void dfs(char[]p,int count) {
+		
+		if(count==3) {
+			 ArrayList<Long> numArr = new ArrayList<>(numList);
+			 ArrayList<Character> opArr = new ArrayList<>(opList);
+			
+			 for(int i=0;i<p.length;i++) {
+				 for(int j=0;j<opArr.size();j++) {
+					 if(opArr.get(j)==p[i]) {
+						 long a = change(opArr.remove(j),numArr.remove(j),numArr.remove(j));
+						 numArr.add(j,a);
+						 j--;
+					 
+					 }
+				 }
+			 }
+			 
+			 answer = Math.max(answer, Math.abs(numArr.get(0)));
+			 
+			 return;
+			 
+			 
+		}
+		
+		
+		
+		
+		for(int i=0;i<3;i++) {
+			if(!visited[i]) {
+				visited[i] = true;
+				p[count] = op[i];
+				dfs(p,count+1);
+				visited[i] = false;
+			}
+			
+		}
+		
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_19/test.java b/Basic_Of_Algorithm/src/Today_22_05_19/test.java
new file mode 100644
index 0000000..dc91767
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_19/test.java
@@ -0,0 +1,9 @@
+package Today_22_05_19;
+
+public class test {
+
+	public static void main(String[] args) {
+		
+		System.out.println("Merge Test");
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_20/bfs.java b/Basic_Of_Algorithm/src/Today_22_05_20/bfs.java
new file mode 100644
index 0000000..2868715
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_20/bfs.java
@@ -0,0 +1,52 @@
+package Today_22_05_20;
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class bfs {
+	
+	public static void main(String[] args) {
+		
+		int[][] maps = {{1,0,1,1,1},{1,0,1,0,1},{1,0,1,1,1},{1,1,1,0,1},{0,0,0,0,1}};
+		int answer = 0;
+		
+		Queue<int[]> q = new LinkedList<>();
+		
+		int[][]temp = new int[maps.length][maps[0].length];
+		
+		temp[0][0] = 1;
+		
+		q.add(new int[] {0,0});
+		
+		int[][]move = {{0,1},{1,0},{0,-1},{-1,0}};
+		
+		while(!q.isEmpty()) {
+			
+			int [] cur = q.poll();
+			
+			int ni = cur[0];
+			int nj = cur[1];
+			
+			for(int d=0;d<4;d++) {
+				
+				int newI = ni + move[d][0];
+				int newJ = nj + move[d][1];
+	
+				if(newI<0||newJ<0||maps.length-1<newI||maps[0].length-1<newJ) continue;
+				
+				if(maps[newI][newJ]==1 && temp[newI][newJ]==0) {
+					temp[newI][newJ] = temp[ni][nj]+1;
+					q.add(new int[] {newI,newJ});
+				}
+				
+			}
+			
+			
+		}
+		
+		answer = temp[maps.length-1][maps[0].length-1];
+		
+		System.out.println(answer);
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_20/dungeons.java b/Basic_Of_Algorithm/src/Today_22_05_20/dungeons.java
new file mode 100644
index 0000000..5f88439
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_20/dungeons.java
@@ -0,0 +1,36 @@
+package Today_22_05_20;
+
+public class dungeons {
+
+	static int answer = 0;
+	
+	public static void main(String[] args) {
+		
+	int k = 80;
+	int[][]dungeons = {{80,20},{50,40},{30,10}};
+	
+	boolean[]visited = new boolean[dungeons.length];
+	
+	dfs(dungeons,visited,k,0);
+	
+	System.out.println(answer);
+	}
+	static void dfs(int[][]dungeons,boolean[]visited,int k,int count) {
+		
+		for(int i=0;i<dungeons.length;i++) {
+			if(!visited[i]&&dungeons[i][0]<=k) {
+				visited[i] = true;
+				int newK = k - dungeons[i][1];
+				dfs(dungeons,visited,newK,count+1);
+				visited[i] = false;
+			}
+			
+		}
+		
+		
+		answer = Math.max(answer, count);
+		
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_20/greddy_changeMoney.java b/Basic_Of_Algorithm/src/Today_22_05_20/greddy_changeMoney.java
new file mode 100644
index 0000000..4462f15
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_20/greddy_changeMoney.java
@@ -0,0 +1,37 @@
+package Today_22_05_20;
+
+import java.util.Scanner;
+
+public class greddy_changeMoney {
+	
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		int cash = scan.nextInt();
+		
+		//500 100 50 10 5 1
+		
+		int[]arr = {500,100,50,10,5,1};
+		
+		cash = 1000-cash;
+		
+		int answer = 0;
+		
+		for(int i=0;i<arr.length;i++) {
+			
+			if(cash>=arr[i]) {
+			
+				answer += cash/arr[i];
+				cash = cash%arr[i];
+			}
+			if(cash==0)break;
+		}
+		
+		
+		System.out.println(answer);
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_20/greedy_atm.java b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_atm.java
new file mode 100644
index 0000000..50be8e6
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_atm.java
@@ -0,0 +1,33 @@
+package Today_22_05_20;
+
+import java.util.Scanner;
+import java.util.Arrays;
+
+public class greedy_atm {
+	
+	public static void main(String[] args) {
+		
+	Scanner scan = new Scanner(System.in);
+	
+	int answer = 0;
+	
+	int n = scan.nextInt();
+	
+	int[]man = new int[n];
+	
+	for(int i=0;i<n;i++) man[i] = scan.nextInt();
+	
+	Arrays.sort(man);
+	int temp = 0;
+	for(int i=0;i<man.length;i++) {
+		temp += man[i];
+		answer += temp;
+	}
+	
+	System.out.println(answer);
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_20/greedy_bracket.java b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_bracket.java
new file mode 100644
index 0000000..1584131
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_bracket.java
@@ -0,0 +1,39 @@
+package Today_22_05_20;
+
+import java.util.Scanner;
+
+public class greedy_bracket {
+	
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		String temp = scan.next();
+		
+		String[]str = temp.split("\\-");
+		
+		int answer = 0;
+		
+		for(int i=0;i<str.length;i++) {
+			
+			String[]subStr = str[i].split("\\+");
+			
+			int calc = 0;
+			for(String item : subStr) {
+				calc += Integer.parseInt(item);
+			}
+			
+			if(i==0) {
+				answer += calc;
+				
+			}else {
+				answer -= calc;
+			}
+		}
+	
+		
+		System.out.println(answer);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_20/greedy_coin.java b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_coin.java
new file mode 100644
index 0000000..78f5cc6
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_coin.java
@@ -0,0 +1,43 @@
+package Today_22_05_20;
+
+import java.util.Scanner;
+import java.util.Arrays;
+import java.util.Collections;
+public class greedy_coin {
+	
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		
+		int n = scan.nextInt();
+		int k = scan.nextInt();
+		
+		int answer = 0;
+
+		Integer[]arr = new Integer[n];
+		
+		
+		for(int i=0;i<n;i++) arr[i] = scan.nextInt();
+		
+		Arrays.sort(arr, Collections.reverseOrder());
+		
+		for(int i=0;i<arr.length;i++) {
+			
+			int coin = arr[i];
+			
+			
+			while(k>=coin) {
+				System.out.println(coin);
+				answer++;
+				k -= coin;
+			}
+			
+			
+		}
+		
+		System.out.println(answer);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_20/greedy_coin2.java b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_coin2.java
new file mode 100644
index 0000000..11d3b15
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_coin2.java
@@ -0,0 +1,35 @@
+package Today_22_05_20;
+
+import java.util.Scanner;
+import java.util.Arrays;
+import java.util.Collections;
+public class greedy_coin2 {
+	
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		
+		int n = scan.nextInt();
+		int k = scan.nextInt();
+		
+		int answer = 0;
+
+		Integer[]arr = new Integer[n];
+		
+		
+		for(int i=0;i<n;i++) arr[i] = scan.nextInt();
+		
+		for(int i=arr.length-1;i>-1;i--) {
+			
+			if(arr[i]<=k) {
+				answer += k/arr[i];
+				k = k%arr[i];
+			}
+			
+		}
+		
+		System.out.println(answer);
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_20/greedy_sugar.java b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_sugar.java
new file mode 100644
index 0000000..8afced0
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_sugar.java
@@ -0,0 +1,40 @@
+package Today_22_05_20;
+
+import java.io.InputStreamReader;
+import java.io.BufferedReader;
+public class greedy_sugar {
+	
+	public static void main(String[] args) throws Exception {
+	
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		
+		int n = Integer.parseInt(br.readLine());
+		
+		//3 //5
+		int answer = 0;
+		
+		//5의 배수도 3의 배수도 아닌 경우에도 나눠 떨어지는 애들이 있음!
+		
+		
+		while(true) {
+			
+			if(n%5==0) {
+				answer += n/5;
+				break;
+			}else {
+				answer ++;
+				n -= 3;
+			}
+			
+			if(n<0) {
+				answer = -1;
+				break;
+			}
+			
+		}
+		
+		System.out.println(answer);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_20/greedy_wordsMath.java b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_wordsMath.java
new file mode 100644
index 0000000..1cd2aa4
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_20/greedy_wordsMath.java
@@ -0,0 +1,42 @@
+package Today_22_05_20;
+
+import java.util.Scanner;
+
+public class greedy_wordsMath {
+
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		int n = scan.nextInt();
+		
+		int[]arr = new int[n];
+		
+		for(int i=0;i<arr.length;i++) arr[i] = scan.nextInt();
+		
+		int answer = 0;
+		
+		int nPoint = arr[arr.length-1];
+		
+		
+		
+		for(int i=arr.length-2;i>-1;i--) {
+			
+			int pre = arr[i];
+			while(nPoint<=pre) {
+				
+				answer++;
+				pre--;
+				
+			}
+			
+			nPoint = pre;
+			
+			
+		}
+		
+		
+		System.out.println(answer);
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_20/room.java b/Basic_Of_Algorithm/src/Today_22_05_20/room.java
new file mode 100644
index 0000000..279c1db
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_20/room.java
@@ -0,0 +1,48 @@
+package Today_22_05_20;
+
+import java.util.Scanner;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class room {
+	
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+	
+		int n = scan.nextInt();
+		
+		int[][]arr = new int[n][2];
+		
+		int answer = 0 ;
+		
+		for(int i=0;i<n;i++) {
+			arr[i][0] = scan.nextInt();
+			arr[i][1] = scan.nextInt();
+		}
+		
+		Arrays.sort(arr, new Comparator<int[]>() {
+
+			@Override
+			public int compare(int[] o1, int[] o2) {
+				if(o1[1]==o2[1]) return o1[0] - o2[0];
+				else return o1[1] - o2[1];
+			}
+		});
+		
+		int end_time = 0;
+		
+		for(int i=0;i<arr.length;i++) {
+			
+			if(end_time<=arr[i][0]) {
+				end_time = arr[i][1];
+				answer++;
+			}
+			
+			
+		}
+		System.out.println(answer);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_20/tuple.java b/Basic_Of_Algorithm/src/Today_22_05_20/tuple.java
new file mode 100644
index 0000000..3dd835a
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_20/tuple.java
@@ -0,0 +1,33 @@
+package Today_22_05_20;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class tuple {
+
+	
+	public static void main(String[] args) {
+		
+		String s = "{{2},{2,1},{2,1,3},{2,1,3,4}}";
+		
+		s = s.replaceAll("\\{", "");
+		s = s.replaceAll("\\}", "");
+		
+		HashMap<Integer,Integer> map = new HashMap<>();
+		
+		String [] splitString = s.split(",");
+		
+		for(int i=0;i<splitString.length;i++) {
+			int num = Integer.parseInt(splitString[i]);
+			map.put(num, map.getOrDefault(num, 0)+1);
+		}
+		
+		List<Integer> keySet = new ArrayList<>(map.keySet());
+		Collections.sort(keySet, (o1,o2)-> map.get(o2).compareTo(map.get(o1)));
+		
+		System.out.println(keySet);
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no1.java b/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no1.java
new file mode 100644
index 0000000..2b0e920
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no1.java
@@ -0,0 +1,65 @@
+package Today_22_05_24;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class backJoon_greedy_no1 {
+
+	static int answer = -1;
+
+	public static void main(String[] args) throws Exception {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		
+		String n = br.readLine();
+		
+		
+		
+		String str = String.valueOf(n);
+		
+		boolean[]visited = new boolean[str.length()];
+		
+		
+		dfs(visited,str,"",0);
+		
+		System.out.println(String.valueOf(answer));
+		
+	}
+	
+	static boolean check(String now) {
+		
+		int a = Integer.parseInt(now);
+		
+		if(a%30==0) return true;
+		else return false;
+		
+		
+		
+	}
+	
+	static void dfs(boolean[]visited,String str,String now,int count) {
+		
+		
+		if(count==str.length()) {
+			if(check(now)) {
+				answer = Math.max(answer, Integer.parseInt(now));
+			}
+			return;
+		}
+		
+			for(int i=0;i<str.length();i++) {
+				if(!visited[i]) {
+					visited[i] = true;
+					String next = now + str.charAt(i);
+					dfs(visited,str,next,count+1);
+					visited[i] = false;
+				}
+			}
+		
+	}
+	
+
+		
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no2.java b/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no2.java
new file mode 100644
index 0000000..50dac69
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no2.java
@@ -0,0 +1,59 @@
+package Today_22_05_24;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class backJoon_greedy_no2 {
+
+	
+
+	public static void main(String[] args) throws Exception {
+		
+	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	
+	int t = Integer.parseInt(br.readLine());
+	
+	//25 10 5 1
+	
+	for(int i=0;i<t;i++) {
+		
+		int money = Integer.parseInt(br.readLine());
+		
+		int a =0, b=0, c=0, d = 0;
+		
+		while(true) {
+			
+			if(money>=25) {
+				money -= 25;
+				a++;
+			}
+			else if(money>=10) {
+				money -= 10;
+				b++;
+			}
+			else if(money>=5) {
+				money -=5;
+				c++;
+			}
+			else {
+				money -= 1;
+				d++;
+			
+			}
+			
+			if(money<=0) break;
+			
+		}
+		
+		
+		System.out.println(a+" "+b+" "+c+" "+d);
+		
+	}
+		
+		
+		
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no3.java b/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no3.java
new file mode 100644
index 0000000..7d6812a
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no3.java
@@ -0,0 +1,33 @@
+package Today_22_05_24;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class backJoon_greedy_no3 {
+
+	public static void main(String[] args) throws Exception {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		
+		String[] input = br.readLine().split("");
+        
+        int i = 0;
+        for(String checkA : input) {
+            if(i == 0 && checkA.equals("U")) i++;
+            if((i == 1 || i == 3) && checkA.equals("C")) i++;
+            if(i == 2 && checkA.equals("P")) i++;
+        }
+        if(i==4) {
+            System.out.println("I love UCPC");
+        }else {
+            System.out.println("I hate UCPC");
+        }
+		
+	
+	}
+	
+
+		
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no4.java b/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no4.java
new file mode 100644
index 0000000..7e12d23
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no4.java
@@ -0,0 +1,58 @@
+package Today_22_05_24;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class backJoon_greedy_no4 {
+
+	public static void main(String[] args) throws Exception {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		
+		int answer = 0;
+		
+		int n = Integer.parseInt(br.readLine());
+		
+		String s = br.readLine();
+		
+		Integer []crain = new Integer[n];
+		
+		for(int i=0;i<n;i++) crain[i] = Integer.parseInt(s.split(" ")[i]);	
+		
+		Arrays.sort(crain, Collections.reverseOrder());
+		
+		int m = Integer.parseInt(br.readLine());
+		
+		String s2 = br.readLine();
+		
+		PriorityQueue<Integer> q = new PriorityQueue<>(Collections.reverseOrder());
+		
+		for(int i=0;i<m;i++) q.add(Integer.parseInt(s2.split(" ")[i]));
+		
+		if(q.peek()>crain[0]) answer = -1;
+		else {
+			
+			while(!q.isEmpty()) {
+				
+				answer++;
+				
+				for(int i=0;i<crain.length;i++) {
+					
+					if(!q.isEmpty() && crain[i] >= q.peek()) q.poll();
+					if(q.isEmpty()) break;
+					
+				}
+				
+				if(q.isEmpty()) break;
+				
+			}
+		}
+		
+		
+		System.out.println(answer);
+		
+	
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no5.java b/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no5.java
new file mode 100644
index 0000000..3ba6717
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_24/backJoon_greedy_no5.java
@@ -0,0 +1,18 @@
+package Today_22_05_24;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.*;
+
+public class backJoon_greedy_no5 {
+
+	public static void main(String[] args) throws Exception {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		
+	
+		
+	
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_1.java b/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_1.java
new file mode 100644
index 0000000..c3328b3
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_1.java
@@ -0,0 +1,54 @@
+package Today_22_05_24;
+
+public class programmer_lv_2_no_1 {
+	
+	public static void main(String[] args) {
+		
+		
+		
+		String s = "aabbaccc";
+		
+		int answer = Integer.MAX_VALUE;
+		
+		
+		for(int i=1;i<=s.length()/2;i++) {
+			
+				String result ="";
+				String next = "";
+				String now = "";
+				int hit = 1;
+				
+			for(int j=0;j<=s.length()/i;j++) {
+				
+				int start = i * j;
+				int end = i * ( j + 1 ) > s.length() ? s.length():i*(j+1) ;
+				
+				next = s.substring(start,end);
+				
+				if(now.equals(next)) {
+					hit++;
+				}else {
+					
+					result += processHit(hit) + now;
+					hit = 1;
+				}
+				now = next;
+				
+				
+			}
+			result += processHit(hit) + now;
+			
+			System.out.println(result + " : " + result.length() + " 개");
+			
+			answer = Math.min(answer, result.length());
+		}
+		
+		System.out.println("답 :" + answer+" 개 ");
+		
+		
+	}
+	static String processHit(int hit) {
+		return hit>1 ? String.valueOf(hit) : "";
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_2.java b/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_2.java
new file mode 100644
index 0000000..20739be
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_2.java
@@ -0,0 +1,56 @@
+package Today_22_05_24;
+
+import java.util.Queue;
+import java.util.LinkedList;
+import java.util.ArrayList;
+
+public class programmer_lv_2_no_2 {
+	
+	public static void main(String[] args) {
+		
+		int [] progresses = {95, 90, 99, 99, 80, 99};
+		
+		int [] speeds = {1, 1, 1, 1, 1, 1};
+		
+		Queue<Integer> q = new LinkedList<>();
+		
+		for(int i=0;i<progresses.length;i++) {
+			
+			int temp = 0;
+			
+
+			
+			while(progresses[i]<100) {
+				progresses[i] += speeds[i];
+				temp++;
+			}
+			
+			q.add(temp);
+			
+		}
+		
+		
+		ArrayList<Integer> answerList = new ArrayList<>();
+		
+		while(!q.isEmpty()) {
+			
+			int a = q.poll();
+			
+			int answerInt = 1;
+			
+			while(!q.isEmpty() && a>= q.peek()) {
+				
+				answerInt++;
+				q.poll();
+			}
+			
+			answerList.add(answerInt);
+			
+		}
+		
+		System.out.println(answerList);
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_3.java b/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_3.java
new file mode 100644
index 0000000..edb7701
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_3.java
@@ -0,0 +1,84 @@
+package Today_22_05_24;
+
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class programmer_lv_2_no_3 {
+	
+	 static ArrayList<int[]> answer = new ArrayList<>();
+	    static int[] ryan;
+	    static int[] apeach;
+	    static int N;
+	    static int max = Integer.MIN_VALUE;
+	
+	
+	public static void main(String[] args) {
+		
+		int []info = {0,0,0,0,0,0,0,0,3,4,3};
+		
+		int n = 10;
+		
+		apeach = info.clone();
+		
+		ryan = new int[11];
+        N = n;
+        apeach = info.clone();
+        dfs(0, 0);
+        
+        Collections.sort(answer,(o1,o2)->{
+        	
+        	
+        	for(int i=apeach.length-1;i>-1;i--) {
+        		if(o1[i]!=o2[i]) return o2[i]-o1[i];
+        	}
+        	
+        	
+        	return 0;
+        });
+        
+        for(int i : answer.get(0))System.out.print(i+",");
+        
+	}
+	 
+	static void dfs(int s, int l) {
+		
+		if(l==N) {
+			int r = 0;
+			int a = 0;
+			
+			for(int i=0;i<apeach.length;i++) {
+				if(ryan[i]==0 && apeach[i]==0)continue;
+				if(apeach[i]<ryan[i]) r += 10 - i;
+				else a += 10 - i;
+			}
+			
+			
+			if(r>a) {
+				int diff = r - a;
+				if(diff>max) {
+					max = diff;
+					answer.clear();
+					answer.add(ryan.clone());
+				}else if(diff==max) {
+					answer.add(ryan.clone());
+				}
+				
+			}
+			
+			
+		}
+		
+		else {
+			
+			for(int i=s;i<apeach.length;i++) {
+				ryan[i]++;
+				dfs(i,l+1);
+				ryan[i]--;
+				
+			}
+			
+		}
+	}
+	
+}  
diff --git a/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_4.java b/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_4.java
new file mode 100644
index 0000000..2851d04
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_24/programmer_lv_2_no_4.java
@@ -0,0 +1,14 @@
+package Today_22_05_24;
+
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class programmer_lv_2_no_4 {
+	
+
+	 public static void main(String[] args) {
+		
+		 
+	}
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_antenna.java b/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_antenna.java
new file mode 100644
index 0000000..2df6ec0
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_antenna.java
@@ -0,0 +1,55 @@
+package Today_22_05_26;
+
+import java.util.Scanner;
+
+import java.util.Arrays;
+
+public class backJoon_antenna {
+
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		int n = scan.nextInt();
+		
+		int[]arr = new int[n];
+		
+		for(int i=0;i<n;i++) arr[i] = scan.nextInt();
+		
+		Arrays.sort(arr);
+		
+		int answer = 0;
+		
+	
+		if(n%2==0) {
+			int one = 0;
+			int two = 0;
+			
+			for(int i=0;i<arr.length;i++) {
+				one += Math.abs(arr[arr.length/2] - arr[i]);
+				
+			}
+			
+			System.out.println(arr.length/2);
+			for(int i=0;i<arr.length;i++) {
+				two += Math.abs(arr[(arr.length/2)-1] - arr[i]);
+			}
+			
+			answer = Math.min(one, two);
+			
+			
+		}else {
+			
+			for(int i=0;i<arr.length;i++) {
+				
+				answer += Math.abs(arr[arr.length/2-1] - arr[i]);
+			
+			}
+			
+		}
+		
+		
+		System.out.println(answer);
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_color.java b/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_color.java
new file mode 100644
index 0000000..90598ea
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_color.java
@@ -0,0 +1,85 @@
+package Today_22_05_26;
+
+public class backJoon_color {
+
+	public static void main(String[] args) {
+		
+		String [] color = {"RRRBB","GGBBB","BBBRR","BBRRR","RRRRR"};
+		char[][] map = new char[color.length][color[0].length()];
+		
+		boolean[][] visited = new boolean[map.length][map[0].length];
+		boolean[][] visited2 = new boolean[map.length][map[0].length];
+		
+		int normal = 0;
+		int special = 0;
+		
+		
+		for(int i=0;i<color.length;i++) {
+			for(int j=0;j<color[0].length();j++) {
+				map[i][j] = color[i].charAt(j);
+			}
+		}
+		
+		
+		for(int i=0;i<map.length;i++) {
+			for(int j=0;j<map[0].length;j++) {
+				if(!visited[i][j]) {
+					dfs(visited,map,i,j);
+					normal++;
+				}
+			}
+		}
+		System.out.println(normal);
+
+		for(int i=0;i<map.length;i++) {
+			for(int j=0;j<map[0].length;j++) {
+				if(map[i][j]=='R') map[i][j]='G';
+			}
+		}
+		
+		for(int i=0;i<map.length;i++) {
+			for(int j=0;j<map[0].length;j++) {
+				if(!visited2[i][j]) {
+					dfs(visited2,map,i,j);
+					special++;
+				}
+			}
+		}
+		
+	
+		
+		System.out.println(special);
+		
+	}
+	
+	static void dfs(boolean[][]visited, char[][]map,int i,int j) {
+		
+		visited[i][j] = true;
+		
+		
+		int[][]move = {{0,1},{1,0},{0,-1},{-1,0}};
+		
+		
+		for(int d=0;d<4;d++) {
+			
+			int newI = i + move[d][0];
+			int newJ = j + move[d][1];
+			
+			if(newI<0||newJ<0||map.length-1<newI||map[0].length-1<newJ) continue;
+			
+			if(map[i][j]==map[newI][newJ] && !visited[newI][newJ]) {
+				dfs(visited,map,newI,newJ);
+			}
+			
+		}
+		
+		
+		
+		
+		
+		
+		
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_combination.java b/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_combination.java
new file mode 100644
index 0000000..a30103a
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_combination.java
@@ -0,0 +1,47 @@
+package Today_22_05_26;
+
+import java.util.*;
+
+public class backJoon_combination {
+
+	
+	public static void main(String[] args) {
+	
+	Scanner scan = new Scanner(System.in);
+		
+	int n = scan.nextInt();
+	int m = scan.nextInt();
+	int [] arr = new int[n];
+	
+	for(int i=0;i<n;i++) arr[i] = i+1;
+	
+
+
+	combi(arr,m,"");
+		
+		
+	
+	
+	
+		
+	}
+	
+	static void combi(int[]arr,int count,String now) {
+		
+		
+		if(count==0) {
+			System.out.println(now);
+			return;
+		}
+		
+		
+		
+		for(int i=0;i<arr.length;i++) {
+			String newOne = arr[i]+ " " + now;
+			combi(arr,count-1,newOne);
+		}
+		
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_number_card2.java b/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_number_card2.java
new file mode 100644
index 0000000..0888145
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_26/backJoon_number_card2.java
@@ -0,0 +1,71 @@
+package Today_22_05_26;
+
+import java.util.Arrays;
+
+public class backJoon_number_card2 {
+	
+	public static void main(String[] args) {
+		
+		int [] arr1 = {6,3,2,10,10,10,-10,7,3};
+		int [] arr2 = {10,9,-5,2,3,4,5,-10};
+		
+		int []answer = new int[arr2.length];
+		
+		
+		Arrays.sort(arr1);
+		
+		
+		for(int i=0;i<arr2.length;i++) {
+			
+			answer[i] = upperBound(arr2[i],arr1) - lowerBound(arr2[i],arr1);
+		}
+		
+		
+		for(int i : answer)System.out.println(i);
+		
+		
+	}
+	static int lowerBound(int num,int []arr) {
+		
+		
+		int start = 0;
+		int end = arr.length;
+		
+		
+		while(start<end) {
+			
+			int mid = (start+end)/2;
+			
+			if(arr[mid]>=num) {
+				end = mid;
+			}else {
+				start = mid+1;
+			}
+			
+		}
+		
+		return start;
+	}
+	static int upperBound(int num,int []arr) {
+		
+		
+		int start = 0;
+		int end = arr.length;
+		
+		
+		while(start<end) {
+			
+			int mid = (start+end)/2;
+			
+			if(arr[mid]>num) {
+				end = mid;
+			}else {
+				start = mid+1;
+			}
+			
+		}
+		
+		return start;
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_26/programmers_bruteForce.java b/Basic_Of_Algorithm/src/Today_22_05_26/programmers_bruteForce.java
new file mode 100644
index 0000000..c44f1e1
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_26/programmers_bruteForce.java
@@ -0,0 +1,70 @@
+package Today_22_05_26;
+
+import java.util.*;
+
+public class programmers_bruteForce {
+
+	static int answer = 0;
+	static Set<Integer>set = new HashSet<>();
+
+	
+	public static void main(String[] args) {
+		
+	
+		String numbers = "17";
+		
+		
+		
+		boolean[]visited = new boolean[numbers.length()];
+		
+		dfs(numbers,visited,"");
+		
+		System.out.println(set.size());
+		System.out.println(set);
+		
+	}
+	
+	static void dfs(String numbers,boolean [] visited,String now) {
+		
+		if(!now.isEmpty()) {
+			
+			
+			int temp = Integer.parseInt(now);
+			boolean flag = true;
+			
+			if(temp==2) flag = true;
+			else if(temp==1 || temp==0) flag = false;
+			
+			
+			for(int i=2;i<=Math.sqrt(temp);i++) {
+				
+				if(temp%i==0) {
+					flag = false;
+					break;
+				}
+				
+			}
+			
+			if(flag) set.add(temp);
+		}
+		
+		
+		
+		
+		for(int i = 0 ; i<numbers.length();i++) {
+			
+			if(!visited[i]) {
+				visited[i] = true;
+				String newOne = now + numbers.charAt(i);
+				dfs(numbers,visited,newOne);
+				visited[i] = false;
+			}
+			
+			
+		}
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_26/rightBigNumber.java b/Basic_Of_Algorithm/src/Today_22_05_26/rightBigNumber.java
new file mode 100644
index 0000000..a8cc534
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_26/rightBigNumber.java
@@ -0,0 +1,39 @@
+package Today_22_05_26;
+
+import java.util.Stack;
+
+public class rightBigNumber {
+	
+	public static void main(String[] args) {
+		
+		int []arr = {1,5,3,0,2};
+		 		   
+		Stack<Integer> temp = new Stack<>();
+		Stack<Integer> pra = new Stack<>();
+		
+		//5 3 2 2 0
+		
+		for(int i=arr.length-1;i>-1;i--) {
+			
+			int num = arr[i];
+			
+			while(!temp.isEmpty() && num>= temp.peek()) {
+				temp.pop();
+			}
+			
+			if(temp.isEmpty()) {
+				pra.add(-1);
+			}else {
+				pra.add(temp.peek());
+			}
+			
+			temp.add(num);
+			
+			
+			
+			
+		}
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_26/test.java b/Basic_Of_Algorithm/src/Today_22_05_26/test.java
new file mode 100644
index 0000000..941152c
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_26/test.java
@@ -0,0 +1,35 @@
+package Today_22_05_26;
+
+import java.util.*;
+
+public class test {
+
+	public static void main(String[] args) {
+		
+		
+		int[]arr = {3,7,1,5};
+					//-1 5 -1 7 stack
+		
+		Stack<Integer>temp = new Stack<>();
+		Stack<Integer>ans = new Stack<>();
+		
+		
+		for(int i=arr.length-1;i>-1;i--) {
+			
+			int num = arr[i];
+			
+			
+			while(!temp.isEmpty()&&num>=temp.peek()) temp.pop();
+			
+			
+			if(temp.isEmpty()) ans.add(-1);
+			else ans.add(temp.peek());
+			
+			temp.add(num);
+			
+		}
+		
+		
+		System.out.println(ans);
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_26/twoPointer.java b/Basic_Of_Algorithm/src/Today_22_05_26/twoPointer.java
new file mode 100644
index 0000000..4e8fd61
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_26/twoPointer.java
@@ -0,0 +1,48 @@
+package Today_22_05_26;
+
+import java.util.*;
+
+public class twoPointer {
+
+	public static void main(String[] args) {
+		
+		int [] two = {1,1,2,2,3,3};
+					//1,1,2,2,3,5,7
+		int target = 4;
+		int answer = 0;
+		//답 = 2
+		int start = 0;
+		int end = two.length-1;
+		Arrays.sort(two);
+		
+		
+		
+		while(start<=end) {
+			
+			
+			int sum = two[start] + two[end];
+			
+			if(sum<target) start++;
+			else if(start==end) break;
+			else end--;
+			
+			
+			if(target==sum)answer++;
+			
+			
+			
+		}
+		
+		
+		System.out.println(answer);
+		
+			
+			
+		
+		
+		
+		
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_26/yangong.java b/Basic_Of_Algorithm/src/Today_22_05_26/yangong.java
new file mode 100644
index 0000000..bad5bf0
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_26/yangong.java
@@ -0,0 +1,102 @@
+package Today_22_05_26;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class yangong {
+
+	
+	static int[] answer;
+	static int[] apeach;
+	static int[] ryan;
+	static boolean[] visited;
+	static int count;
+	static int max = Integer.MIN_VALUE;
+	static ArrayList<int[]>answerList = new ArrayList<>();
+	
+	public static void main(String[] args) {
+		
+		int[] info = {2,1,1,1,0,0,0,0,0,0,0};
+		int n = 5;
+		apeach = info.clone();
+		ryan = new int[apeach.length];
+		visited = new boolean[apeach.length];
+		count = n;
+		
+		answer = solution(n,info);
+		
+		for(int i=0;i<answer.length;i++) System.out.print(answer[i]+" ,");
+	
+		
+		
+	
+	}
+	
+	static void dfs(int s,int L) {
+		
+		if(L==count) {
+			
+			int r = 0;
+			int a = 0;
+			
+			for(int i=0;i<apeach.length;i++) {
+				if(ryan[i]==0 && apeach[i] == 0) continue;
+				
+				if(ryan[i]>apeach[i]) r += 10 - i;
+				else a += 10 - i;
+			}
+			
+			
+			if(r>a) {
+				int diff = r-a;
+				if(max<diff) {
+					max = diff;
+					answerList.clear();
+					answerList.add(ryan.clone());
+				}else if(max==diff) answerList.add(ryan.clone());
+				
+			}
+			
+			return;
+		}
+		
+		
+		for(int i=s;i<apeach.length;i++) {
+			ryan[i]++;
+			dfs(i, L+1);
+			ryan[i]--;
+		}
+	}
+	
+	
+	static int[] solution(int n, int[] info) {
+		 
+		 
+		
+		dfs(0,0);
+		 
+		 
+		Collections.sort(answerList,(o1,o2)->{
+			for(int i=10;i>-1;i--) {
+				if(o1[i]!=o2[i]) return o2[i] - o1[i];
+			}
+			return 0;
+		});
+		
+		
+		if(answerList.isEmpty()) return new int[] {-1};
+		
+			answer = new int[info.length];
+			
+			for(int i=0;i<info.length;i++) answer[i] = answerList.get(0)[i];
+			
+			return answer;
+			
+			
+		
+		
+		 
+	 }
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo01.java b/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo01.java
new file mode 100644
index 0000000..542f282
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo01.java
@@ -0,0 +1,73 @@
+package Today_22_05_27;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class binarySearchNo01 {
+
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+        
+        int n = scan.nextInt();
+        
+        int[]arr = new int[n];
+        
+        for(int i=0;i<n;i++)arr[i] = scan.nextInt();
+        
+        int m = scan.nextInt();
+      
+        int[]find = new int[m];
+        
+        
+        for(int i=0;i<m;i++)find[i] = scan.nextInt();
+		
+		int [] answer = new int[find.length];
+		
+		
+		
+		Arrays.sort(arr);
+		
+		for(int i=0;i<find.length;i++) {
+			
+			int num = find[i];
+			
+			answer[i] = binary(num,arr);
+			
+			if(answer[i]>1) answer[i] = 1;
+			
+		}
+		
+		for(int i : answer)System.out.println(i);
+		
+		
+	}
+	
+	static int binary(int num,int[] arr) {
+		
+		
+		int start = 0;
+		int end = arr.length-1;
+		int count = 0;
+		
+		while(start<=end) {
+			
+			int mid = (start+end) / 2;
+			
+			if(num>=arr[mid]) start = mid+1;
+			else if(start==end)break;
+			else if(num<arr[mid]) end = mid - 1;
+			
+			if(arr[mid]==num) count++;
+			
+			
+		}
+		
+		
+		
+		return count;
+		
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo2.java b/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo2.java
new file mode 100644
index 0000000..71237ec
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo2.java
@@ -0,0 +1,86 @@
+package Today_22_05_27;
+
+import java.util.Scanner;
+import java.util.Arrays;
+
+public class binarySearchNo2 {
+	
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		int n = scan.nextInt();
+		
+		int [] arr = new int[n];
+		
+		for(int i=0;i<n;i++) arr[i] = scan.nextInt();
+
+		Arrays.sort(arr);
+		
+		int m = scan.nextInt();
+		
+		int [] find = new int[m];
+		
+		for(int i=0;i<m;i++) find[i] = scan.nextInt();
+		
+		int []answer = new int[m];
+		
+		for(int i=0;i<find.length;i++) {
+			
+			int num = find[i];
+			
+			answer[i] = upperSearch(num, arr)-lowerSearch(num,arr);
+			
+		}
+		
+		for(int i : answer)System.out.println(i);
+	}
+	
+		static int upperSearch(int num, int []arr) {
+			
+			int start = 0;
+			int end = arr.length-1;
+		
+			
+			while(start<=end) {
+				
+				
+				
+				int mid = (start+end)/2;
+				
+
+				
+				if(num>=arr[mid]) start = mid+1;
+				else end = mid-1;
+				
+			}
+			
+			return start;
+			
+		}
+		
+		static int lowerSearch(int num, int []arr) {
+			
+			int start = 0;
+			int end = arr.length-1;
+	
+			while(start<=end) {
+				
+				
+
+				int mid = (start+end)/2;
+				
+
+				
+				if(num>arr[mid]) start = mid+1;
+				else end = mid-1;
+				
+				
+				
+				
+			}
+			
+			return start;
+			
+		}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo3.java b/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo3.java
new file mode 100644
index 0000000..fee42cc
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo3.java
@@ -0,0 +1,61 @@
+package Today_22_05_27;
+
+import java.util.Scanner;
+import java.util.Arrays;
+
+public class binarySearchNo3 {
+
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		int k = scan.nextInt();
+		int n = scan.nextInt();
+		
+		int[]arr = new int[k];
+		
+		for(int i =0;i<k;i++) arr[i] = scan.nextInt();
+		
+		Arrays.sort(arr);
+		
+		
+		long max = arr[arr.length-1]+1;
+		
+		long min = 0;
+		long mid = 0;
+		
+	
+		while(min<max) {
+			
+			
+			mid = (max+min)/2;
+			
+			long count = 0;
+			
+			for(int i=0;i<arr.length;i++) {
+				
+				count += (arr[i]/mid);
+			}
+			
+			
+			if(count<n) {
+				max = mid;
+			}else {
+				min = mid+1;
+				
+			}
+			
+			
+			
+			
+			
+		}
+		
+		
+		
+		
+		System.out.println(min - 1);
+	}
+	
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo4.java b/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo4.java
new file mode 100644
index 0000000..e7a74c1
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/binarySearchNo4.java
@@ -0,0 +1,62 @@
+package Today_22_05_27;
+
+import java.util.Arrays;
+import java.util.Scanner;
+
+public class binarySearchNo4 {
+	
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		int n = scan.nextInt();
+
+		int m = scan.nextInt();
+		
+		int []arr = new int[n];
+		
+		for(int i=0;i<n;i++) arr[i] = scan.nextInt();
+		
+		Arrays.sort(arr);
+		
+		long min = 0;
+		long max = arr[arr.length-1] + 1;
+		long total = 0;
+		
+		while(min<max) {
+			
+			
+			long mid = (min+max)/2;
+			
+			long temp = 0;
+			
+			for(int i=0;i<arr.length;i++) {
+				
+				if(arr[i]- mid > 0) {
+					temp += (arr[i]-mid);
+				}
+			}
+			
+			
+			if(temp<m) {
+				max = mid;
+			}else {
+				min = mid+1;
+			}
+			
+			
+			
+			
+			
+			
+		}
+		
+		
+		
+		System.out.println(min-1);
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/bracket.java b/Basic_Of_Algorithm/src/Today_22_05_27/bracket.java
new file mode 100644
index 0000000..9cfa93a
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/bracket.java
@@ -0,0 +1,54 @@
+package Today_22_05_27;
+
+import java.util.Stack;
+
+
+public class bracket {
+	
+	public static void main(String[] args) {
+		
+		String s = "[](){}";
+		int answer = 0;
+		
+		
+		for(int i=0;i<s.length();i++) {
+			
+			String temp = s.substring(i);
+			temp += s.substring(0,i);
+			
+			Stack<Character>stack = new Stack<>();
+			
+			for(int j=0;j<temp.length();j++) {
+			
+				char ch = temp.charAt(j);
+				
+				if(stack.isEmpty()) stack.add(ch);
+				else {
+					
+					if(stack.peek()=='(') {
+						if(ch==')') stack.pop();
+						else stack.add(ch);
+					}else if(stack.peek()=='[') {
+						if(ch==']') stack.pop();
+						else stack.add(ch);
+					}else if(stack.peek()=='{') {
+						if(ch=='}') stack.pop();
+						else stack.add(ch);
+					}
+					
+					
+					
+				}
+				
+				
+				
+			}
+			if(stack.isEmpty())answer++;
+			
+		}
+		
+		
+			System.out.println(answer);
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/catchAndHide.java b/Basic_Of_Algorithm/src/Today_22_05_27/catchAndHide.java
new file mode 100644
index 0000000..d22088c
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/catchAndHide.java
@@ -0,0 +1,62 @@
+package Today_22_05_27;
+
+import java.util.*;
+
+public class catchAndHide {
+
+	
+	public static void main(String[] args) {
+		
+		
+		int n = 17; // +1 +1 +1
+		
+		int m = 5; //+1 -1 *2
+		
+		int[]check = new int[100002];
+		
+		check[m] = 0;
+		
+		Queue<int[]>q = new LinkedList<>();
+		
+		
+		q.add(new int[] {n,m,0});
+		
+		
+		while(!q.isEmpty()) {
+			
+			int[]cur = q.poll();
+			
+			int cn = cur[0];
+			int cm = cur[1];
+		
+			
+			if(cn==cm) break;
+			
+			if(cn>100000) break;
+			
+			
+			if(cm+1<10000 && check[cm+1]==0) {
+				check[cm+1] = check[cm] +1;
+				q.add(new int[] {cn,cm+1});
+			}
+			
+			if(cm-1>0 && check[cm-1]==0) {
+				check[cm-1] = check[cm] +1;
+				q.add(new int[] {cn,cm-1});
+			}
+			
+			if(cm*2<10000 && check[cm*2]==0) {
+				check[cm*2] = check[cm] +1;
+				q.add(new int[] {cn,cm*2});
+			}
+			
+		}
+		
+		
+	System.out.println(check[n]);
+		
+		
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/disk.java b/Basic_Of_Algorithm/src/Today_22_05_27/disk.java
new file mode 100644
index 0000000..3c1a0e1
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/disk.java
@@ -0,0 +1,67 @@
+package Today_22_05_27;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class disk {
+	
+	public static void main(String[] args) {
+		
+	int[][]jobs = {{0, 3}, {1, 9}, {2, 6}};	
+	int answer = 0;
+	
+	Arrays.sort(jobs,(int[]o1,int[]o2)->{
+		if(o1[0]==o2[0]) return o1[1] - o2[1];
+		
+		return o1[0] - o2[0];
+	});
+		
+	for(int i=0;i<jobs.length;i++) {
+		System.out.println(jobs[i][0]+":"+jobs[i][1]);
+	}
+	
+	PriorityQueue<int[]> q = new PriorityQueue<>(new Comparator<int[]>() {
+
+		@Override
+		public int compare(int[] o1, int[] o2) {
+			
+			return o1[1]-o2[1];
+		}
+		
+		
+	});
+	
+	q.offer(jobs[0]);
+	int end = jobs[0][0];
+	int sum = 0;
+	int idx = 1;
+	
+	while(!q.isEmpty()) {
+		int [] cur = q.poll();
+		end += cur[1];
+		sum += end - cur[0];
+		System.out.println(end + " end");
+		System.out.println(sum);
+		
+		while(idx < jobs.length && jobs[idx][0] <= end) {
+			q.offer(jobs[idx++]);
+		}
+		
+		
+		
+		if(idx<jobs.length && q.isEmpty()) {
+			end = jobs[idx][0];
+			q.offer(jobs[idx++]);
+			
+		}
+		
+	}
+	
+	System.out.println(sum/jobs.length);
+	
+	
+	
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/programmers_lv_2_no1.java b/Basic_Of_Algorithm/src/Today_22_05_27/programmers_lv_2_no1.java
new file mode 100644
index 0000000..51f7b7f
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/programmers_lv_2_no1.java
@@ -0,0 +1,62 @@
+package Today_22_05_27;
+
+public class programmers_lv_2_no1 {
+
+	static int[]answer;
+	static int[]num = new int[2];
+	
+	public static void main(String[] args) {
+		
+		
+		int[][]arr = {{1,1,1,1,1,1,1,1},{0,1,1,1,1,1,1,1},{0,0,0,0,1,1,1,1},{0,1,0,0,1,1,1,1},{0,0,0,0,0,0,1,1},{0,0,0,0,0,0,0,1},{0,0,0,0,1,0,0,1},{0,0,0,0,1,1,1,1}};
+		
+		answer = new int[2];
+		
+		
+		change(0,0,arr, arr.length);
+				
+		
+				
+		answer = num.clone();
+		
+		System.out.println(answer[0]);
+		System.out.println(answer[1]);
+	}
+	
+	
+	static void change(int x,int y,int[][]arr,int size) {
+		
+		
+		if(check(x,y,arr,size)) {
+			num[arr[x][y]]++;
+			return;
+		}
+		
+		
+		
+		change(x, y,arr,size/2);
+		change(x+size/2, y,arr,size/2);
+		change(x, y+size/2,arr,size/2);
+		change(x+size/2, y+size/2,arr,size/2);
+		
+		
+	}
+	
+	static boolean check(int x,int y,int[][]arr,int size) {
+		
+		for(int i=x;i<x+size;i++) {
+			for(int j=y;j<y+size;j++) {
+				if(arr[i][j]!=arr[x][y]) return false;
+			}
+		}
+		
+		
+		
+		return true;
+		
+	}
+	
+	
+	
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/programmers_lv_2_no2.java b/Basic_Of_Algorithm/src/Today_22_05_27/programmers_lv_2_no2.java
new file mode 100644
index 0000000..a333810
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/programmers_lv_2_no2.java
@@ -0,0 +1,50 @@
+package Today_22_05_27;
+
+import java.util.Queue;
+import java.util.LinkedList;
+import java.util.PriorityQueue;
+public class programmers_lv_2_no2 {
+
+
+	
+	public static void main(String[] args) {
+		
+		
+		int [] scoville = {1, 2, 3, 9, 10, 12};
+		int k = 7;
+		int answer = 0;
+		
+		
+		PriorityQueue<Integer> q = new PriorityQueue<>();
+		
+		
+		for(int i : scoville) q.offer(i);
+		
+		
+		while(k>q.peek()) {
+			
+			if(q.size()<2)break;
+			
+			
+			int first = q.poll();
+			int second = q.poll();
+			
+			int newOne = first + (second*2);
+			
+			q.offer(newOne);
+			answer++;
+			
+			
+		}
+		
+		
+		System.out.println(answer);
+		
+		
+		
+	}
+	
+	
+	
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/quate.java b/Basic_Of_Algorithm/src/Today_22_05_27/quate.java
new file mode 100644
index 0000000..1b48737
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/quate.java
@@ -0,0 +1,55 @@
+package Today_22_05_27;
+
+public class quate {
+
+	static int [] answer = new int[2];
+
+	public static void main(String[] args) {
+		
+		
+		int [][] arr = {{1,1,1,1,1,1,1,1},{0,1,1,1,1,1,1,1},{0,0,0,0,1,1,1,1},{0,1,0,0,1,1,1,1},{0,0,0,0,0,0,1,1},{0,0,0,0,0,0,0,1},{0,0,0,0,1,0,0,1},{0,0,0,0,1,1,1,1}};
+		
+		
+		
+		dfs(arr,arr.length,0,0);
+		
+		
+		System.out.println(answer[0]+" : "+answer[1]);
+		
+	}
+	
+	static boolean check(int[][]arr,int size,int x, int y) {
+		
+		for(int i=x;i<x+size;i++) {
+			for(int j=y;j<y+size;j++) {
+				if(arr[i][j]!=arr[x][y]) return false;
+			}
+		}
+		
+		
+		
+		return true;
+		
+		
+	}
+	
+	static void dfs(int[][]arr,int size,int x, int y) {
+		
+		
+		if(check(arr,size,x,y)) {
+			
+			answer[arr[x][y]]++;
+			
+			return;
+		}
+		
+		
+		dfs(arr,size/2,x,y);
+		dfs(arr,size/2,x,y+size/2);
+		dfs(arr,size/2,x+size/2,y+size/2);
+		dfs(arr,size/2,x+size/2,y);
+		
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/rightBigNumber.java b/Basic_Of_Algorithm/src/Today_22_05_27/rightBigNumber.java
new file mode 100644
index 0000000..b373088
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/rightBigNumber.java
@@ -0,0 +1,43 @@
+package Today_22_05_27;
+
+import java.util.*;
+
+public class rightBigNumber {
+
+	public static void main(String[] args) {
+		
+		int arr[] = {3,5,2,7};
+		int []answer = new int[arr.length];
+		
+		Stack<Integer> tmp = new Stack<>();
+		Stack<Integer> ans = new Stack<>();
+		
+		for(int i=arr.length-1;i>-1;i--) {
+			
+			int num = arr[i];
+			
+			
+			while(!tmp.isEmpty() && num>=tmp.peek()) {
+				tmp.pop();
+			}
+			
+			if(tmp.isEmpty()) {
+				ans.add(-1);
+			}else {
+				ans.add(tmp.peek());
+			}
+			
+			tmp.add(num);
+			
+			
+			
+			
+		}
+		System.out.println(ans);
+		
+		for(int i=0;i<answer.length;i++) answer[i] = ans.pop();
+		
+		for(int i : answer)System.out.println(i);
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/test.java b/Basic_Of_Algorithm/src/Today_22_05_27/test.java
new file mode 100644
index 0000000..4f69622
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/test.java
@@ -0,0 +1,41 @@
+package Today_22_05_27;
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class test {
+	
+	public static void main(String[] args) {
+		
+		
+		int a = 7;
+		
+		int [] tree = {20,15,10,17};
+		
+		
+		int min = 0;
+		int max = 0;
+		
+	
+		for(int i : tree) if(max<i) max = i;
+		
+		while(min<max) {
+			
+			int mid = (min + max) / 2;
+			int sum = 0;
+			
+			for(int i : tree) if(i-mid > 0) sum += i-mid;
+			
+			if(sum<a) max = mid;
+			else min = mid+1;
+		}
+
+		System.out.println(min-1);
+		
+		
+		
+		
+	
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_27/test2.java b/Basic_Of_Algorithm/src/Today_22_05_27/test2.java
new file mode 100644
index 0000000..8b39087
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_27/test2.java
@@ -0,0 +1,30 @@
+package Today_22_05_27;
+
+public interface test2 {
+
+	public static void main(String[] args) {
+		
+		int [] arr = {802,743,457,539};
+		int a = 11;
+		
+		int min = 0;
+		int max = 0;
+		
+		for(int i : arr) if(max<i)max=i;
+		
+		while(min<max) {
+			
+			int mid = (min+max)/2;
+			int count = 0;
+			
+			for(int i : arr) count += i/mid;
+				
+			if(count<a) max = mid;
+			else min = mid+1;
+			
+		}
+		
+		System.out.println(min-1);
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/HowToLine.java b/Basic_Of_Algorithm/src/Today_22_05_31/HowToLine.java
new file mode 100644
index 0000000..a52bcaa
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/HowToLine.java
@@ -0,0 +1,58 @@
+package Today_22_05_31;
+
+public class HowToLine {
+
+	static int check;
+	static String answer = "";
+	public static void main(String[] args) {
+		
+		
+		int n = 3;
+		int k = 5;
+		
+		check = k;
+		
+		int[]arr = new int[n];
+		
+		int num = 1;
+		
+		for(int i=0;i<n;i++)arr[i] = num++;
+		
+		boolean[]visited = new boolean[n];
+		
+		dfs(arr,visited,0,"");
+		
+		int[]result = new int[n];
+		
+		for(int i=0;i<result.length;i++) {
+			result[i] = Integer.parseInt(""+answer.charAt(i));
+		}
+		
+		
+		for(int i : result)System.out.print(i+",");
+	}
+	
+	static void dfs(int[]arr,boolean[]visited,int count,String now) {
+		
+		if(count==arr.length) {
+			
+			check--;
+			
+			if(check==0) {
+				answer = now;
+				return;
+			}
+			
+		}
+		
+		
+		for(int i=0;i<arr.length;i++) {
+			if(!visited[i]) {
+				visited[i] = true;
+				String next = now + arr[i];
+				dfs(arr,visited,count+1,next);
+				visited[i] = false;
+			}
+		}
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/Yangong.java b/Basic_Of_Algorithm/src/Today_22_05_31/Yangong.java
new file mode 100644
index 0000000..16df24f
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/Yangong.java
@@ -0,0 +1,87 @@
+package Today_22_05_31;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class Yangong {
+
+	static int[]ryan;
+	static int[]apeach;
+	static int arrow;
+	static ArrayList<int[]> answerList = new ArrayList<>();
+	static int maxValue = Integer.MIN_VALUE;
+	
+	public static void main(String[] args) {
+		
+		
+	int n = 10;
+	int[]info = {0,0,0,0,0,0,0,0,3,4,3};
+	
+	apeach = info.clone();
+	ryan = new int[apeach.length];
+		
+
+	arrow = n;
+		
+	dfs(0,0);
+	
+	
+	if(answerList.isEmpty()) answerList.add(new int[] {-1});
+	else {
+		
+		Collections.sort(answerList,(o1,o2)-> {
+			
+			for(int i=o1.length-1;i>-1;i--) {
+				if(o1[i]!=o2[i]) return o2[i] - o1[i];
+			}
+			
+			return 0;
+		
+		});
+		
+		
+	}
+		
+	for(int i : answerList.get(0)) System.out.print(i+",");
+		
+	}
+	
+	static void dfs(int start,int goal) {
+		
+		if(goal==arrow) {
+			int r = 0;
+			int a = 0;
+			
+			for(int i=0;i<apeach.length;i++) {
+				
+				if(apeach[i]==0 && ryan[i]==0)continue;
+				
+				if(apeach[i]>=ryan[i]) a += 10 - i;
+				else r += 10-i;
+				
+			}
+			
+			if(r>a) {
+				int diff = r-a;
+				if(maxValue<diff) {
+					maxValue = diff;
+					answerList.clear();
+					answerList.add(ryan.clone());
+				}else if(maxValue==diff) {
+					answerList.add(ryan.clone());
+				}
+			}
+			
+		}else {
+			
+			for(int i=0;i<apeach.length;i++) {
+				ryan[i]++;
+				dfs(i,goal+1);
+				ryan[i]--;
+			}
+			
+		}
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/apchuck.java b/Basic_Of_Algorithm/src/Today_22_05_31/apchuck.java
new file mode 100644
index 0000000..5876cac
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/apchuck.java
@@ -0,0 +1,56 @@
+package Today_22_05_31;
+
+import java.util.ArrayList;
+
+public class apchuck {
+	
+	public static void main(String[] args) {
+		
+		
+		String msg = "KAKAO";
+		
+		String alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+		
+		ArrayList<String> dic = new ArrayList<>();
+		ArrayList<Integer>ans = new ArrayList<>();
+		
+		dic.add("^&#(");
+		
+		for(int i=0;i<alpha.length();i++) dic.add(""+alpha.charAt(i));
+		
+		int idx = 0;
+		
+		String now = "";
+		String next = "";
+		
+		while(idx<msg.length()) {
+			
+			next = ""+msg.charAt(idx);
+			
+			String newOne = now + next;
+			
+			if(dic.contains(newOne)) {
+				now = newOne;
+				idx++;
+				
+				
+			}else {
+				
+				dic.add(newOne);
+				ans.add(dic.indexOf(now));
+				idx++;
+				now = next;
+			}
+			
+				
+			
+			
+		}
+		
+		ans.add(dic.indexOf(now));
+		
+		System.out.println(ans);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/changeBracket.java b/Basic_Of_Algorithm/src/Today_22_05_31/changeBracket.java
new file mode 100644
index 0000000..0e44f88
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/changeBracket.java
@@ -0,0 +1,88 @@
+package Today_22_05_31;
+
+import java.util.Stack;
+
+public class changeBracket {
+
+	public static void main(String[] args) {
+		
+		
+		String p = "()))((()";
+		
+		String result = change(p);
+		
+		System.out.println(result);
+		
+		
+		
+	}
+	static String change(String w) {
+		
+		if(w.isEmpty()) return "";
+		
+		String u = "";
+		String v = "";
+		
+		int i;
+		int left =0;
+		int right = 0;
+		
+		for(i=0;i<w.length();i++) {
+			
+			char ch = w.charAt(i);
+			
+			if(ch==')') right++;
+			else left++;
+			
+			if(right==left) break;
+				
+		}
+		
+		u = w.substring(0,i+1);
+		v = w.substring(i+1,w.length());
+		
+		String result = "";
+		
+		if(right(u)) {
+			
+			result = u + change(v);
+		}else {
+			
+			result = "(" + change(v) + ")";
+			u = u.substring(1,u.length()-1);
+			u = u.replaceAll("\\(", "\\.");
+			u = u.replaceAll("\\)", "\\(");
+			u = u.replaceAll("\\.", "\\)");
+			result += u;
+			
+			
+		}
+		
+		return result;
+		
+		
+		
+	}
+	
+	static boolean right(String u) {
+		
+		Stack<Character>st = new Stack<>();
+		
+		for(int i=0;i<u.length();i++) {
+			char ch = u.charAt(i);
+			if(st.isEmpty()) st.add(ch);
+			else {
+				
+				if(st.peek()=='(') {
+					if(ch==')') st.pop();
+					else st.add(ch);
+				
+				}
+			}
+		
+		}
+		
+		if(st.isEmpty())return true;
+		else return false;
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/dungeon.java b/Basic_Of_Algorithm/src/Today_22_05_31/dungeon.java
new file mode 100644
index 0000000..9d3578d
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/dungeon.java
@@ -0,0 +1,37 @@
+package Today_22_05_31;
+
+public class dungeon {
+	
+	static int answer = 0;
+	
+	public static void main(String[] args) {
+		
+		int k = 80;
+		int[][]dungeons = {{80,20},{50,40},{30,10}};
+		boolean[]visited = new boolean[dungeons.length];
+		
+		dfs(k,dungeons,visited,0);
+		
+		System.out.println(answer);
+		
+	}
+	
+	static void dfs(int k, int[][]dungeons,boolean[]visited,int count) {
+		
+		
+		
+		for(int i=0;i<dungeons.length;i++) {
+			if(!visited[i] && dungeons[i][0]<=k) {
+				visited[i] = true;
+				int newK = k - dungeons[i][1];
+				dfs(newK,dungeons,visited,count+1);
+				visited[i] = false;
+			}
+		}
+		
+	
+		answer = Math.max(answer, count);
+	
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/gameMap.java b/Basic_Of_Algorithm/src/Today_22_05_31/gameMap.java
new file mode 100644
index 0000000..d70dd2f
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/gameMap.java
@@ -0,0 +1,55 @@
+package Today_22_05_31;
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class gameMap {
+	
+	
+	public static void main(String[] args) {
+		
+		int[][] maps = {{1,0,1,1,1},{1,0,1,0,1},{1,0,1,1,1},{1,1,1,0,1},{0,0,0,0,1}};
+		
+		
+		int answer= 0;
+		
+		Queue<int[]>q = new LinkedList<>();
+		
+		int [][]temp = new int[maps.length][maps[0].length];
+		
+		temp[0][0] = 1;
+		
+		q.add(new int[] {0,0});
+		
+		int[][]move = {{0,1},{1,0},{0,-1},{-1,0}};
+		
+		while(!q.isEmpty()) {
+			
+			int [] cur = q.poll();
+			int i = cur[0];
+			int j = cur[1];
+			
+			for(int d = 0 ; d< 4; d++) {
+				
+				int newI = i + move[d][0];
+				int newJ = j + move[d][1];
+				
+				if(newI<0||newJ<0||maps.length-1<newI||maps[0].length-1<newJ)continue;
+				
+				if(maps[newI][newJ]==1 && temp[newI][newJ]==0) {
+					temp[newI][newJ] = temp[i][j] + 1;
+					q.offer(new int[] {newI,newJ});
+				}
+				
+			}
+			
+			
+		}
+		
+		answer = temp[maps.length-1][maps[0].length-1];
+		
+		System.out.println(answer);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/groupPicture.java b/Basic_Of_Algorithm/src/Today_22_05_31/groupPicture.java
new file mode 100644
index 0000000..0037e36
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/groupPicture.java
@@ -0,0 +1,66 @@
+package Today_22_05_31;
+
+public class groupPicture {
+	
+	static char[] member = {'A','C','F','J','M','N','R','T'};
+	static boolean[] visited= new boolean[member.length];
+	static int answer=  0;
+	static String[] dt;
+	
+	public static void main(String[] args) {
+		
+	
+		int n = 2;
+		String [] data = {"N~F=0", "R~T>2"};
+		dt = data;
+		dfs(0,"");
+		
+		System.out.println(answer);
+		
+	}
+	static boolean check(String now) {
+		
+		for(String str : dt) {
+		
+			int pos1 = now.indexOf(str.charAt(0));
+			int pos2 = now.indexOf(str.charAt(2));
+			int op = str.charAt(3);
+			int idx = str.charAt(4) - '0';
+			
+			if(op=='=') {
+				if(!(Math.abs(pos1-pos2)==idx+1)) return false;
+			}else if(op=='>') {
+				if(!(Math.abs(pos1-pos2)>idx+1)) return false;
+			}else if(op=='<') {
+				if(!(Math.abs(pos1-pos2)<idx+1)) return false;
+			}
+			
+		}
+		
+		return true;
+		
+	}
+	
+	static void dfs(int count, String now) {
+		
+		if(count==member.length) {
+			if(check(now)) {
+				answer++;
+			}
+			return;
+		}
+		
+		for(int i=0;i<member.length;i++) {
+			if(!visited[i]) {
+				visited[i] = true;
+				String newOne = now + member[i];
+				dfs(count+1,newOne);
+				visited[i] = false;
+						
+			}
+			
+		}
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/groupPicture2_BFS.java b/Basic_Of_Algorithm/src/Today_22_05_31/groupPicture2_BFS.java
new file mode 100644
index 0000000..d5857e2
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/groupPicture2_BFS.java
@@ -0,0 +1,100 @@
+package Today_22_05_31;
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class groupPicture2_BFS {
+	
+	public static void main(String[] args) {
+		
+		String[][]places = {{"POOOP", "OXXOX", "OPXPX", "OOXOX", "POXXP"}, {"POOPX", "OXPXP", "PXXXO", "OXXXO", "OOOPP"}, {"PXOPX", "OXOXP", "OXPOX", "OXXOP", "PXPOX"}, {"OOOXX", "XOOOX", "OOOXX", "OXOOX", "OOOOO"}, {"PXPXP", "XPXPX", "PXPXP", "XPXPX", "PXPXP"}};
+		int []result = new int[places.length];
+	
+		
+		for(int i=0;i<places.length;i++) {
+			
+			String[]temp = places[i];
+			
+			result[i] = map(temp);
+			
+		}
+		
+		for(int i : result)System.out.println(i);
+		
+	}
+	
+	static boolean check(int i, int j,String[]map) {
+		
+		
+		//그냥 상하좌우
+		
+		int[][]move1 = {{0,1},{1,0},{0,-1},{-1,0}};
+		
+		for(int d= 0 ; d < 4 ; d++) {
+			
+			int newI = i + move1[d][0];			
+			int newJ = j + move1[d][1];
+			
+			if(newI<0||newJ<0||map.length-1<newI||map[0].length()-1<newJ)continue;
+			
+			if(map[newI].charAt(newJ)=='P') return false;
+			
+		}
+		
+		//대각선
+		
+		int[][]move2 = {{1,1},{-1,-1},{1,-1},{-1,1}};
+		
+		for(int d= 0 ; d < 4 ; d++) {
+			
+			int newI = i + move2[d][0];			
+			int newJ = j + move2[d][1];
+			
+			if(newI<0||newJ<0||map.length-1<newI||map[0].length()-1<newJ)continue;
+			
+			if(map[newI].charAt(newJ)=='P') {
+				if(!((map[newI].charAt(j)=='X')&&(map[i].charAt(newJ)=='X'))) return false;
+			}
+			
+		}
+		
+		//맨해튼 거리
+		int[][]move3 = {{2,0},{0,2},{-2,0},{0,-2}};
+		
+		for(int d= 0 ; d < 4 ; d++) {
+			
+			int newI = i + move3[d][0];			
+			int newJ = j + move3[d][1];
+			
+			if(newI<0||newJ<0||map.length-1<newI||map[0].length()-1<newJ)continue;
+			
+			if(map[newI].charAt(newJ)=='P') {
+				if(!(map[(newI+i)/2].charAt((newJ+j)/2)=='X'))return false;
+			}
+			
+		}
+		
+		
+		
+		return true;
+		
+		
+	}
+	
+	static int map(String[]map) {
+		
+		for(int i=0;i<map.length;i++) {
+			for(int j=0;j<map[0].length();j++) {
+				if(map[i].charAt(j)=='P') {
+					if(!check(i,j,map)) {
+						return 0;
+					};
+				}
+			}
+		}
+			
+		return 1;
+	
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/hanoi.java b/Basic_Of_Algorithm/src/Today_22_05_31/hanoi.java
new file mode 100644
index 0000000..38ae63f
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/hanoi.java
@@ -0,0 +1,31 @@
+package Today_22_05_31;
+
+import java.util.Scanner;
+
+
+public class hanoi {
+	
+	public static StringBuilder sb = new StringBuilder();
+	
+	public static void main(String[] args) {
+		
+		int n = 3;
+		
+		
+		hanoi(n,1,2,3);
+		
+	}
+	static void hanoi(int n,int start,int mid,int to) {
+		
+		if(n==1) {
+			System.out.println(start + " -> " + to);
+			return;
+		}
+		
+		hanoi(n-1,start,to,mid);
+		
+		System.out.println(start+" -> " +to);
+		
+		hanoi(n-1,mid,start,to);
+	}
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/lastWordLinked.java b/Basic_Of_Algorithm/src/Today_22_05_31/lastWordLinked.java
new file mode 100644
index 0000000..dd2b1cc
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/lastWordLinked.java
@@ -0,0 +1,52 @@
+package Today_22_05_31;
+
+import java.util.ArrayList;
+
+public class lastWordLinked {
+
+	public static void main(String[] args) {
+		
+		int n = 3;
+		
+		String [] words = {"tank", "kick", "know", "wheel", "land", "dream", "mother", "robot", "tank"};
+		
+		int []answer = new int[2];
+		
+		char last = words[0].charAt(words[0].length()-1);
+		
+		int person = 2;
+		int round = 1;
+		
+		ArrayList<String>wordsList = new ArrayList<>();
+		
+		wordsList.add(words[0]);
+		
+		for(int i=1;i<words.length;i++) {
+			
+			char first = words[i].charAt(0);
+			String now = words[i];
+			
+			if(first != last || wordsList.contains(now)) {
+				answer[0] = person;
+				answer[1] = round;
+				break;
+			}
+
+			wordsList.add(now);
+			
+			last = words[i].charAt(words[i].length()-1);
+			
+			person++;
+			
+			if(person>n) {
+				round++;
+				person = 1;
+			}
+			
+		}
+		
+		System.out.println(answer[0]+" : "+answer[1]);
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/menuRenewal.java b/Basic_Of_Algorithm/src/Today_22_05_31/menuRenewal.java
new file mode 100644
index 0000000..4981387
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/menuRenewal.java
@@ -0,0 +1,66 @@
+package Today_22_05_31;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+public class menuRenewal {
+	
+	static HashMap<String, Integer> map = new HashMap<>();
+	static ArrayList<String>answerList = new ArrayList<>();
+	
+	public static void main(String[] args) {
+		
+		String[]orders = {"ABCFG", "AC", "CDE", "ACDE", "BCFG", "ACDEH"};
+		int[]course = {2,3,4};
+		
+		for(int i=0;i<orders.length;i++) {
+			char[]temp = orders[i].toCharArray();
+			Arrays.sort(temp);
+			orders[i] = String.valueOf(temp);
+		}
+		
+		
+		
+		for(int count : course) {
+			for(String order : orders) {
+				
+				dfs(count,order,"");
+				
+			}
+			
+			if(!map.isEmpty()) {
+				ArrayList<Integer>maxList = new ArrayList<>(map.values());
+				int max = Collections.max(maxList);
+				if(max>1) {
+					for(String key : map.keySet()) {
+						if(max==map.get(key)) {
+							answerList.add(key);
+						}
+					}
+				}
+			}
+			
+			map.clear();
+		}
+		
+		Collections.sort(answerList);
+		
+		System.out.println(answerList);
+		
+	}
+	static void dfs(int count,String order,String now) {
+		
+		if(count==0) {
+			map.put(now, map.getOrDefault(now, 0)+1);
+			return;
+		}
+		
+		for(int i=0;i<order.length();i++) {
+			dfs(count-1,order.substring(i+1),now+order.charAt(i));
+		}
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/parkingFee.java b/Basic_Of_Algorithm/src/Today_22_05_31/parkingFee.java
new file mode 100644
index 0000000..cdc0e1c
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/parkingFee.java
@@ -0,0 +1,86 @@
+package Today_22_05_31;
+
+import java.util.HashMap;
+import java.util.TreeMap;
+import java.util.ArrayList;
+
+public class parkingFee {
+	
+	static HashMap<String,Integer> map = new HashMap<>();
+	static TreeMap<String,Integer> tree = new TreeMap<>();
+	
+	public static void main(String[] args) {
+		
+		int[]fees = {180,5000,10,600};
+		String []records = {"05:34 5961 IN", "06:00 0000 IN", "06:34 0000 OUT", "07:59 5961 OUT", "07:59 0148 IN", "18:59 0000 IN", "19:09 0148 OUT", "22:59 5961 IN", "23:00 5961 OUT"};
+		
+		
+		for(String str : records) {
+			
+			String [] temp = str.split(" ");
+			
+			int time = change(temp[0]);
+			String num = temp[1];
+			String action = temp[2];
+			
+			if(action.equals("IN")) map.put(num, time);				
+			else {
+				
+				if(!tree.containsKey(num)) tree.put(num, 0);
+				
+				tree.put(num, tree.get(num) + (time - map.get(num)));
+				map.remove(num);
+				
+			}
+		}
+		
+		if(!map.isEmpty()) {
+			for(String key : map.keySet()) {
+				if(!tree.containsKey(key)) tree.put(key, 0);
+		
+				tree.put(key, tree.get(key) + ((23 * 60) + 59 - map.get(key)));
+				
+			}
+		}
+		
+		System.out.println(tree);
+		
+		ArrayList<Integer> answerList = new ArrayList<>();
+		
+	
+		
+		for(String key : tree.keySet()) {
+			
+			int time = tree.get(key);
+		
+			if(time<=fees[0]) {
+				answerList.add(fees[1]);
+				continue;
+			}
+			time -= fees[0];
+			double result = fees[1];
+			double check = (double)time/fees[2];
+
+			check = Math.ceil(check);
+	
+			result += fees[3] * check;
+			answerList.add((int)result);
+			
+			
+		}
+		
+		System.out.println(answerList);
+		
+	
+	}
+	static int change(String time) {
+		
+		String [] temp = time.split(":");
+		
+		int hour = Integer.parseInt(temp[0]) * 60;
+		int min = Integer.parseInt(temp[1]) + hour;
+		
+		return min;
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/quad.java b/Basic_Of_Algorithm/src/Today_22_05_31/quad.java
new file mode 100644
index 0000000..2a70cb0
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/quad.java
@@ -0,0 +1,71 @@
+package Today_22_05_31;
+
+public class quad {
+
+	
+	public static void main(String[] args) {
+		
+		solution solution = new solution();
+		
+		int[][]arr1 = {{1,1,0,0},{1,0,0,0},{1,0,0,1},{1,1,1,1}};
+		int[][]arr2 = {{1,1,1,1,1,1,1,1},{0,1,1,1,1,1,1,1},{0,0,0,0,1,1,1,1},{0,1,0,0,1,1,1,1},{0,0,0,0,0,0,1,1},{0,0,0,0,0,0,0,1},{0,0,0,0,1,0,0,1},{0,0,0,0,1,1,1,1}};
+		int[]result1 = solution.solution(arr1);
+		int[]result2 = solution.solution(arr2);
+		
+		System.out.print(result1[0]+" , ");
+		System.out.println(result1[1]);
+		System.out.print(result2[0]+" , ");
+		System.out.println(result2[1]);
+		
+	}
+}
+
+class solution{
+	
+
+	int[]answer;
+	
+	public int[]solution(int[][]arr) {
+		
+		answer= new int[2];
+		
+		
+		
+		change(arr,0,0,arr.length);
+		
+		
+		
+		
+		
+		
+		return answer;
+	}
+	
+	boolean check(int[][]arr,int x,int y,int size) {
+		
+		for(int i=x;i<x+size;i++) {
+			for(int j=y;j<y+size;j++) {
+				if(arr[x][y]!=arr[i][j]) return false;
+			}
+		}
+		
+		return true;
+	}
+	
+	void change(int[][]arr,int x,int y,int size) {
+		
+		
+		if(check(arr,x,y,size)) {
+			answer[arr[x][y]] += 1;
+			return;
+		}
+		
+		
+		change(arr,x,y,size/2);
+		change(arr,x,y+size/2,size/2);
+		change(arr,x+size/2,y,size/2);
+		change(arr,x+size/2,y+size/2,size/2);
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/soosick.java b/Basic_Of_Algorithm/src/Today_22_05_31/soosick.java
new file mode 100644
index 0000000..061c0ee
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/soosick.java
@@ -0,0 +1,86 @@
+package Today_22_05_31;
+
+import java.util.ArrayList;
+
+public class soosick {
+	
+	static char[]op = {'*','+','-'};
+	static ArrayList<Character>opList = new ArrayList<>();
+	static ArrayList<Long>numList = new ArrayList<>();
+	static long answer = 0;
+
+	public static void main(String[] args) {
+		
+		
+		String expression = "100-200*300-500+20";
+		
+		check(expression);
+		
+		boolean[]visited = new boolean[3];
+		
+		dfs(new char[3],0,visited);
+		
+		System.out.println(answer);
+		
+	}
+	static long change(long a,long b,char ch) {
+		if(ch=='+')return a+b;
+		else if(ch=='-')return a-b;
+		else if(ch=='*')return a*b;
+		return 0;
+	}
+	static void dfs(char[]p,int num,boolean[]visited) {
+		
+		if(num==3) {
+			
+			ArrayList<Long> numArr = new ArrayList<>(numList);
+			ArrayList<Character> opArr = new ArrayList<>(opList);
+			
+			for(int i=0;i<p.length;i++) {
+				for(int j=0;j<opArr.size();j++) {
+					if(p[i]==opArr.get(j)) {
+						long a = change(numArr.remove(j),numArr.remove(j),opArr.remove(j));
+						numArr.add(j,a);
+						j--;
+					}
+				}
+			}
+			
+			answer = Math.max(answer, Math.abs(numArr.get(0)));
+			
+			return;
+		}
+		
+		for(int i=0;i<3;i++) {
+			
+			if(!visited[i]) {
+				visited[i] = true;
+				p[i] = op[num];
+				dfs(p,num+1,visited);
+				visited[i] = false;
+			}
+			
+		}
+	}
+	
+	static void check(String expression) {
+		
+		String num = "";
+		
+		for(int i=0;i<expression.length();i++) {
+			
+			char ch = expression.charAt(i);
+			
+			if(ch>='0' && ch<='9') num += ch;
+			else {
+				numList.add(Long.parseLong(num));
+				num="";
+				opList.add(ch);
+			}
+			
+		}
+		
+		numList.add(Long.parseLong(num));
+	
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/targetNumber.java b/Basic_Of_Algorithm/src/Today_22_05_31/targetNumber.java
new file mode 100644
index 0000000..1d0edf6
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/targetNumber.java
@@ -0,0 +1,36 @@
+package Today_22_05_31;
+
+public class targetNumber {
+	
+	static int answer= 0;
+	static int tar;
+	public static void main(String[] args) {
+		
+		int[]numbers = {1,1,1,1,1};
+		int target = 3;
+		tar = target;
+		dfs(numbers,0,0);
+		
+		System.out.println(answer);
+		
+	}
+	
+	static void dfs(int[]numbers,int now,int count) {
+		
+		if(count==numbers.length) {
+			
+			if(tar==now) answer++;
+			
+			
+			return;
+		}
+		
+		
+		dfs(numbers,now + numbers[count],count+1);
+		dfs(numbers,now - numbers[count],count+1);
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/treeCut.java b/Basic_Of_Algorithm/src/Today_22_05_31/treeCut.java
new file mode 100644
index 0000000..d112dfc
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/treeCut.java
@@ -0,0 +1,37 @@
+package Today_22_05_31;
+
+import java.util.Collections;
+
+public class treeCut {
+
+	public static void main(String[] args) {
+		
+	int[]arr = {20,15,10,17};
+	int cut = 7;
+	
+	int min = 0;
+	int max = 0;
+	
+	for(int i : arr) if(max<i) max= i;
+	
+	while(min<max) {
+		
+		int mid = (max+min)/2;
+		
+		int count = 0;
+		
+		for(int i : arr) if(i-mid>0) count += i-mid;
+			
+		if(count>cut) min = mid+1;
+		else max = mid;
+		
+		
+		
+	}
+	
+	System.out.println(min);
+	
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_31/tuple.java b/Basic_Of_Algorithm/src/Today_22_05_31/tuple.java
new file mode 100644
index 0000000..ae995ca
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_31/tuple.java
@@ -0,0 +1,51 @@
+package Today_22_05_31;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+
+public class tuple {
+	
+	public static void main(String[] args) {
+		
+		String s = "{{4,2,3},{3},{2,3,4,1},{2,3}}";
+		
+		s = s.replaceAll("\\{", "");
+		s = s.replaceAll("\\}", "");
+		
+		
+		HashMap<Integer,Integer> map = new HashMap<>();
+		
+		String []temp = s.split(",");
+	
+		for(String str : temp) {
+			int num = Integer.parseInt(str);
+			map.put(num,map.getOrDefault(num, 0)+1);
+		}
+	
+		
+		ArrayList<Integer> answerList = new ArrayList<>(map.keySet());
+		
+		
+		Collections.sort(answerList, new Comparator<Integer>() {
+
+			@Override
+			public int compare(Integer o1, Integer o2) {
+				if(map.get(o1)==map.get(o2)) return map.get(o1)- map.get(o2);
+				else return map.get(o2)- map.get(o1);
+			}
+			
+		});
+		
+		
+		
+		int[]answer= new int[answerList.size()];
+		
+		for(int i=0;i<answer.length;i++)answer[i] = answerList.get(i);
+		
+		for(int i : answer)System.out.print(i+" , ");
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_02/arrow.java b/Basic_Of_Algorithm/src/Today_22_06_02/arrow.java
new file mode 100644
index 0000000..8206112
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_02/arrow.java
@@ -0,0 +1,91 @@
+package Today_22_06_02;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class arrow {
+
+	static int apeach[];
+	static int ryan[];
+	static int count;
+	static int maxvalue = 0;
+	static ArrayList<int[]> answerList = new ArrayList<>();
+	
+	public static void main(String[] args) {
+		
+		int[]info = {0,0,1,2,0,1,1,1,1,1,1};
+		int n = 9;
+		
+		apeach = info.clone();
+		count = n;
+		ryan = new int[info.length];
+		
+		dfs(0,0);
+		
+		int [] answer;
+		
+		if(answerList.isEmpty()) answer = new int[] {-1};
+		
+		else {
+			
+			Collections.sort(answerList,(o1,o2)->{
+				
+				for(int i=10;i>-1;i--) {
+					if(o1[i]!=o2[i]) return o2[i] - o1[i];
+				}
+				
+				return 0;
+				
+			});
+			
+			answer = new int[apeach.length];
+			
+			for(int i=0;i<apeach.length;i++) answer[i] = answerList.get(0)[i];
+			
+			
+			for(int i : answer)System.out.print(i+", ");
+		}
+		
+		
+		
+		
+		
+	}
+	static void dfs(int start, int arrow) {
+		
+		if(arrow==count) {
+			
+			int r = 0;
+			int a = 0;
+			
+			for(int i=0;i<11;i++) {
+				if(ryan[i]==0 && apeach[i]==0) continue;
+				
+				if(ryan[i]>apeach[i]) r += 10 - i;
+				else a += 10 - i;
+			}
+			
+			if(r>a) {
+				int diff = r - a;
+				if(diff>maxvalue) {
+					maxvalue = diff;
+					answerList.clear();
+					answerList.add(ryan.clone());
+					
+				}else if(diff==maxvalue) {
+					answerList.add(ryan.clone());
+				}
+			}
+			
+			return;
+		}
+				
+		
+		for(int i=0;i<11;i++) {
+			ryan[i]++;
+			dfs(i,arrow+1);
+			ryan[i]--;
+		}
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_02/coronaTest.java b/Basic_Of_Algorithm/src/Today_22_06_02/coronaTest.java
new file mode 100644
index 0000000..77a4024
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_02/coronaTest.java
@@ -0,0 +1,90 @@
+package Today_22_06_02;
+
+public class coronaTest {
+	
+	public static void main(String[] args) {
+		
+		String[][]places = {{"POOOP", "OXXOX", "OPXPX", "OOXOX", "POXXP"}, {"POOPX", "OXPXP", "PXXXO", "OXXXO", "OOOPP"}, {"PXOPX", "OXOXP", "OXPOX", "OXXOP", "PXPOX"}, {"OOOXX", "XOOOX", "OOOXX", "OXOOX", "OOOOO"}, {"PXPXP", "XPXPX", "PXPXP", "XPXPX", "PXPXP"}};
+		int []result = new int[places.length];
+	
+		for(int i=0;i<places.length;i++) {
+			
+			char[][]map = new char[places[0].length][places[0][0].length()];
+			
+			for(int j=0;j<places[i].length;j++) {
+				for(int k=0;k<places[j].length;k++) {
+					map[j][k] = places[i][j].charAt(k);
+				}
+			}
+			
+			result[i] = check(map);
+		}
+		
+		for(int i : result)System.out.println(i);
+		
+		
+	}
+	
+	static boolean isRight(char[][]map,int i,int j) {
+		
+		//상하좌우
+		int [][] move1 = {{-1,0},{1,0},{-1,0},{0,1}};
+		
+		for(int d=0;d<4;d++) {
+			int newI = i + move1[d][0];
+			int newJ = j + move1[d][1];
+			
+			if(newI<0||newJ<0||map.length-1<newI||map[0].length-1<newJ) continue;
+			
+			if(map[newI][newJ]=='P') return false;
+			
+		}
+		//대각선
+		int [][] move2 = {{1,1},{-1,1},{1,-1},{-1,-1}};
+		
+		for(int d=0;d<4;d++) {
+			int newI = i + move2[d][0];
+			int newJ = j + move2[d][1];
+			
+			if(newI<0||newJ<0||map.length-1<newI||map[0].length-1<newJ) continue;
+			
+			if(map[newI][newJ]=='P') {
+				if(!(map[newI][j]=='X' && map[i][newJ]=='X')) return false;
+			}
+		}
+		//맨해튼
+		int [][] move3 = {{-2,0},{2,0},{0,-2},{0,2}};
+		
+		for(int d=0;d<4;d++) {
+			int newI = i + move3[d][0];
+			int newJ = j + move3[d][1];
+			
+			if(newI<0||newJ<0||map.length-1<newI||map[0].length-1<newJ) continue;
+			if(map[newI][newJ]=='P') {
+				if(map[(newI+i)/2][(newJ+j)/2]!='X') return false;
+			}
+		}
+		
+		return true;
+	}
+	
+	static int check(char[][]map) {
+		
+		for(int i=0;i<map.length;i++) {
+			for(int j=0;j<map[0].length;j++) {
+				if(map[i][j]=='P') {
+					if(!isRight(map,i,j)) {
+						return 0;
+					}
+				}
+			}
+		}
+		
+		
+		
+		return 1;
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_02/delivery.java b/Basic_Of_Algorithm/src/Today_22_06_02/delivery.java
new file mode 100644
index 0000000..883546c
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_02/delivery.java
@@ -0,0 +1,80 @@
+package Today_22_06_02;
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class delivery {
+
+	public static void main(String[] args) {
+		
+	
+		int INF = 50001;
+		int n = 4;
+		
+		int[][]road = {{1,2,1},{1,3,5},{2,3,1},{2,4,2}};
+		int k = 2;
+		int answer = 0;
+		
+		int [][] map = new int[n+1][n+1];
+		
+		for(int i = 1 ; i <=n; i++) {
+			for(int j=1; j<=n ; j++) {
+				if(i==j) continue;
+				map[i][j] = INF; //무한대
+			}
+		}
+		
+		
+		for(int i=0;i<road.length;i++) {
+			int a = road[i][0];
+			int b = road[i][1];
+			int w = road[i][2];
+			//무한대 보다 작으면 간선의 정보 저장
+			if(map[a][b] > w) {
+				map[a][b] = w;
+				map[b][a] = w;
+			}
+			
+		}
+		
+		int [] dist = new int[n+1];
+		for(int i = 2; i <= n ; i++) {
+			dist[i] = INF;
+		}
+		
+		boolean[] visited = new boolean[n+1];
+		visited[1] = true;
+		
+		
+		for(int i=1; i <=n-1 ; i++) {
+			
+			int min_idx = 1;
+			int min_value = INF;
+			for(int j=2;j<=n;j++) {
+				if(!visited[j] && dist[j]<min_value) {
+					min_value = dist[j];
+					min_idx = j;
+				}
+			}
+			
+			visited[min_idx] = true;
+			
+			
+			for(int j = 2; j <= n ; j++) {
+				if(dist[j]>dist[min_idx] + map[min_idx][j]) {
+					dist[j] = dist[min_idx] + map[min_idx][j];
+				}
+			}
+			
+		}
+		
+		for(int i=1;i<=n;i++) {
+			if(dist[i]<=k) answer++;
+		}
+		
+		for(int i : dist)System.out.print(i+",");
+		System.out.println();
+		System.out.println(answer);
+	}
+	
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/Today_22_06_02/hanoi.java b/Basic_Of_Algorithm/src/Today_22_06_02/hanoi.java
new file mode 100644
index 0000000..408945d
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_02/hanoi.java
@@ -0,0 +1,34 @@
+package Today_22_06_02;
+
+public class hanoi {
+	
+	public static void main(String[] args) {
+		
+		int n = 4;
+		
+		int [] arr = {1,2,3};
+		
+		hanoi(arr[0],arr[1],arr[2],n);
+		
+		
+		//n개를 옮기는 문제는 n-1로 세분화되고 다시 n-1를 위해 1를 옮기는걸 세분화 시킨다
+		// a -> b (n-1)개 옮기기
+		// b - > c (n-1)개 옮기기
+		//n ==1 마지막에 남은거 옮기기
+		
+	}
+	
+	static void hanoi(int from, int by, int to,int n) {
+		
+		if(n==1) {
+			System.out.println(from + " - > " + to);
+			return;
+		}
+		
+		hanoi(from, to, by, n-1);
+		System.out.println(from + " - > " + to);
+		hanoi(by,from,to,n-1);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_02/openChatting.java b/Basic_Of_Algorithm/src/Today_22_06_02/openChatting.java
new file mode 100644
index 0000000..f46536f
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_02/openChatting.java
@@ -0,0 +1,57 @@
+package Today_22_06_02;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public class openChatting {
+	
+
+	
+	public static void main(String[] args) {
+		
+		String [] record = {"Enter uid1234 Muzi", "Enter uid4567 Prodo","Leave uid1234","Enter uid1234 Prodo","Change uid4567 Ryan"};
+		ArrayList<String> answerList = new ArrayList<>();
+		
+		HashMap<String,String>idMap = new HashMap<>();
+		
+		for(String str : record) {
+			
+			String []temp = str.split(" ");
+			
+			String action = temp[0];
+			String id = temp[1];
+			
+			if(action.equals("Leave")) continue;
+			
+			String nick = temp[2];
+			
+			idMap.put(id, nick);
+			
+			
+		}
+		
+		for(String str : record) {
+			
+			String []temp = str.split(" ");
+			
+			String action = temp[0];
+			if(action.equals("Change")) continue;
+			String id = temp[1];
+			String nick = idMap.get(id);
+			
+			String ans = nick+"님이 " + (action.equals("Enter") ? "들어왔습니다." : "나갔습니다.");
+			
+			answerList.add(ans);
+			
+		}
+		
+		String[]answer = new String[answerList.size()];
+		
+		for(int i=0;i<answer.length;i++) answer[i] = answerList.get(i);
+		
+		for(String str  : answer)System.out.println(str);
+		
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_02/test.java b/Basic_Of_Algorithm/src/Today_22_06_02/test.java
new file mode 100644
index 0000000..541446d
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_02/test.java
@@ -0,0 +1,92 @@
+package Today_22_06_02;
+
+import java.util.Arrays;
+
+public class test {
+
+	public static void main(String[] args) {
+		
+	
+		int n = 3;
+		int [][]road = {{1,2,1},{1,3,5},{2,3,1}};
+		int k = 2;
+		int answer = 0;
+		
+		int INF = 50001;
+		
+		int[][]map = new int[n+1][n+1];
+		
+		for(int i =0;i<map.length;i++) Arrays.fill(map[i], INF);
+		
+		for(int i=0;i<road.length;i++) {
+			int start = road[i][0];
+			int end = road[i][1];
+			int value = road[i][2];
+			
+			if(map[start][end] >value) {
+				map[start][end] = value;
+				map[end][start] = value;
+			}
+			
+		}
+		
+		
+		int[]dist = new int[n+1];
+		
+		boolean[]visited = new boolean[n+1];
+		
+		visited[1] = true;
+		
+		for(int i = 2 ;i<=n;i++) {
+			 dist[i] = (dist[i]==0) ? INF : map[1][i];
+		}
+		
+		for(int i : dist) System.out.print(i+",");
+		
+		System.out.println();
+		
+		for(int i=1;i<n;i++) {
+			
+			int min_value = INF;
+			int min_idx = 1;
+			
+			for(int j=2;j<=n;j++) {
+				
+				if(!visited[j] && dist[j] < min_value) {
+					
+					min_value = dist[j];
+					min_idx = j;
+				}
+				
+			}
+			
+			visited[min_idx] = true;
+			
+			for(int j=2;j<=n;j++) {
+				
+				if(dist[j] > dist[min_idx] + map[min_idx][j]) {
+					dist[j] = dist[min_idx] + map[min_idx][j];
+				}
+				
+			}
+			
+			
+			
+		}
+		
+		for(int i=1;i<=n;i++) {
+			if(dist[i]<=k)answer++;
+		}
+	
+		
+		System.out.println(answer);
+
+		for(int i : dist)System.out.print(i+",");
+		System.out.println();
+		for(boolean a : visited)System.out.print(a+",");
+		System.out.println();
+		
+	}
+	
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_03/deliveryAgain.java b/Basic_Of_Algorithm/src/Today_22_06_03/deliveryAgain.java
new file mode 100644
index 0000000..b626408
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_03/deliveryAgain.java
@@ -0,0 +1,84 @@
+package Today_22_06_03;
+
+public class deliveryAgain {
+
+	public static void main(String[] args) {
+		
+		
+		int n = 3;
+		
+		int [][]road = {{1,2,1},{1,3,5},{2,3,1}};
+		
+		int k = 2;
+		
+		int answer = 0;
+		
+		int [][] map = new int[n+1][n+1];
+		
+		int INF = 500001;
+		
+		for(int i=1;i<map.length;i++) {
+			for(int j = 1 ; j < map[0].length;j++) {
+				if(i==j)continue;
+				map[i][j] = INF;
+			}
+		}
+	
+		for(int i = 0 ; i < road.length;i++) {
+			int a = road[i][0];
+			int b = road[i][1];
+			int value = road[i][2];
+			
+			if(map[a][b] > value) {
+				map[a][b] = value;
+				map[b][a] = value;
+			}
+		}
+		
+		
+		int[]dist = new int[n+1];
+		
+		for(int i=2 ; i<dist.length;i++) {
+			dist[i] = INF;
+		}
+		
+		boolean[] visited=  new boolean[n+1];
+		
+		visited[1] = true;
+		
+		
+		for(int i = 1 ; i < n ; i ++) {
+			
+			
+			
+			int min_value = INF;
+			int min_idx = 1;
+			
+			for(int j=2;j<=n;j++) {
+				if(!visited[j] && dist[j] < min_value) {
+					min_value = dist[j];
+					min_idx = j;
+				}
+			}
+			
+			visited[min_idx] = true;
+			
+			
+			for(int j=2;j<=n;j++) {
+				if(dist[j] > dist[min_idx] + map[min_idx][j]) {
+					dist[j] = dist[min_idx] + map[min_idx][j];
+				}
+			}
+						
+		}
+		
+		for(int i = 1 ; i <dist.length;i++) {
+			if(dist[i]<=k)answer++;
+		}
+		
+		
+		System.out.println(answer);
+		
+		for(int i : dist)System.out.print(i+",");
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_03/dijikstra.java b/Basic_Of_Algorithm/src/Today_22_06_03/dijikstra.java
new file mode 100644
index 0000000..0336f96
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_03/dijikstra.java
@@ -0,0 +1,80 @@
+package Today_22_06_03;
+
+class graph{
+	
+	private int n ;
+	private int maps[][];
+	
+	public graph(int n) {
+		this.n = n;
+		maps = new int[n+1][n+1];
+	}
+	public void input(int i,int j,int w) {
+		maps[i][j] = w;
+		maps[j][i] = w;
+	}
+	public void dijikstra(int v) {
+		int distance[] = new int[n+1];
+		boolean[]check = new boolean[n+1];
+		
+		for(int i = 1; i < n+1; i++) {
+			distance[i] = Integer.MAX_VALUE;
+		}
+		distance[v] = 0;
+		check[v] = true;
+		
+		for(int i = 1; i < n+1;i++) {
+			if(!check[i] && maps[v][i] != 0) {
+				distance[i] = maps[v][i];
+			}
+		}
+		
+		for(int a = 0 ; a < n-1; a++) {
+			int min = Integer.MAX_VALUE;
+			int min_idx = 1;
+			
+			for(int i=1;i<n+1;i++) {
+				if(!check[i] && distance[i]!=Integer.MAX_VALUE) {
+					if(distance[i] < min) {
+						min = distance[i];
+						min_idx = i;
+					}
+				}
+			}
+			check[min_idx] = true;
+			for(int i = 1; i < n+1; i++) {
+				if(!check[i] && maps[min_idx][i]!=0) {
+					distance[i] = distance[min_idx]+maps[min_idx][i];
+				}
+			}
+		}
+		for(int i =1 ;i<n+1;i++) {
+			System.out.print(distance[i]+" ");
+		}
+		System.out.println((" "));
+	}
+	
+}
+
+public class dijikstra {
+
+	public static void main(String[] args) {
+		
+		graph g = new graph(8);
+		
+		g.input(1, 2, 3);
+		g.input(1, 5, 4);
+		g.input(1, 4, 4);
+		g.input(2, 3, 2);
+		g.input(3, 4, 1);
+		g.input(4, 5, 2);
+		g.input(5, 6, 4); 
+		g.input(4, 7, 6);
+		g.input(7, 6, 3);
+		g.input(3, 8, 3);
+		g.input(6, 8, 2);
+		g.dijikstra(1);
+	
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_08/gameMapQueue.java b/Basic_Of_Algorithm/src/Today_22_06_08/gameMapQueue.java
new file mode 100644
index 0000000..e9993bc
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_08/gameMapQueue.java
@@ -0,0 +1,52 @@
+package Today_22_06_08;
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class gameMapQueue {
+
+	public static void main(String[] args) {
+		
+		int[][]maps = {{1,0,1,1,1},{1,0,1,0,1},{1,0,1,1,1},{1,1,1,0,1},{0,0,0,0,1}};
+		
+		int[][]move = {{0,1},{1,0},{0,-1},{-1,0}};
+		
+		int answer = 0;
+		
+		int[][]temp = new int[maps.length][maps.length];
+		
+		temp[0][0] = 1;
+		
+		Queue<int []> q = new LinkedList<>();
+		
+		q.add(new int[] {0,0});
+		
+		while(!q.isEmpty()) {
+			
+			int[]cur = q.poll();
+			
+			int i = cur[0];
+			int j = cur[1];
+			
+			for(int d=0;d<4;d++) {
+				
+				int newI = move[d][0] + i;
+				int newJ = move[d][1] + j;
+				
+				if(newI<0||newJ<0||maps.length-1<newI||maps[0].length-1<newJ) continue;
+				
+				if(temp[newI][newJ]==0 && maps[newI][newJ]==1) {
+					temp[newI][newJ] = temp[i][j] +1;
+					q.add(new int[] {newI,newJ});
+					
+				}
+				
+			}
+		}
+		
+		answer = temp[maps.length-1][maps[0].length-1];
+		
+		System.out.println(answer);
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_08/menuRenewal.java b/Basic_Of_Algorithm/src/Today_22_06_08/menuRenewal.java
new file mode 100644
index 0000000..5a16bf3
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_08/menuRenewal.java
@@ -0,0 +1,73 @@
+package Today_22_06_08;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Arrays;
+
+public class menuRenewal {
+
+	static HashMap<String,Integer> map = new HashMap<>();
+	static ArrayList<String> answerList = new ArrayList<>();
+	public static void main(String[] args) {
+		
+		String []orders = {"ABCFG", "AC", "CDE", "ACDE", "BCFG", "ACDEH"};
+		int []course = {2,3,4};
+		
+		for(int i=0;i<orders.length;i++) {
+			
+			char[]temp = orders[i].toCharArray();
+			Arrays.sort(temp);
+			orders[i] = String.valueOf(temp);
+			
+		}
+		
+		for(int c : course) {
+			for(String order : orders) {
+				
+				dfs(c,order,"");
+			}
+			
+			
+			if(!map.isEmpty()) {
+				ArrayList<Integer> maxList = new ArrayList<>(map.values());
+				int max = Collections.max(maxList);
+				if(max>1) {
+					for(String key : map.keySet()) {
+						if(map.get(key)==max) {
+							answerList.add(key);
+						}
+					}
+				}
+			}
+			
+			map.clear();
+		}
+		
+		
+		String[]answer = new String[answerList.size()];
+		
+		Collections.sort(answerList);
+		
+		for(int i=0;i<answerList.size();i++) answer[i] = answerList.get(i);
+		
+		for(String str : answer) System.out.print(str +", ");
+		
+		
+		
+	}
+	
+	static void dfs(int c,String order,String now) {
+		
+		if(c==0) {
+			if(!map.containsKey(now)) {
+				map.put(now, 0);
+			}
+			map.put(now,map.get(now)+1);
+			return;
+		}
+		
+		for(int i=0;i<order.length();i++) dfs(c-1,order.substring(i+1),now+order.charAt(i));
+	
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_08/stringApchuck.java b/Basic_Of_Algorithm/src/Today_22_06_08/stringApchuck.java
new file mode 100644
index 0000000..2815551
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_08/stringApchuck.java
@@ -0,0 +1,56 @@
+package Today_22_06_08;
+
+public class stringApchuck {
+
+	public static void main(String[] args) {
+		
+		String s = "xababcdcdababcdcd";
+		
+		int answer = Integer.MAX_VALUE ;
+		
+		for(int i=1;i<=s.length()/2;i++) {
+			
+			String result = "";
+			String now = "";
+			String next = "";
+			int hit = 1;
+			
+			for(int j=0;j<=s.length()/i;j++) {
+				
+				int start = i * j;
+				int end = i * (j+1) < s.length() ? i * (j+1) : s.length();
+				
+				next = s.substring(start,end);
+				
+				if(now.equals(next)) {
+					hit++;
+				}else {
+					result += hitProess(hit) + now;
+					hit = 1;
+				}
+				
+				
+				now = next;
+				
+			}
+			
+			result += hitProess(hit) + now;
+
+			answer = Math.min(answer, result.length());
+			
+			System.out.println(result+" -> " +result.length());
+			
+			
+		}
+		
+		if(answer==Integer.MAX_VALUE) answer=1;
+		
+		System.out.println(answer);
+		
+		
+		
+	}
+	static String hitProess(int hit) {
+		return hit>1 ? String.valueOf(hit) : "";
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_09/no_1.java b/Basic_Of_Algorithm/src/Today_22_06_09/no_1.java
new file mode 100644
index 0000000..35d3f24
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_09/no_1.java
@@ -0,0 +1,97 @@
+package Today_22_06_09;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class no_1 {
+
+	static int[]apeach;
+	static int[]ryan;
+	static boolean[]visited = new boolean[3];
+	static char[]op = {'*','+','-'};
+	static int max = 0;
+	static int N;
+	static ArrayList<int[]> answerList = new ArrayList<>();
+	
+	public static void main(String[] args) {
+		
+		int[] info = {2,1,1,1,0,0,0,0,0,0,0};
+		int n = 5;
+		
+		N = n;
+		apeach = info.clone();
+		
+		ryan = new int[apeach.length];
+		
+		dfs(0,0);
+		
+		int[]answer;
+		
+		if(answerList.isEmpty()) {
+			answer = new int [] {-1};
+		}else {
+			
+			Collections.sort(answerList,(o1,o2)-> {
+				
+				for(int i=10;i>-1;i--) {
+					if(o1[i]!=o2[i]) return o1[i]-o2[i];
+				}
+				
+				return 0;
+			});
+			
+	
+			answer = new int[apeach.length];
+		
+			for(int i=0;i<answer.length;i++)answer[i] = answerList.get(0)[i];
+			
+		}
+		
+		for(int i : answer)System.out.print(i+",");
+		
+	}
+	
+	
+	
+	
+	static void dfs(int start,int count) {
+		
+		if(count==N) {
+			
+			int r = 0;
+			int a = 0;
+			
+			for(int i=0;i<11;i++) {
+				if(ryan[i]==0 && apeach[i]==0) continue;
+				
+				if(ryan[i]>apeach[i]) r += 10-i;
+				else a += 10-i;
+				
+			}
+			
+			if(r>a) {
+				int diff = r - a;
+				if(diff>max) {
+					max = diff;
+					answerList.clear();
+					answerList.add(ryan.clone());
+				}else if(diff==max) {
+					answerList.add(ryan.clone());
+				}
+			}
+			
+			
+			return;
+		}
+		
+		
+		
+		for(int i=0;i<11;i++) {
+			ryan[i]++;
+			dfs(i,count+1);
+			ryan[i]--;
+			
+		}
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_09/no_2.java b/Basic_Of_Algorithm/src/Today_22_06_09/no_2.java
new file mode 100644
index 0000000..34f9387
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_09/no_2.java
@@ -0,0 +1,72 @@
+package Today_22_06_09;
+
+public class no_2 {
+	
+	static char[]member = {'A','C','F','J','M','N','R','T'};
+	static int answer = 0;
+	static boolean[ ] visited;
+	static String[]d;
+	
+	public static void main(String[] args) {
+		
+		int n = 2;
+		
+		String[]data = {"N~F=0", "R~T>2"};
+		
+		d = data.clone();
+		
+		visited = new boolean[member.length];
+		
+		dfs("");
+		
+		System.out.println(answer);
+		
+	}
+	
+	static boolean check(String now) {
+		
+		for(String str : d) {
+			
+			int pos1 = now.indexOf(str.charAt(0));
+			int pos2 = now.indexOf(str.charAt(2));
+			char op = str.charAt(3);
+			int idx = str.charAt(4)-'0';
+			
+			if(op=='=') {
+				if(!(Math.abs(pos1-pos2)==idx+1)) return false;
+			}else if(op=='>') {
+				if(!(Math.abs(pos1-pos2)>idx+1)) return false;
+			}else if(op=='=') {
+				if(!(Math.abs(pos1-pos2)<idx+1)) return false;
+			}
+			
+		}
+		
+
+		return true;
+		
+		
+	}
+	
+	static void dfs(String now) {
+		
+		if(now.length()==member.length) {
+			if(check(now)) answer++;
+			
+			
+			return;
+		}
+		
+		
+		for(int i=0;i<member.length;i++) {
+			if(!visited[i]) {
+				visited[i]= true;
+				String next = now + member[i];
+				dfs(next);
+				visited[i] = false;
+			}
+		}
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_28/bfs.java b/Basic_Of_Algorithm/src/Today_22_06_28/bfs.java
new file mode 100644
index 0000000..734d805
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_28/bfs.java
@@ -0,0 +1,51 @@
+package Today_22_06_28;
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class bfs {
+
+	public static void main(String[] args) {
+		
+		int[][]maps = {{1,0,1,1,1},{1,0,1,0,1},{1,0,1,1,1},{1,1,1,0,1},{0,0,0,0,1}};
+		
+		int [][] temp = new int[maps.length][maps[0].length];
+		
+		int answer;
+		
+		temp[0][0] = 1;
+		
+		Queue<int[]> bfs = new LinkedList<>();
+		
+		bfs.add(new int[] {0,0});
+		
+		int [][]move = {{1,0},{0,1},{-1,0},{0,-1}};
+		
+		while(!bfs.isEmpty()) {
+			
+			int[]cur = bfs.poll();
+			
+			int i = cur[0];
+			int j = cur[1];
+			
+			for(int d=0;d<4;d++) {
+				int newI = i + move[d][0];
+				int newJ = j + move[d][1];
+				
+				if(newI<0||newJ<0||maps.length-1<newI||maps[0].length-1<newJ) continue;
+				
+				if(maps[newI][newJ]==1 && temp[newI][newJ] ==0) {
+					temp[newI][newJ] = temp[i][j] + 1;
+					bfs.add(new int[] {newI,newJ});
+				}
+				
+			}
+			
+			
+		}
+		
+		answer = temp[maps.length-1][maps[0].length-1];
+		
+		System.out.println(answer);
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_06_28/dfs.java b/Basic_Of_Algorithm/src/Today_22_06_28/dfs.java
new file mode 100644
index 0000000..fa26561
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_06_28/dfs.java
@@ -0,0 +1,68 @@
+package Today_22_06_28;
+
+public class dfs {
+	
+	static int answer = 0;
+	static char [] member = {'A', 'C', 'F', 'J', 'M', 'N', 'R', 'T'};
+	static boolean[] visited = new boolean[member.length];
+	static String[]dataSample;
+	
+	public static void main(String[] args) {
+		
+		int n = 2;
+		String []data = {"N~F=0", "R~T>2"};
+		
+		dataSample = data.clone();
+		
+		dfs("");
+		
+		System.out.println(answer);
+		
+	}
+	static boolean check(String now) {
+		
+		for(String d : dataSample) {
+			
+			int pos1 = now.indexOf(d.charAt(0));
+			int pos2 = now.indexOf(d.charAt(2));
+			char op = d.charAt(3);
+			int idx = (d.charAt(4) - '0') +  1;
+			
+			if(op=='=') {
+				if(!(Math.abs(pos1-pos2)==idx)) return false;
+			}else 	if(op=='>') {
+				if(!(Math.abs(pos1-pos2)>idx)) return false;
+			}else 	if(op=='<') {
+				if(!(Math.abs(pos1-pos2)<idx)) return false;
+			}
+			
+			
+		}
+		
+		
+		
+		return true;
+		
+		
+	}
+	
+	static void dfs(String now) {
+		
+		if(now.length()==member.length) {
+			if(check(now)) answer++;
+		}
+		
+		for(int i=0;i<visited.length;i++) {
+			if(!visited[i]) {
+				visited[i] = true;
+				String newOne = now + member[i];
+				dfs(newOne);
+				visited[i] = false;
+			}
+		}
+		
+		
+	}
+
+
+}
diff --git a/Basic_Of_Algorithm/src/interestingAlgorithm/Collatz_Graph.java b/Basic_Of_Algorithm/src/interestingAlgorithm/Collatz_Graph.java
new file mode 100644
index 0000000..2291b9a
--- /dev/null
+++ b/Basic_Of_Algorithm/src/interestingAlgorithm/Collatz_Graph.java
@@ -0,0 +1,31 @@
+package interestingAlgorithm;
+
+import java.util.Scanner;
+
+public class Collatz_Graph {
+
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		int n = scan.nextInt();
+		
+		
+		while(n!=1) {
+			
+			if(n%2==0) n /=2;
+			else n = (n*3) + 1;
+			
+			for(int i =0;i<n;i++) {
+				System.out.print("0");
+			}
+			
+			System.out.println();
+			
+			
+		}
+	
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/interestingAlgorithm/HashMapTest.java b/Basic_Of_Algorithm/src/interestingAlgorithm/HashMapTest.java
new file mode 100644
index 0000000..9d3a36c
--- /dev/null
+++ b/Basic_Of_Algorithm/src/interestingAlgorithm/HashMapTest.java
@@ -0,0 +1,62 @@
+package interestingAlgorithm;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+
+public class HashMapTest {
+
+	public static void main(String[] args) {
+		
+		
+		String [] record = {"Enter uid1234 Muzi", "Enter uid4567 Prodo","Leave uid1234","Enter uid1234 Prodo","Change uid4567 Ryan"};
+		String []answer;
+		
+		
+		HashMap<String,String>user = new HashMap<>();
+		
+		
+		for(String str : record) {
+			
+			String[]temp = str.split(" ");
+			
+			String action =temp[0];
+			String id = temp[1];
+			
+			if(action.equals("Leave"))continue;
+			
+			user.put(id, temp[2]);
+			
+			
+		}
+		
+		ArrayList<String>answerList = new ArrayList<>();
+		
+		for(String str : record) {
+			
+			String[]temp = str.split(" ");
+			
+			String action = temp[0];
+			String id = temp[1];
+			
+			if(action.equals("Change"))continue;
+			
+			String nick = user.get(id);
+			
+			String ans = nick +"님이 " + (action.equals("Enter") ? "들어왔습니다." :  "나갔습니다.");
+			
+			answerList.add(ans);
+			
+			
+		}
+		
+		
+		answer = new String[answerList.size()];
+		
+		for(int i=0;i<answerList.size();i++) answer[i] = answerList.get(i);
+		
+		for(String str : answer) System.out.println(str);
+		
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/interestingAlgorithm/arrTest.java b/Basic_Of_Algorithm/src/interestingAlgorithm/arrTest.java
new file mode 100644
index 0000000..1dcc3b4
--- /dev/null
+++ b/Basic_Of_Algorithm/src/interestingAlgorithm/arrTest.java
@@ -0,0 +1,25 @@
+package interestingAlgorithm;
+
+import java.util.Arrays;
+
+public class arrTest {
+
+	public static void main(String[] args) {
+		
+		
+		int[]arr = {1,2,3,4,5};
+		
+		int[]scores;
+		
+		scores = arr;
+		
+		scores[0] = 1320;
+		
+		System.out.println(Arrays.toString(arr));
+		System.out.println(Arrays.toString(scores));
+		
+		
+		//주소값을 복사하는 shallow copy는 copy한 영역을 조정해도 원래값도 바뀜 ㅠ
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/interestingAlgorithm/bruthForce_backjoon.java b/Basic_Of_Algorithm/src/interestingAlgorithm/bruthForce_backjoon.java
new file mode 100644
index 0000000..a4bb9ee
--- /dev/null
+++ b/Basic_Of_Algorithm/src/interestingAlgorithm/bruthForce_backjoon.java
@@ -0,0 +1,69 @@
+package interestingAlgorithm;
+
+
+public class bruthForce_backjoon {
+
+	static int normal = 0;
+	static boolean visited[][];
+
+	public static void main(String[] args) {
+		
+	String []temp =	{"RRRBB",
+					 "GGBBB",
+					 "BBBRR",
+					 "BBRRR",
+					 "RRRRR"};
+	
+	char[][]map = new char[temp.length][temp[0].length()];
+	
+	
+	for(int i=0;i<map.length;i++) {
+		for(int j=0;j<map[0].length;j++) {
+			map[i][j] = temp[i].charAt(j);
+		}
+	}
+	
+	visited = new boolean[map.length][map[0].length];
+	
+	for(int i=0;i<map.length;i++) {
+		for(int j=0;j<map[0].length;j++) {
+			if(!visited[i][j]) {
+				dfs(map,i,j);
+				normal++;
+			}
+		}
+		
+	}
+	
+	
+	
+	dfs(map,0,0);
+	
+	System.out.println(normal);
+	
+	}
+	static void dfs(char[][]map,int i,int j){
+		
+		visited[i][j] = true;
+		int[][]move = {{0,1},{1,0},{0,-1},{-1,0}};
+		
+		for(int d=0;d<4;d++) {
+			int newI = i + move[d][0];
+			int newJ = j + move[d][1];
+			
+			if(newI<0||newJ<0||map.length-1<newI||map[0].length-1<newJ) continue;
+			
+			if(!visited[newI][newJ] && map[newI][newJ]==map[i][j]) {
+				dfs(map,newI,newJ);
+			}
+			
+			
+		}
+		
+		
+		
+		
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/interestingAlgorithm/collatz_conjecture.java b/Basic_Of_Algorithm/src/interestingAlgorithm/collatz_conjecture.java
new file mode 100644
index 0000000..af7217b
--- /dev/null
+++ b/Basic_Of_Algorithm/src/interestingAlgorithm/collatz_conjecture.java
@@ -0,0 +1,21 @@
+package interestingAlgorithm;
+
+public class collatz_conjecture {
+
+	public static void main(String[] args) {
+		
+		int n = 6;
+		int answer = 0;
+		
+		while(true) {
+			
+			if(n%2==0) n /= 2;
+			else n = (n*3) + 1;
+			
+			answer++;
+			
+			System.out.println(n);
+		}
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/interestingAlgorithm/dfs.java b/Basic_Of_Algorithm/src/interestingAlgorithm/dfs.java
new file mode 100644
index 0000000..096c5f6
--- /dev/null
+++ b/Basic_Of_Algorithm/src/interestingAlgorithm/dfs.java
@@ -0,0 +1,38 @@
+package interestingAlgorithm;
+
+public class dfs {
+	
+	public static void main(String[] args) {
+		
+		int[]arr = {1,2,3};
+		
+		boolean[]visited = new boolean[arr.length];
+		
+		dfs(arr,0,"",visited);
+		
+		
+	}
+	
+	static void dfs(int[]arr,int count,String now,boolean[]visited) {
+		
+		if(count==arr.length) {
+			System.out.println(now);
+			return;
+		}
+		
+		for(int i=0;i<arr.length;i++) {
+			if(!visited[i]) {
+				visited[i] = true;
+				String newOne = now + arr[i];
+				dfs(arr,count+1,newOne,visited);
+				visited[i] = false;
+			}
+		}
+		
+		
+		
+		
+	}
+	
+
+}
diff --git a/Basic_Of_Algorithm/src/interestingAlgorithm/interesting.java b/Basic_Of_Algorithm/src/interestingAlgorithm/interesting.java
new file mode 100644
index 0000000..56c5d1f
--- /dev/null
+++ b/Basic_Of_Algorithm/src/interestingAlgorithm/interesting.java
@@ -0,0 +1,10 @@
+package interestingAlgorithm;
+
+public class interesting {
+	
+	public static void main(String[] args) {
+		
+		System.out.println("yes");
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_01/crain.java b/Basic_Of_Algorithm/src/programmers_level_01/crain.java
new file mode 100644
index 0000000..f43b4c5
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_01/crain.java
@@ -0,0 +1,56 @@
+package programmers_level_01;
+
+import java.util.Stack;
+
+public class crain {
+	
+	public static void main(String[] args) {
+		
+		int[][] board = {{0,0,0,0,0},{0,0,1,0,3},{0,2,5,0,1},{4,2,4,4,2},{3,5,1,3,1}};
+		int [] moves = {1,5,3,5,1,2,1,4};
+		
+		int answer = 0;
+		
+		Stack<Integer> stack = new Stack<>();
+		
+		
+		for(int mov : moves) {
+			
+			mov--;
+			
+			for(int i=0;i<board.length;i++) {
+				
+				if(board[i][mov]!=0) {
+					if(stack.isEmpty()) {
+						stack.add(board[i][mov]);
+						board[i][mov] = 0;
+						break;
+					}
+					else {
+						if(stack.peek()==board[i][mov]) {
+							stack.pop();
+							answer++;
+						}else {
+							stack.add(board[i][mov]);
+						}
+						board[i][mov] = 0;
+						break;
+					}
+					
+				}
+				
+			}
+			
+			
+		}
+		
+		
+		
+		System.out.println(answer*2);
+		
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_01/no_1.java b/Basic_Of_Algorithm/src/programmers_level_01/no_1.java
new file mode 100644
index 0000000..98b3f78
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_01/no_1.java
@@ -0,0 +1,69 @@
+package programmers_level_01;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Set;
+public class no_1 {
+	
+	public static void main(String[] args) {
+		
+		String[]id_list = {"muzi", "frodo", "apeach", "neo"};
+		String [] report = {"muzi frodo","apeach frodo","frodo neo","muzi neo","apeach muzi"};
+		int k = 2;
+		
+		//나를 신고한 사람 리스트를 뽑음
+		//그 사이즈가 2 이상이면
+		//나를 신고한 사람한테 +1
+		
+		int[]result = new int[id_list.length];
+		
+		HashMap<String,Set<String>> singoList = new HashMap<>();
+		//나를 신고한 사람 리스트
+		HashMap<String,Integer> myList = new HashMap<>();
+		//내가 받을 매일 횟수
+		
+		for(int i=0;i<id_list.length;i++) {
+			singoList.put(id_list[i], new HashSet<>());
+			myList.put(id_list[i], 0);
+		}
+		
+		for(int i=0;i<report.length;i++) {
+			String[]temp = report[i].split(" ");
+			
+			String attack = temp[0];
+			String taker = temp[1];	
+			singoList.get(taker).add(attack);
+		
+			
+		}
+		
+		System.out.println(singoList);
+		
+		for(String key : singoList.keySet()) {
+			
+			if(singoList.get(key).size()>=k) {
+				
+				System.out.println(singoList.get(key));
+				
+				for(String str : singoList.get(key)) {
+					
+					myList.put(str, myList.get(str)+1);
+					
+					
+				}
+			}
+			
+		}
+		
+		for(int i=0;i<id_list.length;i++) {
+			
+			result[i] = myList.get(id_list[i]);
+			
+		}
+		
+		
+		for(int i : result)System.out.println(i);
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_01/no_2.java b/Basic_Of_Algorithm/src/programmers_level_01/no_2.java
new file mode 100644
index 0000000..aaa028c
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_01/no_2.java
@@ -0,0 +1,30 @@
+package programmers_level_01;
+
+public class no_2 {
+
+	public static void main(String[] args) {
+		
+	String new_id = "...!@BaT#*..y.abcdefghijklm";
+	
+	new_id = new_id.toLowerCase();
+	new_id = new_id.replaceAll("[^a-z1-9-_.]", "");
+	new_id = new_id.replaceAll("[.]{2,}", ".");
+	new_id = new_id.replaceAll("^[.]|[x]$", "");
+	
+	if(new_id.isEmpty())new_id ="a";
+	
+	if(new_id.length()>15) {
+		new_id = new_id.substring(0,15);
+		new_id = new_id.replaceAll("[.]$", "");
+	}
+	
+	if(new_id.length()<3) {
+		while(new_id.length()<3) {
+			new_id += new_id.charAt(new_id.length()-1);
+		}
+	}
+	
+	System.out.println(new_id);
+	
+	}
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_01/no_3.java b/Basic_Of_Algorithm/src/programmers_level_01/no_3.java
new file mode 100644
index 0000000..3b15d80
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_01/no_3.java
@@ -0,0 +1,22 @@
+package programmers_level_01;
+
+public class no_3 {
+	
+	public static void main(String[] args) {
+		
+		String s = "one4seveneight";
+		int answer = 0;
+		
+		String [] alpha = {"zero","one","two","three","four","five","six","seven","eight","nine"};
+		
+		
+		for(int i=0;i<alpha.length;i++) s = s.replaceAll(alpha[i], String.valueOf(i));
+			
+		answer = Integer.valueOf(s);
+		
+		
+		System.out.println(answer);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_01/no_4.java b/Basic_Of_Algorithm/src/programmers_level_01/no_4.java
new file mode 100644
index 0000000..764ff2d
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_01/no_4.java
@@ -0,0 +1,54 @@
+package programmers_level_01;
+
+import java.util.Stack;
+
+public class no_4 {
+
+	public static void main(String[] args) {
+		
+		
+		int[][]board = {{0,0,0,0,0},{0,0,1,0,3},{0,2,5,0,1},{4,2,4,4,2},{3,5,1,3,1}};
+		
+		int [] moves = {1,5,3,5,1,2,1,4};
+		
+		int answer = 0;
+		
+		Stack<Integer> stack = new Stack<>();
+		
+		for(int i=0;i<moves.length;i++) {
+			
+			int move = moves[i]-1;
+			
+			
+			for(int i2 = 0; i2 <board.length;i2++) {
+				
+				if(board[i2][move]!=0) {
+					
+					if(stack.isEmpty()) {
+						stack.add(board[i2][move]);
+						board[i2][move]=0;
+						break;
+					}
+					else {
+						if(stack.peek()==board[i2][move]) {
+							stack.pop();
+							answer ++;
+							board[i2][move]=0;
+							break;
+						}
+					}
+					
+					
+				
+				}
+				
+				
+				
+			}
+			
+		}
+		
+		System.out.println(answer*2);
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_01/no_5.java b/Basic_Of_Algorithm/src/programmers_level_01/no_5.java
new file mode 100644
index 0000000..f1d60b5
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_01/no_5.java
@@ -0,0 +1,45 @@
+package programmers_level_01;
+
+import java.util.*;
+
+public class no_5 {
+
+	public static void main(String[] args) {
+		
+		int n = 5;
+		int []stages = {2,1,2,6,2,4,3,3};
+		
+		int []answer = new int[n];
+		
+		double users = stages.length;
+		
+		List<double[]> fail_rate = new ArrayList<>();
+		
+		int cnt = 0;
+		
+		for(int i=1;i<=n;i++) {
+			for(int j=0;j<stages.length;j++) {
+				if(i==stages[j]) {
+					cnt++;
+				}
+			}
+			if(cnt==0) {
+				fail_rate.add(new double[] {i,0});
+				continue;
+				
+			}
+			fail_rate.add(new double[] {i,cnt/users});
+			users -= cnt;
+			cnt =0;
+		}
+		
+		fail_rate.sort((a,b)->Double.compare(b[1], a[1]));
+		
+		for(int i=0;i<fail_rate.size();i++) {
+			answer[i] = (int)fail_rate.get(i)[0];
+		}
+		
+		for(int i : answer)System.out.println(i);
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_01/no_6.java b/Basic_Of_Algorithm/src/programmers_level_01/no_6.java
new file mode 100644
index 0000000..fb0fd40
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_01/no_6.java
@@ -0,0 +1,52 @@
+package programmers_level_01;
+
+public class no_6 {
+	
+	public static void main(String[] args) {
+		
+		int n = 5;
+		
+		int[]arr1 = {9,20,28,18,11};
+		int[]arr2 = {30,1,21,17,28};
+		
+		String[]answer = new String[arr1.length];
+		
+		for(int i=0;i<answer.length;i++) {
+			
+			String temp = "";
+			
+			int a = arr1[i];
+			int b = arr2[i];
+			
+			String str1 = Integer.toBinaryString(a);
+			String str2 = Integer.toBinaryString(b);
+			
+			if(str1.length()<n) {
+				while(str1.length()<n) {
+					str1 = "0"+str1;
+				}
+			}
+			if(str2.length()<n) {
+				while(str2.length()<n) {
+					str2 = "0"+str2;
+				}
+			}
+			
+			for(int j=0;j<str1.length();j++) {
+				boolean flag = false;
+				if(str1.charAt(j)=='1'||str2.charAt(j)=='1') {
+					temp += "#";
+					flag = true;
+					continue;
+				}
+				if(!flag) temp += " ";
+				
+			}
+			
+			System.out.println(temp);
+		}
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_01/no_7.java b/Basic_Of_Algorithm/src/programmers_level_01/no_7.java
new file mode 100644
index 0000000..8835fbf
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_01/no_7.java
@@ -0,0 +1,68 @@
+package programmers_level_01;
+
+public class no_7 {
+	
+	public static void main(String[] args) {
+		
+		
+		String dartResult = "1S2D*3T";
+		
+		int answer = 0;
+		
+		//숫자가 나오면 넣어주면 되겠네
+		
+		int[]temp = new int[3];
+		
+		int idx = -1;
+		
+		for(int i=0;i<dartResult.length();i++) {
+			
+			String str = ""+dartResult.charAt(i);
+			
+			if(str.equals("1")&&i<dartResult.length()-1) {
+				if(dartResult.charAt(i+1)=='0') {
+					str = "10";
+				}
+			}
+			
+			if(str.equals("0") && i!=0) {
+				if(dartResult.charAt(i-1)=='1') continue;
+			}
+			
+			
+			switch (str) {
+			case "S": temp[idx] =(int)Math.pow(temp[idx], 1);
+				
+				break;
+			case "D": temp[idx] =(int)Math.pow(temp[idx], 2);
+				
+				break;
+			case "T": temp[idx] =(int)Math.pow(temp[idx], 3);
+				
+				break;
+			case "*": if(idx!=0)  temp[idx-1] *= 2;
+			 		  temp[idx] *= 2;
+				break;
+			case "#":  temp[idx] *= -1;
+				
+				break;
+			
+			default: idx++;
+					 temp[idx] = Integer.valueOf(str);
+					 
+				break;
+			}
+			
+			
+			
+		}
+		
+		for(int i=0;i<3;i++) {
+			System.out.println(temp[i]);
+			answer += temp[i];
+		}
+		
+		System.out.println(answer);		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/change.java b/Basic_Of_Algorithm/src/programmers_level_2/change.java
new file mode 100644
index 0000000..8c146d9
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/change.java
@@ -0,0 +1,38 @@
+package programmers_level_2;
+
+import java.util.*;
+
+public class change {
+
+	public static void main(String[] args) {
+		
+	String [][] clothes = {{"yellowhat", "headgear"}, {"bluesunglasses", "eyewear"}, {"green_turban", "headgear"}};	
+	int answer = 1;
+	
+	HashMap<String,ArrayList<String>> map = new HashMap<>();
+	
+	for(int i=0;i<clothes.length;i++) {
+		
+		String first = clothes[i][0];
+		String second = clothes[i][1];
+		
+		if(!map.containsKey(second)) map.put(second, new ArrayList<>());
+		
+		map.get(second).add(first);
+		
+	}
+	
+	
+	
+	for(String key : map.keySet()) {
+		
+		answer *= map.get(key).size()+1;
+	}
+	
+	
+	
+	System.out.println(answer-1);
+	
+	
+	}
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_1.java b/Basic_Of_Algorithm/src/programmers_level_2/no_1.java
new file mode 100644
index 0000000..375b4a4
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_1.java
@@ -0,0 +1,53 @@
+package programmers_level_2;
+
+public class no_1 {
+	
+	public static void main(String[] args) {
+		
+		String s ="abcabcabcabcdededededede";	
+		
+		int answer = Integer.MAX_VALUE;
+		
+		for(int i=1;i<=s.length()/2;i++) {
+				
+			String now = "",next = "";
+			String result = "";
+			int hit = 1;
+			for(int j=0;j<=s.length()/i;j++) {
+				
+				int start = j * i;
+				int end = i * (j+1) > s.length() ? s.length() : i  * (j+1);
+				
+				now = next;
+				next = s.substring(start,end);
+				
+				if(now.equals(next)) {
+					hit++;
+				}else {
+					result += processHit(hit) + now;
+					hit = 1;
+				}
+				
+				
+				
+				
+			}
+			
+			result += processHit(hit) + next;
+			
+			System.out.println(result);
+			
+			answer = Math.min(answer, result.length());
+		}
+		
+		
+		System.out.println(answer);
+		
+		
+		
+	}
+	static String processHit(int hit) {
+		return hit > 1 ? String.valueOf(hit) : "";
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_10.java b/Basic_Of_Algorithm/src/programmers_level_2/no_10.java
new file mode 100644
index 0000000..ee3fd67
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_10.java
@@ -0,0 +1,55 @@
+package programmers_level_2;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+
+public class no_10 {
+	
+	public static void main(String[] args) {
+		
+		
+		String [] record = {"Enter uid1234 Muzi", "Enter uid4567 Prodo","Leave uid1234","Enter uid1234 Prodo","Change uid4567 Ryan"};
+		
+		HashMap<String,String> map = new HashMap<>();
+		ArrayList<String> answerList = new ArrayList<>();
+		
+		for(String str : record) {
+			
+			String temp[] = str.split(" ");
+			String action = temp[0];
+			String id = temp[1];
+			
+			if(action.equals("Leave")) continue;
+			
+			String nick = temp[2];
+			
+			map.put(id, nick);
+			
+		}
+		
+		for(String str : record) {
+			
+			String temp[] = str.split(" ");
+			String action = temp[0];
+			String id = temp[1];
+			
+			if(action.equals("Change")) continue;
+			
+			String nick = map.get(id);
+			String ans = nick + "님이 " + (action.equals("Enter") ? "들어왔습니다." : "나갔습니다.");
+			
+			answerList.add(ans);
+		
+		}
+		
+		
+		String[]answer = new String[answerList.size()];
+		
+		for(int i = 0 ; i< answerList.size();i++) answer[i] = answerList.get(i);
+		
+		for(String str : answer)System.out.println(str);
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_11.java b/Basic_Of_Algorithm/src/programmers_level_2/no_11.java
new file mode 100644
index 0000000..32904a6
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_11.java
@@ -0,0 +1,91 @@
+package programmers_level_2;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class no_11 {
+	
+	public static void main(String[] args) {
+		
+		
+		String m = "CC#BCC#BCC#BCC#B";
+		String[]musicinfos = {"03:00,03:30,FOO,CC#B", "04:00,04:08,BAR,CC#BCC#BCC#B"};
+		String answer = "(None)";
+		
+		String []mel = {"C#","D#","E#","F#","G#","A#","B#"};
+		String []melChange = {"c","d","e","f","g","a","b"};
+		
+		ArrayList<String>answerList = new ArrayList<>();
+		
+		for(int i=0;i<mel.length;i++) m = m.replaceAll(mel[i],melChange[i] );
+		
+		
+		for(String str : musicinfos) {
+			
+			String[]temp = str.split(",");
+			
+			int time = change(temp[0],temp[1]);
+			
+			String title = temp[2];
+			
+			String melody = temp[3];
+			
+			String tempMel = "";
+			
+			for(int i=0;i<mel.length;i++) melody = melody.replaceAll(mel[i], melChange[i]);
+			
+			for(int i=0;i<time;i++) tempMel += melody.charAt(i%melody.length());	
+			
+			System.out.println(tempMel);
+			
+			if(tempMel.contains(m)) answerList.add(title+":"+time);
+			
+		}
+		
+		if(answerList.isEmpty()){
+			System.out.println(answer);
+		}else {
+			Collections.sort(answerList,(o1,o2)->{
+				
+				String []a = o1.split(":");
+				String []b = o2.split(":");
+				
+				int aa = Integer.parseInt(a[1]);
+				int bb = Integer.parseInt(b[1]);
+				
+				if(aa>bb) return bb-aa;
+				
+				return 0;
+			});
+			
+			
+			String [] temp = answerList.get(0).split(":");
+			answer = temp[0];
+			
+			System.out.println(answer);
+		}
+		
+	
+		
+		
+		
+	}
+	static int change(String start,String end) {
+		
+		String s[] = start.split(":");
+		
+		int hour = Integer.parseInt(s[0]);
+		int StartMin = Integer.parseInt(s[1]) + hour*60;
+		
+		s = end.split(":");
+		
+		hour = Integer.parseInt(s[0]);
+		int endMin = Integer.parseInt(s[1]) + hour*60;
+		
+		return endMin - StartMin;
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_12.java b/Basic_Of_Algorithm/src/programmers_level_2/no_12.java
new file mode 100644
index 0000000..d16ce0f
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_12.java
@@ -0,0 +1,73 @@
+package programmers_level_2;
+
+public class no_12 {
+
+	public static void main(String[] args) {
+		
+		int n = 6;
+		int[][]road = {{1,2,1},{1,3,2},{2,3,2},{3,4,3},{3,5,2},{3,5,3},{5,6,1}};
+		int k = 4;
+		int answer = 0;
+		int INF = 500001;
+		int [][] map = new int[n+1][n+1];
+		
+		for(int i = 1 ; i <=n; i++) {
+			for(int j=1; j<=n ; j++) {
+				if(i==j) continue;
+				map[i][j] = INF; //무한대
+			}
+		}
+		
+		
+		for(int i=0;i<road.length;i++) {
+			int a = road[i][0];
+			int b = road[i][1];
+			int w = road[i][2];
+			//무한대 보다 작으면 간선의 정보 저장
+			if(map[a][b] > w) {
+				map[a][b] = w;
+				map[b][a] = w;
+			}
+			
+		}
+		
+		int [] dist = new int[n+1];
+		for(int i = 2; i <= n ; i++) {
+			dist[i] = INF;
+		}
+		
+		boolean[] visited = new boolean[n+1];
+		visited[1] = true;
+		
+		
+		for(int i=1; i <=n-1 ; i++) {
+			
+			int min_idx = 1;
+			int min_value = INF;
+			for(int j=2;j<=n;j++) {
+				if(!visited[j] && dist[j]<min_value) {
+					min_value = dist[j];
+					min_idx = j;
+				}
+			}
+			
+			visited[min_idx] = true;
+			
+			
+			for(int j = 2; j <= n ; j++) {
+				if(dist[j]>dist[min_idx] + map[min_idx][j]) {
+					dist[j] = dist[min_idx] + map[min_idx][j];
+				}
+			}
+			
+		}
+		
+		for(int i=1;i<=n;i++) {
+			
+			if(dist[i]<=k) answer++;
+		}
+		System.out.println(answer);
+		for(int i : dist)System.out.print(i+",");
+	}
+	
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_13.java b/Basic_Of_Algorithm/src/programmers_level_2/no_13.java
new file mode 100644
index 0000000..ef45464
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_13.java
@@ -0,0 +1,54 @@
+package programmers_level_2;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public class no_13 {
+
+	
+	public static void main(String[] args) {
+		
+String [] record = {"Enter uid1234 Muzi", "Enter uid4567 Prodo","Leave uid1234","Enter uid1234 Prodo","Change uid4567 Ryan"};
+		
+		HashMap<String,String> map = new HashMap<>();
+		ArrayList<String> answerList = new ArrayList<>();
+		
+		for(String str : record) {
+			
+			String temp[] = str.split(" ");
+			String action = temp[0];
+			String id = temp[1];
+			
+			if(action.equals("Leave")) continue;
+			
+			String nick = temp[2];
+			
+			map.put(id, nick);
+			
+		}
+		
+		for(String str : record) {
+			
+			String temp[] = str.split(" ");
+			String action = temp[0];
+			String id = temp[1];
+			
+			if(action.equals("Change")) continue;
+			
+			String nick = map.get(id);
+			String ans = nick + "님이 " + (action.equals("Enter") ? "들어왔습니다." : "나갔습니다.");
+			
+			answerList.add(ans);
+		
+		}
+		
+		
+		String[]answer = new String[answerList.size()];
+		
+		for(int i = 0 ; i< answerList.size();i++) answer[i] = answerList.get(i);
+		
+		for(String str : answer)System.out.println(str);
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_14.java b/Basic_Of_Algorithm/src/programmers_level_2/no_14.java
new file mode 100644
index 0000000..a6353ea
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_14.java
@@ -0,0 +1,70 @@
+package programmers_level_2;
+
+public class no_14 {
+
+	public static void main(String[] args) {
+		
+		String p = "()))((()";
+		
+		System.out.println(solution(p));
+		
+	}
+	
+	static String solution(String p) {
+		
+		String answer = change(p);
+		
+		
+		
+		return answer;
+		
+		
+	}
+	static String change(String w) {
+		
+		if(w.isEmpty())return "";
+		
+		String u = "";
+		String v = "";
+		
+		int l = 0;
+		int r = 0;
+		int i;
+		for(i=0;i<w.length();i++) {
+			
+			if(w.charAt(i)==')') l++;
+			else r++;
+			
+			if(l==r) break;
+			
+		}
+		
+		u = w.substring(0,i+1);
+		v = w.substring(i+1,w.length());
+		
+		if(isRight(u)) {
+			u = u + change(v);
+		}else {
+			String newU = "(" + change(v) + ")";
+			u = u.substring(1,u.length()-1);
+			u = u.replaceAll("\\(", "\\.");
+			u = u.replaceAll("\\)", "\\(");
+			u = u.replaceAll("\\.", "\\)");
+			newU += u;
+			u = newU;
+		}
+		
+		
+		return u;
+		
+		
+	}
+	
+	static boolean isRight(String u) {
+		
+		if(u.charAt(0)==')') return false;
+		return true;
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_2.java b/Basic_Of_Algorithm/src/programmers_level_2/no_2.java
new file mode 100644
index 0000000..67169a0
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_2.java
@@ -0,0 +1,54 @@
+package programmers_level_2;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public class no_2 {
+	
+	public static void main(String[] args) {
+		
+		String [] record = {"Enter uid1234 Muzi", "Enter uid4567 Prodo","Leave uid1234","Enter uid1234 Prodo","Change uid4567 Ryan"};
+		
+		ArrayList<String> answerList = new ArrayList<>();
+		
+		HashMap<String,String> map = new HashMap<>();
+		
+		for(String str : record) {
+			
+			String[]temp = str.split(" ");
+			
+			String action = temp[0];
+			if(action.equals("Leave")) continue;
+			String id = temp[1];
+			String nick = temp[2];
+			
+			map.put(id, nick);
+			
+		}
+		for(String str : record) {
+			
+			String[]temp = str.split(" ");
+			
+			String action = temp[0];
+			if(action.equals("Change")) continue;
+			String id = temp[1];
+			String nick = map.get(id);
+			
+			String ans = nick+"님이 " + (action.equals("Enter") ? "들어왔습니다." : "나갔습니다.");
+			
+			answerList.add(ans);
+			
+			
+		}
+		
+		String[]answer = new String[answerList.size()];
+		
+		
+		for(int i=0;i<answerList.size();i++)answer[i] = answerList.get(i);
+		
+		
+		for(String s : answer)System.out.println(s);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_4.java b/Basic_Of_Algorithm/src/programmers_level_2/no_4.java
new file mode 100644
index 0000000..9ab9456
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_4.java
@@ -0,0 +1,71 @@
+package programmers_level_2;
+
+public class no_4 {
+	
+	static char[] member = {'A','C','F','J','M','N','R','T'};
+
+	static String[]datas;
+	static int answer = 0;
+	
+	public static void main(String[] args) {
+		
+		int n = 2;
+		
+		String[]data = {"N~F=0", "R~T>2"};
+		
+		
+		datas = data.clone();
+		
+		boolean[]visited = new boolean[member.length];
+		
+		dfs(visited,"");
+		
+		System.out.println(answer);
+		
+	}
+	static void dfs(boolean[]visited,String now) {
+		
+		if(now.length()==member.length) {
+			if(check(now)) answer++;
+			
+			return;
+		}
+		
+		
+		for(int i=0;i<visited.length;i++) {
+			
+			if(!visited[i]) {
+				visited[i] = true;
+				String newOne = now + member[i];
+				dfs(visited,newOne);
+				visited[i] = false;
+			}
+			
+			
+		}
+		
+	}
+	static boolean check(String now) {
+		
+		for(String data : datas) {
+			
+			int pos1 = now.indexOf(data.charAt(0));
+			int pos2 = now.indexOf(data.charAt(2));
+			char ch = data.charAt(3);
+			int idx = data.charAt(4)-'0';
+			
+			if(ch=='=') {
+				if(!(Math.abs(pos1-pos2)==idx+1)) return false;
+			}else if(ch=='>') {
+				if(!(Math.abs(pos1-pos2)>idx+1)) return false;
+			}else if(ch=='<') {
+				if(!(Math.abs(pos1-pos2)<idx+1)) return false;
+			}
+			
+		}
+		
+		
+		return true;
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_5.java b/Basic_Of_Algorithm/src/programmers_level_2/no_5.java
new file mode 100644
index 0000000..bfca776
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_5.java
@@ -0,0 +1,84 @@
+package programmers_level_2;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Arrays;
+
+public class no_5 {
+
+	static HashMap<String,Integer> map = new HashMap<>();
+	static ArrayList<String> answerList = new ArrayList<>();
+	
+	public static void main(String[] args) {
+		
+		String[] orders = {"ABCFG", "AC", "CDE", "ACDE", "BCFG", "ACDEH"};
+		int [] course = {2,3,4};
+		
+		for(int i=0;i<orders.length;i++) {
+			
+			char[]arr = orders[i].toCharArray();
+			Arrays.sort(arr);
+			orders[i] = String.valueOf(arr);
+			
+			
+			
+		}
+		
+		
+		for(int c : course) {
+			for(String order : orders) {
+				
+				dfs(c,order,"");
+				
+				
+			}
+			
+			if(!map.isEmpty()) {
+				ArrayList<Integer> list = new ArrayList<>(map.values());
+				int max = Collections.max(list);
+				if(max>1) {
+					for(String key : map.keySet()) {
+						if(map.get(key)==max) {
+							answerList.add(key);
+						}
+					}
+					
+				}
+				
+				
+				
+			}
+			
+			
+			map.clear();
+		}
+		
+		String[]answer = new String[answerList.size()];
+		
+		Collections.sort(answerList);
+		
+		for(int i=0;i<answerList.size();i++) answer[i] = answerList.get(i);
+		
+		for(String str : answer)System.out.println(str);
+	}
+	
+	static void dfs(int count, String order,String now) {
+		
+		if(count==0) {
+			
+			map.put(now, map.getOrDefault(now, 0)+1);
+			
+			return;
+		}
+		
+		
+		for(int i=0;i<order.length();i++) {
+			
+			dfs(count-1,order.substring(i+1),now + order.charAt(i));
+			
+		}
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_7.java b/Basic_Of_Algorithm/src/programmers_level_2/no_7.java
new file mode 100644
index 0000000..5e50510
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_7.java
@@ -0,0 +1,54 @@
+package programmers_level_2;
+
+public class no_7 {
+
+	public static void main(String[] args) {
+		
+		String p = ")(";
+		
+		String answer = change(p);
+		
+		System.out.println(answer);
+		
+	}
+	
+	static String change(String w) {
+		
+		if(w.isEmpty()) return "";
+		
+		int l = 0, r = 0;
+		
+		int i;
+		
+		for(i=0;i<w.length();i++) {
+			
+			if(w.charAt(i)=='(') l++;
+			else r++;
+			
+			if(l==r) break;
+		}
+		
+		String u = w.substring(0,i+1);
+		String v = w.substring(i+1);
+		
+		if(isRight(u)) u += change(v);
+		else {
+			String str = "(" + change(v) + ")";
+			u = u.substring(1,u.length()-1);
+			u = u.replaceAll("\\(", ".");
+			u = u.replaceAll("\\)", "(");
+			u = u.replaceAll("\\.", ")");
+			str += u;
+			return str;
+		}
+		return u;
+	}
+	static boolean isRight(String u) {
+		
+		if(u.charAt(0)==')') return false;
+		
+		
+		return true;
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_8.java b/Basic_Of_Algorithm/src/programmers_level_2/no_8.java
new file mode 100644
index 0000000..dfa0305
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_8.java
@@ -0,0 +1,87 @@
+package programmers_level_2;
+
+import java.util.ArrayList;
+
+public class no_8 {
+	
+	public static void main(String[] args) {
+		
+		
+		String str1 = "FRANCE";
+		String str2 = "french";
+		
+		str1 = str1.toLowerCase();
+		str2 = str2.toLowerCase();
+		
+		ArrayList<String> arr1 = new ArrayList<>();
+		ArrayList<String> arr2 = new ArrayList<>();
+		
+		
+		
+		for(int i=0;i<str1.length()-1;i++) {
+			
+			char first = str1.charAt(i);
+			char second = str1.charAt(i+1);
+			
+			if((first>='a'&&first<='z')&&(second>='a'&&second<='z')) {
+				arr1.add(""+first+second);
+			}
+		}
+
+		for(int i=0;i<str2.length()-1;i++) {
+			
+			char first = str2.charAt(i);
+			char second = str2.charAt(i+1);
+			
+			if((first>='a'&&first<='z')&&(second>='a'&&second<='z')) {
+				arr2.add(""+first+second);
+			}
+		}
+		double son = 0;
+		double mom = 0;
+		
+		mom = arr1.size() + arr2.size();
+		
+		System.out.println(mom);
+		
+		for(int i=0;i<arr1.size();i++) {
+			String a = arr1.get(i);
+			
+			for(int j=0;j<arr2.size();j++) {
+				String b = arr2.get(j);
+				if(a.equals(b)) {
+					son++;
+					arr2.remove(j);
+					break;
+				}
+			}
+			
+			
+		}
+		
+		mom -= son;
+		
+		
+		System.out.println(mom);
+		System.out.println(son);
+		
+		double answer = 0;
+		
+		if(son==0 && mom==0) answer = 1;
+		else if(son==0 && mom!=0) answer = 0;
+		else answer = son/mom;
+		
+		
+		answer *= 65536;
+		
+		int result = (int) answer;
+		
+		if(result==0) result = 65536;
+		
+		System.out.println(result);
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/programmers_level_2/no_9.java b/Basic_Of_Algorithm/src/programmers_level_2/no_9.java
new file mode 100644
index 0000000..8f00dac
--- /dev/null
+++ b/Basic_Of_Algorithm/src/programmers_level_2/no_9.java
@@ -0,0 +1,97 @@
+package programmers_level_2;
+
+import java.util.ArrayList;
+
+public class no_9 {
+
+	
+	
+	
+	static ArrayList<Long> numArr = new ArrayList<>();
+	static ArrayList<Character> opArr = new ArrayList<>();
+	static char[]op = {'+','-','*'};
+	static long answer = Integer.MIN_VALUE;
+	static boolean[]visited = new boolean[3];
+	
+	public static void main(String[] args) {
+		
+	String expression = "100-200*300-500+20";
+	
+	change(expression);
+		
+	dfs(new char[3] ,0);
+		
+	System.out.println(answer);
+	
+	}
+	
+	static Long changeNum(char ch , long a, long b) {
+	
+		if(ch=='+') return a+b;
+		else if(ch=='*') return a*b;
+		else if(ch=='-') return a-b;
+		
+		return (long) 0;
+	}
+	
+	static void dfs(char[]p,int count) {
+		
+		if(count==3) {
+			
+			ArrayList<Long> numList = new ArrayList<>(numArr);
+			ArrayList<Character> opList = new ArrayList<>(opArr);
+			
+			for(int i=0;i<op.length;i++) {
+				for(int j=0;j<opList.size();j++) {
+					if(opList.get(j)==p[i]) {
+						long a = changeNum(opList.get(j),numList.remove(j),numList.remove(j));
+						opList.remove(j);
+						numList.add(j,a);
+						j--;						
+					}
+				}
+			}
+			
+			
+			answer = Math.max(answer, Math.abs(numList.get(0)));
+			return;
+			
+		}
+		
+		
+		for(int i=0;i<op.length;i++) {
+			if(!visited[i]) {
+				visited[i] = true;
+				p[count] = op[i];
+				dfs(p,count+1);				
+				visited[i] = false;
+			}
+			
+		}
+		
+	}
+	
+	
+	static void change(String expression) {
+		
+		String num = "";
+		
+		for(int i=0;i<expression.length();i++) {
+			
+			char ch = expression.charAt(i);
+			
+			if(ch>='0'&&ch<='9') {
+				num += ch;
+			}else {
+				numArr.add(Long.parseLong(num));
+				opArr.add(ch);
+				num = "";
+				
+			}
+			
+		}
+		
+		numArr.add(Long.parseLong(num));
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1226.java b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1226.java
new file mode 100644
index 0000000..524de28
--- /dev/null
+++ b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1226.java
@@ -0,0 +1,97 @@
+package ssafy_avanced_study;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class no_1226 {
+	
+	
+	public static void main(String[] args) throws Exception {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		
+		/*
+		   여러 개의 테스트 케이스가 주어지므로, 각각을 처리합니다.
+		*/
+		
+		int[][]move = {{1,0},{0,1},{-1,0},{0,-1}};
+		
+		for(int test_case = 1; test_case <= 10; test_case++)
+		{
+			
+			Integer.parseInt(br.readLine());
+			
+			int[][]map = new int[16][16];
+			
+			Queue<int []> q = new LinkedList<>();
+			
+			
+			int []start = new int[2];
+			int []end = new int[2];
+		
+			
+			for(int i=0;i<16;i++) {
+				String s = br.readLine();
+				for(int j=0;j<16;j++) {
+					map[i][j] = Integer.parseInt(""+s.charAt(j));
+					
+				}
+			}
+			
+			StringBuilder sb = new StringBuilder();
+			
+			boolean[][]visited = new boolean[16][16];
+		
+			
+			q.add(new int[] {1,1});
+	
+			boolean isTrue = false;
+			
+			while(!q.isEmpty()) {
+				
+				int [] c = q.poll();
+				int i = c[0];
+				int j = c[1];
+				
+	
+			
+				
+		
+				
+				for(int d=0;d<4;d++) {
+				
+					int ni = i+move[d][0];
+					int nj = j+move[d][1];
+					
+					if(ni<0||nj<0||15<ni||15<nj) continue;
+					
+					if(map[ni][nj]==3) {
+						isTrue = true;
+						break;
+					}
+					
+					if(!visited[ni][nj] && map[ni][nj]==0) {
+						visited[ni][nj] = true;
+						q.add(new int[] {ni,nj});
+						
+						
+					}
+					
+				}
+				
+			}
+			
+			sb.append("#").append(test_case).append(" ");
+			
+			if(isTrue) sb.append(1);
+			else sb.append(0);
+			
+			System.out.println(sb.toString());
+			
+		}
+		
+	}
+	
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1247.java b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1247.java
new file mode 100644
index 0000000..6271940
--- /dev/null
+++ b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1247.java
@@ -0,0 +1,23 @@
+package ssafy_avanced_study;
+
+import java.util.Scanner;
+
+public class no_1247 {
+
+	public static void main(String[] args) {
+		
+		
+		Scanner sc = new Scanner(System.in);
+		int T;
+		T=sc.nextInt();
+		/*
+		   여러 개의 테스트 케이스가 주어지므로, 각각을 처리합니다.
+		*/
+
+		for(int test_case = 1; test_case <= T; test_case++){
+		
+			
+			
+		}
+	}
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1248.java b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1248.java
new file mode 100644
index 0000000..9ce4e96
--- /dev/null
+++ b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1248.java
@@ -0,0 +1,80 @@
+package ssafy_avanced_study;
+
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class no_1248 {
+	
+	
+	
+
+	public static void main(String[] args) throws Exception {
+		
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int T;
+		T=Integer.parseInt(br.readLine());
+	
+		for(int test_case = 1; test_case <= T; test_case++){
+		
+			int size =Integer.parseInt(br.readLine());
+			
+			int[][]map = new int[size][size];
+			
+			int answer = Integer.MAX_VALUE;
+		
+			
+			for(int i=0;i<size;i++) {
+				String s = br.readLine();
+				for(int j=0;j<size;j++) {
+					map[i][j] = Integer.parseInt(""+s.charAt(j));
+				}
+			}
+			
+			Queue<int[]> q = new LinkedList<>();
+			
+			int[][]mov = {{1,0},{0,1},{-1,0},{0,-1}};
+			int[][]temp = new int[size][size];
+			boolean[][]visited = new boolean[size][size];
+			q.add(new int[] {0,0});
+			
+			while(!q.isEmpty()) {
+				
+				int []c = q.poll();
+				int i = c[0];
+				int j = c[1];
+
+				if(i==size-1 && j==size-1) {
+					answer = Math.min(answer, temp[i][j]);
+					continue;
+				}
+				if(answer<=temp[i][j]) continue;
+			
+				for(int d=0;d<4;d++) {
+					int ni = i + mov[d][0];
+					int nj = j + mov[d][1];
+					
+					if(ni<0 || nj<0|| size-1 <ni|| size-1 < nj) continue;
+					
+					if(!visited[ni][nj] || temp[ni][nj] > temp[i][j] + map[ni][nj]) {
+						visited[ni][nj] = true;
+						temp[ni][nj]  = temp[i][j] + map[ni][nj];
+						q.add(new int[] {ni,nj});	
+					}
+						
+				}
+				
+			}
+			
+			System.out.println("#"+test_case+" "+answer);
+			
+			
+			
+		}
+		
+	}
+	
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1249.java b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1249.java
new file mode 100644
index 0000000..5741327
--- /dev/null
+++ b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1249.java
@@ -0,0 +1,79 @@
+package ssafy_avanced_study;
+
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class no_1249 {
+	
+	
+	
+
+	 public static void main(String args[]) throws Exception
+	    {
+	            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+	        int T;
+	        T=Integer.parseInt(br.readLine());
+	     
+	        for(int test_case = 1; test_case <= T; test_case++){
+	         
+	            int size =Integer.parseInt(br.readLine());
+	             
+	            int[][]map = new int[size][size];
+	             
+	            int answer = Integer.MAX_VALUE;
+	         
+	             
+	            for(int i=0;i<size;i++) {
+	                String s = br.readLine();
+	                for(int j=0;j<size;j++) {
+	                    map[i][j] = Integer.parseInt(""+s.charAt(j));
+	                }
+	            }
+	             
+	            Queue<int[]> q = new LinkedList<>();
+	             
+	            int[][]mov = {{1,0},{0,1},{-1,0},{0,-1}};
+	            int[][]temp = new int[size][size];
+	            boolean[][]visited = new boolean[size][size];
+	            q.add(new int[] {0,0});
+	             
+	            while(!q.isEmpty()) {
+	                 
+	                int []c = q.poll();
+	                int i = c[0];
+	                int j = c[1];
+	 
+	                if(i==size-1 && j==size-1) {
+	                    answer = Math.min(answer, temp[i][j]);
+	                    continue;
+	                }
+	                if(answer<=temp[i][j]) continue;
+	             
+	                for(int d=0;d<4;d++) {
+	                    int ni = i + mov[d][0];
+	                    int nj = j + mov[d][1];
+	                     
+	                    if(ni<0 || nj<0|| size-1 <ni|| size-1 < nj) continue;
+	                     
+	                    if(!visited[ni][nj] || temp[ni][nj] > temp[i][j] + map[ni][nj]) {
+	                        visited[ni][nj] = true;
+	                        temp[ni][nj]  = temp[i][j] + map[ni][nj];
+	                        q.add(new int[] {ni,nj});   
+	                    }
+	                         
+	                }
+	                 
+	            }
+	             
+	            System.out.println("#"+test_case+" "+answer);
+	             
+	             
+	             
+	        }
+	         
+	    }
+	     
+	}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1936.java b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1936.java
new file mode 100644
index 0000000..a89a8df
--- /dev/null
+++ b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1936.java
@@ -0,0 +1,37 @@
+package ssafy_avanced_study;
+
+import java.util.Scanner;
+
+public class no_1936 {
+
+	
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		int a = scan.nextInt();
+        int b = scan.nextInt();
+        
+        String.valueOf(a);
+        
+        String answer = "";
+       
+        if(a==1){
+            if(b==2) answer = "B";
+            else answer = "A";
+        }else if(a==2){
+            if(b==3) answer = "B";
+            else answer = "A";
+        }else{
+            if(b==1) answer = "B";
+            else answer = "A";
+        }
+		/////////////////////////////////////////////////////////////////////////////////////////////
+		/*
+			 이 부분에 여러분의 알고리즘 구현이 들어갑니다.
+		 */
+		/////////////////////////////////////////////////////////////////////////////////////////////
+		System.out.println(answer);
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1946.java b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1946.java
new file mode 100644
index 0000000..4721da0
--- /dev/null
+++ b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1946.java
@@ -0,0 +1,60 @@
+package ssafy_avanced_study;
+
+import java.util.Scanner;
+
+public class no_1946 {
+	
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int T;
+		T=sc.nextInt();
+	
+
+		for(int test_case = 1; test_case <= T; test_case++)
+		{
+           
+		
+			int n = sc.nextInt();
+			
+			
+			
+			String answer = "";
+            
+			sc.nextLine();
+
+			for(int i=0;i<n;i++) {
+				
+				
+				String str = sc.nextLine();
+				char alpha = str.charAt(0);
+				int count = 0;
+			
+				if(str.charAt(2)=='1' && str.length()>3) {
+					count = Integer.parseInt(""+str.charAt(2)+str.charAt(3));
+				}else if(str.charAt(2)=='2' && str.length()>3) {
+					count = Integer.parseInt(""+str.charAt(2)+str.charAt(3));
+				}
+				else count = Integer.parseInt(String.valueOf(str.charAt(2)));
+				
+				for(int j=0;j<count;j++) answer += alpha;
+				
+				
+				
+			}
+
+			System.out.println("#"+test_case);
+			String a = "";
+			for(int i=1;i<=answer.length();i++) {
+				a += answer.charAt(i-1);
+				if(i%10==0) {
+					System.out.println(a);
+					a = "";
+				}
+			}
+			System.out.println(a);
+			
+			
+
+		}
+	}
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1959.java b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1959.java
new file mode 100644
index 0000000..498f395
--- /dev/null
+++ b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1959.java
@@ -0,0 +1,71 @@
+package ssafy_avanced_study;
+
+import java.util.Scanner;
+
+public class no_1959 {
+
+	public static void main(String[] args) {
+		
+		Scanner sc = new Scanner(System.in);
+		
+		int T;
+		T = sc.nextInt();
+		
+		for(int test_case=1;test_case<=T;test_case++) {
+			
+			String answer = "#"+test_case+" ";
+			
+			int a = sc.nextInt();
+			int b = sc.nextInt();
+			int ans = 0;
+			int []arr1 = new int[a];
+			int []arr2 = new int[b];
+			
+			for(int i=0;i<a;i++) arr1[i] = sc.nextInt();
+			for(int i=0;i<b;i++) arr2[i] = sc.nextInt();
+			
+			int max = 0;
+			
+			if(a<=b) {
+				
+				int c = b-a;
+				
+				for(int i=0;i<=c;i++) {
+					
+					for(int j=0;j<arr1.length;j++) ans += arr1[j] * arr2[j+i];
+						
+					System.out.println(ans);
+					
+					max = Math.max(max, ans);					
+					ans = 0;
+				}
+				
+				
+			}else {
+				
+				int c = a-b;
+				
+				for(int i=0;i<=c;i++) {
+					
+					for(int j=0;j<arr2.length;j++) ans += arr2[j] * arr1[j+i];
+					
+				
+					
+					max = Math.max(max, ans);
+					ans = 0;
+				}
+				
+				
+			}
+			
+			
+			answer += max;
+			
+			System.out.println(answer);
+			
+		}
+		
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1961.java b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1961.java
new file mode 100644
index 0000000..7c414d4
--- /dev/null
+++ b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1961.java
@@ -0,0 +1,83 @@
+package ssafy_avanced_study;
+
+import java.util.Scanner;
+
+public class no_1961 {
+
+	public static void main(String[] args) {
+		
+		
+		
+		Scanner sc = new Scanner(System.in);
+		int T;
+		T=sc.nextInt();
+		/*
+		   여러 개의 테스트 케이스가 주어지므로, 각각을 처리합니다.
+		*/
+
+		for(int test_case = 1; test_case <= T; test_case++){
+		
+			
+			
+			String answer = "#"+test_case;
+			
+			int size = sc.nextInt();
+			
+			int[][]map = new int[size][size];
+			
+			for(int i=0;i<size;i++) {
+				for(int j=0;j<size;j++) {
+					map[i][j] = sc.nextInt();
+				}
+			}
+			
+			System.out.println(answer);
+			
+			int[][]map1 = new int[size][size];
+			
+			for(int j=0;j<size;j++) {
+				for(int i=size-1;i>-1;i--) {
+					map1[j][size-i-1] = map[i][j];
+				}
+				
+			}
+			
+			int[][]map2 = new int[size][size];
+			
+			
+			for(int i=size-1;i>-1;i--) {
+				for(int j=size-1;j>-1;j--) {
+					map2[size-i-1][size-j-1] = map[i][j];
+				}
+				
+			}
+			
+			int[][]map3 = new int[size][size];
+			
+			for(int j=size-1;j>-1;j--) {
+				for(int i=0;i<size;i++) {
+					map3[size-j-1][i] = map[i][j];
+				}
+				
+			}
+			
+			for(int i=0;i<size;i++) {
+				for(int j=0;j<size;j++) {
+					System.out.print(map1[i][j]);
+					
+				}
+				System.out.print(" ");
+				for(int j=0;j<size;j++) {
+					System.out.print(map2[i][j]);
+				}
+				System.out.print(" ");
+				for(int j=0;j<size;j++) {
+					System.out.print(map3[i][j]);
+				}
+				System.out.println();
+			}
+			
+			
+		}
+	}
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1974.java b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1974.java
new file mode 100644
index 0000000..b21d1b7
--- /dev/null
+++ b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1974.java
@@ -0,0 +1,68 @@
+package ssafy_avanced_study;
+
+import java.util.Scanner;
+
+public class no_1974 {
+
+	public static void main(String[] args) {
+		
+		Scanner sc = new Scanner(System.in);
+		int T;
+		T=sc.nextInt();
+		
+		for(int test_case = 1; test_case <= T; test_case++){
+		
+			int[][]map = new int[9][9];
+			
+			boolean flag = true;
+			String answer = "#"+test_case+" ";
+			for(int i=0;i<9;i++) {
+				for(int j=0;j<9;j++) {
+					map[i][j] = sc.nextInt();
+				}
+			}
+			outerLoop:
+			for(int i=0;i<9;i++) {
+				int []arr = new int[9];
+				int []arr2 = new int[9];
+				for(int j=0;j<9;j++) {
+					arr[map[i][j]-1]++;
+					arr2[map[j][i]-1]++;
+					
+					if(arr[map[i][j]-1]>1 || arr2[map[i][j]-1]>1) {
+						flag = false;
+						break outerLoop;
+					}
+					
+					
+					}
+					
+				}
+			outerLoop:
+			for(int l=0;l<3;l++) {
+				
+				int[]arr = new int[9];
+
+				for(int i=0;i<3;i++) {
+					for(int j=0;j<3;j++) {
+						arr[map[i+(l*3)][j+(l*3)]-1]++;
+						if(arr[map[i][j]-1]>1) {
+							flag = false;
+							break outerLoop;
+						}
+						
+					}
+				}
+			}
+			
+			
+			if(!flag) answer += 0 ;
+			else answer += 1;
+			
+			System.out.println(answer);
+			
+			
+			
+		}
+	}
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1979.java b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1979.java
new file mode 100644
index 0000000..bf7f756
--- /dev/null
+++ b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_1979.java
@@ -0,0 +1,108 @@
+package ssafy_avanced_study;
+
+import java.util.Scanner;
+import java.util.Stack;
+
+public class no_1979 {
+	
+	public static void main(String[] args) {
+		
+		
+		Scanner sc = new Scanner(System.in);
+		int T;
+		T=sc.nextInt();
+		
+		for(int test_case = 1; test_case <= T; test_case++){
+		
+			String answer = "#"+test_case+" ";
+			
+			int size = sc.nextInt();
+			int len = sc.nextInt();
+			int ans = 0;
+			
+			int [][]map = new int[size][size];
+			
+			for(int i=0;i<size;i++) {
+				for(int j=0;j<size;j++) {
+					map[i][j] = sc.nextInt();
+				}
+			}
+			
+			//가로
+			
+			for(int i=0;i<size;i++) {
+				Stack<Integer> stack = new Stack<>();
+				for(int j=0;j<size;j++) {
+					
+					if(map[i][j]==1) stack.add(1);
+					else stack.add(0);
+				}
+				int count = 0;
+				
+				while(!stack.isEmpty()) {
+					
+					if(stack.isEmpty()) break;
+			
+					if(stack.peek()==1) count++;
+					else if(stack.peek()==0) count = 0;
+						
+			
+					stack.pop();	
+					
+					if(count==len) {
+						if(!stack.isEmpty()&&stack.peek()==0) {
+							ans++;
+							count = 0;
+							stack.pop();
+						}else if(stack.isEmpty()) {
+							ans++;
+						}
+					}
+					
+				}
+				
+			}
+			
+			//세로
+			
+			for(int j=0;j<size;j++) {
+				Stack<Integer> stack = new Stack<>();
+				for(int i=0;i<size;i++) {
+					
+					if(map[i][j]==1) stack.add(1);
+					else stack.add(0);
+				}
+				int count = 0;
+				
+				while(!stack.isEmpty()) {
+					
+					if(stack.isEmpty()) break;
+				
+					if(stack.peek()==1) count++;
+					else if(stack.peek()==0) count = 0;
+						
+					stack.pop();
+					
+					if(count==len) {
+						if(!stack.isEmpty()&&stack.peek()==0) {
+							ans++;
+							count = 0;
+							stack.pop();
+						}else if(stack.isEmpty()) {
+							ans++;
+						}
+					}
+					
+				}
+				
+			}
+			
+			answer += ans;
+			
+			System.out.println(answer);
+			
+			
+			
+		}
+	}
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/ssafy_avanced_study/no_2001.java b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_2001.java
new file mode 100644
index 0000000..52cf58d
--- /dev/null
+++ b/Basic_Of_Algorithm/src/ssafy_avanced_study/no_2001.java
@@ -0,0 +1,50 @@
+package ssafy_avanced_study;
+
+import java.util.Scanner;
+
+public class no_2001 {
+	
+	public static void main(String[] args) {
+		
+		
+		Scanner sc = new Scanner(System.in);
+		int T;
+		T=sc.nextInt();
+		/*
+		   여러 개의 테스트 케이스가 주어지므로, 각각을 처리합니다.
+		*/
+
+		for(int test_case = 1; test_case <= T; test_case++)
+		{
+		int n = sc.nextInt();
+		int k = sc.nextInt();
+		int [][]map = new int[n][n];
+		
+		for(int i=0;i<n;i++) {
+			for(int j=0;j<n;j++) {
+				map[i][j] = sc.nextInt();
+			}
+		}
+		
+		int ans = 0;
+		int max = 0;
+		
+		for(int i=0;i<=n-k;i++) {
+			for(int j=0;j<=n-k;j++) {
+				
+				for(int ii=0;ii<k;ii++) {
+					for(int jj=0;jj<k;jj++) {
+						ans += map[ii+i][jj+j];
+					}
+				}
+				
+				max = Math.max(ans, max);
+				ans = 0;
+			}
+		}
+		String answer = "#"+test_case+" "+max;
+		System.out.println(answer);
+		
+		}
+	}
+}
diff --git a/Basic_Of_Algorithm/src/sw_java_im/no_1244.java b/Basic_Of_Algorithm/src/sw_java_im/no_1244.java
new file mode 100644
index 0000000..8d5fbb4
--- /dev/null
+++ b/Basic_Of_Algorithm/src/sw_java_im/no_1244.java
@@ -0,0 +1,88 @@
+package sw_java_im;
+
+import java.util.Scanner;
+
+public class no_1244 {
+	
+	public static void main(String[] args) {
+		
+		Scanner sc = new Scanner(System.in);
+		
+		int count = sc.nextInt();
+		
+		int [] arr = new int[count+1];
+		
+		arr[0] = 0;
+		
+		for(int i=1;i<count+1;i++) {
+			
+			arr[i] = sc.nextInt();
+			
+			
+		}
+		
+		count = sc.nextInt();
+		
+		for(int i=0;i<count;i++) {
+			
+			int sex = sc.nextInt();
+			
+			int loc = sc.nextInt();
+			
+			if(sex==1) {
+				
+				
+				while(true) {
+					
+					if(arr[loc]==0) {
+						arr[loc] = 1;
+					}else {
+						arr[loc] = 0;
+					}
+					
+					loc = loc + loc;
+					
+					if(loc>=arr.length) break;
+					
+					
+				}
+				
+			
+			}else {
+				
+				if(arr[loc]==0) arr[loc] = 1;
+				else arr[loc] = 0;
+				
+				int left = loc-1;
+				int right = loc+1;
+				
+				while(true) {
+					
+					if(left<1 || arr.length<right || arr[left] != arr[right]) break;
+					else {
+						
+						if(arr[left] == 0) {
+							arr[left] = 1;
+							arr[right] = 1;
+						}else {
+							arr[left] = 0;
+							arr[right] = 0;
+						}
+						
+						left--;
+						right++;
+					}
+					
+				}
+				
+				
+			
+		}
+			
+		}
+		
+		
+		for(int i =1 ; i<arr.length; i++) System.out.println(arr[i]);
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/sw_java_im/no_2527.java b/Basic_Of_Algorithm/src/sw_java_im/no_2527.java
new file mode 100644
index 0000000..ee6714c
--- /dev/null
+++ b/Basic_Of_Algorithm/src/sw_java_im/no_2527.java
@@ -0,0 +1,41 @@
+package sw_java_im;
+
+import java.util.Scanner;
+
+public class no_2527 {
+
+	public static void main(String[] args) {
+		
+		Scanner scan = new Scanner(System.in);
+		
+		for(int i=0;i<4;i++) {
+			
+			int x1 = scan.nextInt();
+			int y1 = scan.nextInt();
+			int x2 = scan.nextInt();
+			int y2 = scan.nextInt();
+			int x3 = scan.nextInt();
+			int y3 = scan.nextInt();
+			int x4 = scan.nextInt();
+			int y4 = scan.nextInt();
+			
+			//점
+			if((x2 == x3 && y2 == y3) || (x1 == x4 && y1 == y4) 
+			|| (x2 == x3 && y1 == y4) || (x1 == x4 && y2 == y3)) {
+					System.out.println("c");
+				//선분
+			}else if((x2==x3 && y2 != y3) || (x1==x4 && y1 != y4) ||
+					(x2==x3 && y1 != y4) || (x2!=x3 && y1 == y4)){
+					System.out.println("b");
+			//겹치지 않을 경구
+			}else if(x2 < x3 || x4 < x1 || y2 < y3 || y4 < y1) System.out.println("d");
+			
+			else System.out.println("a");
+			
+			
+			
+		}
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/sw_java_im/no_3.java b/Basic_Of_Algorithm/src/sw_java_im/no_3.java
new file mode 100644
index 0000000..7ff28f3
--- /dev/null
+++ b/Basic_Of_Algorithm/src/sw_java_im/no_3.java
@@ -0,0 +1,35 @@
+package sw_java_im;
+
+public class no_3 {
+	
+	static int answer = 0 ;
+	static int t;
+	public static void main(String[] args) {
+		
+		
+		int [] arr = {1,1,1,1,1};
+		int target = 3;
+		t = target;
+		
+		dfs(arr,0,0);
+		
+		System.out.println(answer);
+	}
+	
+	static void dfs(int[]arr,int now,int count) {
+		
+		if(count==arr.length) {
+			if(now==t) answer++;
+			
+			return;
+		}
+		
+		dfs(arr,now+arr[count],count+1);
+		dfs(arr,now-arr[count],count+1);
+		
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/swea/no_1244.java b/Basic_Of_Algorithm/src/swea/no_1244.java
new file mode 100644
index 0000000..7e37ebf
--- /dev/null
+++ b/Basic_Of_Algorithm/src/swea/no_1244.java
@@ -0,0 +1,68 @@
+package swea;
+
+import java.util.Scanner;
+
+public class no_1244 {
+	
+	public static void main(String[] args) {
+		
+		Scanner sc = new Scanner(System.in);
+		
+		int size = sc.nextInt();
+		
+		int[]arr = new int[size];
+		
+		for(int i=0;i<size;i++) arr[i] = sc.nextInt();
+		
+		int test = sc.nextInt();
+		
+		for(int t=0;t<test;t++) {
+			
+			int sex = sc.nextInt();
+			int idx = sc.nextInt();
+			
+			if(sex==1) {
+				for(int i=idx;i<size;i += idx) {
+					if(arr[i]==1) arr[i] = 0;
+					else arr[i] = 1;
+				}
+			}else {
+				
+				int plus = 1;
+				
+				while(true) {
+					
+					if(arr[idx+plus]==arr[idx-plus]) {
+						if(arr[idx+plus]==1) {
+							arr[idx+plus] = 0;
+							arr[idx-plus] = 0;
+						}else {
+							arr[idx+plus] = 1;
+							arr[idx-plus] = 1;
+						}
+						
+						plus++;
+						
+					}else break;
+				
+					
+					
+				}
+				
+					
+					
+					
+			}
+				
+				
+			}
+			
+
+			
+		
+		
+		for(int i : arr)System.out.println(i);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/swea/no_1289.java b/Basic_Of_Algorithm/src/swea/no_1289.java
new file mode 100644
index 0000000..9107da4
--- /dev/null
+++ b/Basic_Of_Algorithm/src/swea/no_1289.java
@@ -0,0 +1,53 @@
+package swea;
+
+import java.util.Scanner;
+
+public class no_1289 {
+
+	
+	public static void main(String args[]) throws Exception
+	{
+		/*
+		   아래의 메소드 호출은 앞으로 표준 입력(키보드) 대신 input.txt 파일로부터 읽어오겠다는 의미의 코드입니다.
+		   여러분이 작성한 코드를 테스트 할 때, 편의를 위해서 input.txt에 입력을 저장한 후,
+		   이 코드를 프로그램의 처음 부분에 추가하면 이후 입력을 수행할 때 표준 입력 대신 파일로부터 입력을 받아올 수 있습니다.
+		   따라서 테스트를 수행할 때에는 아래 주석을 지우고 이 메소드를 사용하셔도 좋습니다.
+		   단, 채점을 위해 코드를 제출하실 때에는 반드시 이 메소드를 지우거나 주석 처리 하셔야 합니다.
+		 */
+		//System.setIn(new FileInputStream("res/input.txt"));
+
+		/*
+		   표준입력 System.in 으로부터 스캐너를 만들어 데이터를 읽어옵니다.
+		 */
+		Scanner sc = new Scanner(System.in);
+		int T;
+		T=sc.nextInt();
+		/*
+		   여러 개의 테스트 케이스가 주어지므로, 각각을 처리합니다.
+		*/
+
+		for(int test_case = 1; test_case <= T; test_case++)
+		{
+		
+			StringBuilder sb = new StringBuilder();
+			
+			sb.append("#").append(test_case).append(" ");
+			
+			String str = sc.next();
+			int[] a = new int[str.length()];
+			for(int i = 0; i < str.length(); i++) {
+				a[i] = str.charAt(i) - '0';
+			}
+			int num = a[0];
+			
+			for(int i = 1; i < a.length; i++) {
+				if(a[i] != a[i-1]) num++;
+			}
+			
+			sb.append(num);
+			
+			System.out.println(sb.toString());
+
+		}
+	}
+}
diff --git a/Basic_Of_Algorithm/src/test/bfs.java b/Basic_Of_Algorithm/src/test/bfs.java
new file mode 100644
index 0000000..9273400
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/bfs.java
@@ -0,0 +1,50 @@
+package test;
+
+import java.util.Queue;
+import java.util.LinkedList;
+
+public class bfs {
+	
+	public static void main(String[] args) {
+		
+		int[][]maps = {{1,0,1,1,1},{1,0,1,0,1},{1,0,1,1,1},{1,1,1,0,1},{0,0,0,0,1}};
+		int answer = 0;
+		
+		Queue<int []> q= new LinkedList<>();
+	
+		q.add(new int[] {0,0});
+		
+		int[][]temp = new int[maps.length][maps[0].length];
+		
+		temp[0][0] = 1;
+		
+		int[][]move = {{1,0},{0,1},{-1,0},{0,-1}};
+		
+		while(!q.isEmpty()) {
+			int []cur = q.poll();
+			
+			int i = cur[0];
+			int j = cur[1];
+			
+			for(int d=0;d<4;d++) {
+				int newI = i + move[d][0];
+				int newJ = j + move[d][1];
+				
+				if(newI<0||newJ<0||maps.length-1<newI||maps[0].length-1<newJ) continue;
+				
+				if(temp[newI][newJ]==0 && maps[newI][newJ]==1) {
+					temp[newI][newJ] = temp[i][j]+1;
+					q.add(new int[] {newI,newJ});
+				}
+				
+			}
+			
+		}
+		
+		answer = temp[maps.length-1][maps[0].length-1];
+		
+		System.out.println(answer);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/test/binarySearch.java b/Basic_Of_Algorithm/src/test/binarySearch.java
new file mode 100644
index 0000000..7610a03
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/binarySearch.java
@@ -0,0 +1,83 @@
+package test;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class binarySearch {
+
+	static HashMap<String,ArrayList<Integer>>infoMap = new HashMap<>();
+
+	public static void main(String[] args) {
+		
+		String[]info = {"java backend junior pizza 150","python frontend senior chicken 210","python frontend senior chicken 150","cpp backend senior pizza 260","java backend junior chicken 80","python backend senior chicken 50"};
+		String[]query = {"java and backend and junior and pizza 100","python and frontend and senior and chicken 200","cpp and - and senior and pizza 250","- and backend and senior and - 150","- and - and - and chicken 100","- and - and - and - 150"};
+		
+		int[]answer = new int[query.length];
+		
+		
+		
+		for(String str : info) {
+			
+			String[]temp = str.split(" ");
+			dfs(temp,0,"");
+			
+		}
+		
+		for(int i=0;i<query.length;i++) {
+			
+			query[i] = query[i].replaceAll(" and ","");
+			
+			String[]temp = query[i].split(" ");
+			
+			answer[i] = infoMap.containsKey(temp[0]) ? binarySearch(temp) : 0;
+		
+		}
+		
+		for(int i : answer)System.out.println(i);
+		
+	}
+	
+	static int binarySearch(String[]temp) {
+		
+		ArrayList<Integer> list = new ArrayList<>(infoMap.get(temp[0]));
+		
+		Collections.sort(list);
+		
+		int start = 0;
+		int end = list.size()-1;
+		int score = Integer.parseInt(temp[1]);
+		
+		
+		
+		while(start<=end) {
+			
+			int mid = (start+end)/2;
+			
+			if(score>list.get(mid)) start = mid+1;
+			else end = mid-1;
+			
+		}
+		
+		
+		return list.size()-start;
+	}
+	
+	static void dfs(String[]temp,int count,String now) {
+		
+		if(count==4) {
+			if(!infoMap.containsKey(now)) {
+				infoMap.put(now, new ArrayList<Integer>());
+			}
+			infoMap.get(now).add(Integer.parseInt(temp[4]));
+			return;
+		}
+		
+		dfs(temp,count+1,now+temp[count]);
+		dfs(temp,count+1,now+"-");
+		
+		
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/test/color.java b/Basic_Of_Algorithm/src/test/color.java
new file mode 100644
index 0000000..52513e6
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/color.java
@@ -0,0 +1,81 @@
+package test;
+
+public class color {
+
+	public static void main(String[] args) {
+		
+		String[]temp = {"RRRBB", 
+				"GGBBB", 
+				"BBBRR",  
+				"BBRRR", 
+				"RRRRR"};
+		
+		char[][]map = new char[temp.length][temp[0].length()];
+		
+		
+		for(int i=0;i<map.length;i++) {
+			for(int j=0;j<map[0].length;j++) {
+				map[i][j] = temp[i].charAt(j);
+			}
+		}
+		
+		boolean[][]visited = new boolean[map.length][map[0].length];
+		boolean[][]visited2 = new boolean[map.length][map[0].length];
+		
+		int normal = 0;
+		
+		for(int i=0;i<map.length;i++) {
+			for(int j=0;j<map[0].length;j++) {
+				if(!visited[i][j]) {
+					dfs(i,j,map,visited);
+					normal++;
+				}
+			}
+		}
+		
+		
+		int disabled = 0;
+		
+		for(int i=0;i<map.length;i++) {
+			for(int j=0;j<map[0].length;j++) {
+				if(map[i][j]=='G') map[i][j] = 'R';
+				
+			}
+		}
+		
+		for(int i=0;i<map.length;i++) {
+			for(int j=0;j<map[0].length;j++) {
+				if(!visited2[i][j]) {
+					dfs(i,j,map,visited2);
+					disabled++;
+				}
+			}
+		}
+		
+		System.out.println(normal);
+		System.out.println(disabled);
+	}
+	
+	static void dfs(int i,int j,char[][]map,boolean[][]visited) {
+		
+		int[][]move = {{0,1},{1,0},{0,-1},{-1,0}};
+		
+		visited[i][j] = true;
+		
+		
+		for(int d=0;d<4;d++) {
+			
+			int newI = i + move[d][0];
+			int newJ = j + move[d][1];
+			
+			if(newI<0||newJ<0||map.length-1<newI||map[0].length-1<newJ) continue;
+			
+			if(!visited[newI][newJ] && map[newI][newJ]==map[i][j]) {
+				dfs(newI,newJ,map,visited);
+			}
+			
+		}
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/test/combination_Algorithm.java b/Basic_Of_Algorithm/src/test/combination_Algorithm.java
new file mode 100644
index 0000000..59ce02d
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/combination_Algorithm.java
@@ -0,0 +1,78 @@
+package test;
+
+public class combination_Algorithm {
+
+public static void main(String[] args) {
+		
+		int [] arr = {1,2,3};
+		
+		boolean[]visited = new boolean[arr.length];
+		
+		combi(arr,visited);
+		
+		dfs(arr,visited,"");
+	
+		
+	}
+	
+
+	
+	static void dfs(int[]arr,boolean[]visited,String now) {
+		
+		System.out.println(now);
+		
+		if(now.length()==arr.length) return;
+		
+		for(int i=0;i<arr.length;i++) {
+			if(!visited[i]) {
+				visited[i] = true;
+				String newOne = now + arr[i];
+				dfs(arr,visited,newOne);
+				visited[i] = false;
+				
+			}
+			
+		}
+		
+	}
+	
+	static void combi(int[]arr,boolean[]visited) {
+		
+		
+		for(int i=1 ; i<=arr.length;i++) {
+			
+			System.out.println(arr.length+"중에 " + i + "개 뽑기");
+			
+			combination(arr,visited,i,0);
+			
+			System.out.println();
+		}
+		
+		
+		
+	}
+	static void combination(int[]arr,boolean[]visited,int r, int start) {
+		
+		if(r==0) {
+			print(visited,arr);
+			return;
+		}
+		
+		for(int i=start;i<arr.length;i++) {
+			visited[i] = true;
+			combination(arr,visited,r-1,i+1);
+			visited[i] = false;
+		}
+		
+		
+	}
+	static void print(boolean[]visited,int[]arr) {
+		String printNow = "";
+		for(int i=0;i<arr.length;i++) {
+			
+			if(visited[i]) printNow += arr[i];
+		}
+		System.out.println(printNow);
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/test/ddd.java b/Basic_Of_Algorithm/src/test/ddd.java
new file mode 100644
index 0000000..7888a06
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/ddd.java
@@ -0,0 +1,39 @@
+package test;
+
+public class ddd {
+	
+	public static void main(String[] args) {
+		
+		
+		int n = 3;
+		
+		int[][]computers = {{1,1,0},{1,1,0},{0,0,1}};
+		
+		int answer = 0;
+		
+		boolean[]visited = new boolean[computers.length];
+		
+		for(int i=0;i<computers.length;i++) {
+			
+			if(!visited[i]) {
+				dfs(visited,computers,i);
+				answer++;
+			}
+			
+		}
+		
+		System.out.println(answer);
+	}
+	static void dfs(boolean[]visited,int[][]computers,int node) {
+		
+		visited[node] = true;
+		
+		for(int i=0;i<computers.length;i++) {
+			if(!visited[i] && computers[node][i]==1) {
+				dfs(visited,computers,i);
+			}
+		}
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/test/dfs.java b/Basic_Of_Algorithm/src/test/dfs.java
new file mode 100644
index 0000000..3da9ff7
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/dfs.java
@@ -0,0 +1,57 @@
+package test;
+
+public class dfs {
+
+	static int answer = Integer.MAX_VALUE;
+	
+	static String t;
+	static boolean[] visited;
+	
+	public static void main(String[] args) {
+		
+		
+		String begin = "hit";
+		String target = "cog";
+		String [] words = {"hot", "dot", "dog", "lot", "log", "cog"};
+		
+		
+		
+		t = target;
+		
+		visited = new boolean[words.length];
+		
+		dfs(begin,words,0);
+		
+		System.out.println(answer);
+		
+		
+	}
+	
+	static void dfs(String begin, String [] words , int count) {
+		
+		if(begin.equals(t)) {
+			System.out.println(begin + " : " + count);
+			answer = Math.min(answer, count);
+			return;
+		}
+		
+		
+		for(int i=0;i<words.length;i++) {
+			int c = 0;
+			for(int j=0;j<begin.length();j++) {
+				if(words[i].charAt(j)!=begin.charAt(j)) {
+					c++;
+				}
+			}
+			
+			
+			if(!visited[i] && c==1) {
+				visited[i]= true;
+				begin = words[i];
+				dfs(begin,words,count+1);
+				visited[i] = false;
+			}
+		}
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/test/dungeon.java b/Basic_Of_Algorithm/src/test/dungeon.java
new file mode 100644
index 0000000..e83400f
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/dungeon.java
@@ -0,0 +1,42 @@
+package test;
+
+public class dungeon {
+	
+	static int answer = 0;
+	
+	public static void main(String[] args) {
+		
+	int k = 80;
+	int[][]dungeons = {{80,20},{50,40},{30,10}};
+	boolean[]visited = new boolean[dungeons.length];
+	
+	dfs(dungeons,k,visited,0);
+	
+	System.out.println(answer);
+	
+	
+	}
+	
+	static void dfs(int[][]dungeons,int k,boolean[]visited,int count) {
+		
+		
+		
+		for(int i=0;i<dungeons.length;i++) {
+			if(!visited[i] && dungeons[i][0]<=k) {
+				visited[i] = true;
+				int newK = k - dungeons[i][1];
+				dfs(dungeons,newK,visited,count+1);
+				visited[i] = false;
+			}
+			
+		}
+		
+		answer = Math.max(answer, count);
+		
+		
+	}
+
+}
+
+
+
diff --git a/Basic_Of_Algorithm/src/test/dungeons.java b/Basic_Of_Algorithm/src/test/dungeons.java
new file mode 100644
index 0000000..e46061e
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/dungeons.java
@@ -0,0 +1,35 @@
+package test;
+
+public class dungeons {
+	
+	static int answer = 0;
+	
+	public static void main(String[] args) {
+		
+		int k = 80;
+		int [][] dungeons = {{80,20},{50,40},{30,10}};
+		boolean[] visited = new boolean[dungeons.length];
+		
+		dfs(visited,dungeons,k,0);
+		
+		System.out.println(answer);
+		
+	}
+	
+	static void dfs(boolean[]visited,int[][]dungeons,int k,int count) {
+		
+		
+		for(int i=0;i<dungeons.length;i++) {
+			if(!visited[i] && dungeons[i][0]<=k) {
+				visited[i] = true;
+				int next = k -  dungeons[i][1];
+				dfs(visited,dungeons,next,count+1);
+				visited[i] = false;
+			}
+		}
+		
+	
+		answer= Math.max(answer, count);
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/test/network.java b/Basic_Of_Algorithm/src/test/network.java
new file mode 100644
index 0000000..2132cfc
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/network.java
@@ -0,0 +1,38 @@
+package test;
+
+import java.util.*;
+
+public class network {
+	
+	public static void main(String[] args) {
+		
+		int n = 3;
+		
+		int[][]computers = {{1,1,0},{1,1,0},{0,0,1}};
+		
+		int answer = 0;
+		
+		boolean[]visited = new boolean[computers.length];
+		
+		
+		for(int i=0;i<computers.length;i++) {
+			if(!visited[i]) {
+				answer++;
+				dfs(i,visited,computers);
+			}
+		}
+		
+		System.out.println(answer);
+		
+	}
+	static void dfs(int node,boolean[]visited,int[][]computers) {
+		visited[node] = true;
+		
+		for(int i=0;i<computers.length;i++) {
+			if(!visited[i] && computers[node][i]==1) {
+				dfs(i,visited,computers);
+			}
+		}
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/test/network2.java b/Basic_Of_Algorithm/src/test/network2.java
new file mode 100644
index 0000000..895d7a6
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/network2.java
@@ -0,0 +1,39 @@
+package test;
+
+import java.util.*;
+
+public class network2 {
+	
+	public static void main(String[] args) {
+		
+		int n = 3;
+		
+		int[][]computers = {{1,1,0},{1,1,0},{0,0,1}};
+		
+		int answer = 0;
+		
+		boolean[]visited = new boolean[computers.length];
+		
+		for(int i=0;i<computers.length;i++) {
+			if(!visited[i]) {
+				dfs(i,visited,computers);
+				answer++;
+			}
+		}
+		
+		System.out.println(answer);
+	}
+	static void dfs(int node,boolean[]visited,int[][]computers) {
+		
+		visited[node] = true;
+		
+		for(int i=0;i<computers.length;i++) {
+			
+			if(!visited[i] && computers[node][i]==1) {
+				dfs(i,visited,computers);
+			}
+			
+		}
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/test/no_13.java b/Basic_Of_Algorithm/src/test/no_13.java
new file mode 100644
index 0000000..b5b22b8
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/no_13.java
@@ -0,0 +1,54 @@
+package test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public class no_13 {
+
+	
+	public static void main(String[] args) {
+		
+String [] record = {"Enter uid1234 Muzi", "Enter uid4567 Prodo","Leave uid1234","Enter uid1234 Prodo","Change uid4567 Ryan"};
+		
+		HashMap<String,String> map = new HashMap<>();
+		ArrayList<String> answerList = new ArrayList<>();
+		
+		for(String str : record) {
+			
+			String temp[] = str.split(" ");
+			String action = temp[0];
+			String id = temp[1];
+			
+			if(action.equals("Leave")) continue;
+			
+			String nick = temp[2];
+			
+			map.put(id, nick);
+			
+		}
+		
+		for(String str : record) {
+			
+			String temp[] = str.split(" ");
+			String action = temp[0];
+			String id = temp[1];
+			
+			if(action.equals("Change")) continue;
+			
+			String nick = map.get(id);
+			String ans = nick + "님이 " + (action.equals("Enter") ? "들어왔습니다." : "나갔습니다.");
+			
+			answerList.add(ans);
+		
+		}
+		
+		
+		String[]answer = new String[answerList.size()];
+		
+		for(int i = 0 ; i< answerList.size();i++) answer[i] = answerList.get(i);
+		
+		for(String str : answer)System.out.println(str);
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/test/openChatting.java b/Basic_Of_Algorithm/src/test/openChatting.java
new file mode 100644
index 0000000..a68d28c
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/openChatting.java
@@ -0,0 +1,52 @@
+package test;
+
+import java.util.HashMap;
+import java.util.ArrayList;
+
+public class openChatting {
+	
+	public static void main(String[] args) {
+		
+		String[]record = {"Enter uid1234 Muzi", "Enter uid4567 Prodo","Leave uid1234","Enter uid1234 Prodo","Change uid4567 Ryan"};
+		
+		HashMap<String,String> map = new HashMap<>();
+		
+		ArrayList<String> answerList = new ArrayList<>();
+		
+		for(String str : record) {
+			
+			String []temp = str.split(" ");
+			
+			String action = temp[0];
+			String id = temp[1];
+			if(action.equals("Leave"))continue;
+			String nick = temp[2];
+			
+			map.put(id, nick);
+			
+		}
+		
+		
+		for(String str : record) {
+			
+			String []temp = str.split(" ");
+			
+			String action = temp[0];
+			String id = temp[1];
+			if(action.contains("Change"))continue;
+			String nick = map.get(id);
+			
+			String ans = nick+"님이 " + (action.equals("Enter") ? "들어왔습니다." : "나갔습니다."); 
+			
+			answerList.add(ans);
+		}
+		
+		String[]answer = new String[answerList.size()];
+		
+		for(int i=0;i<answer.length;i++)answer[i] = answerList.get(i);
+		
+		for(String str : answer) System.out.println(str);
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/test/parking.java b/Basic_Of_Algorithm/src/test/parking.java
new file mode 100644
index 0000000..9aec947
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/parking.java
@@ -0,0 +1,76 @@
+package test;
+
+import java.util.*;
+
+public class parking {
+
+	public static void main(String[] args) {
+		
+			int[]fees= {180, 5000, 10, 600};
+			String[]records = {"05:34 5961 IN", "06:00 0000 IN", "06:34 0000 OUT", "07:59 5961 OUT", "07:59 0148 IN", "18:59 0000 IN", "19:09 0148 OUT", "22:59 5961 IN", "23:00 5961 OUT"}; 
+		
+		   HashMap<String,Integer> map = new HashMap<>();
+		   TreeMap<String,Integer> tree = new TreeMap<>();
+			
+		    for(String s : records) {
+				
+				String []temp = s.split(" ");
+				int time = timeChange(temp[0]);
+				String num = temp[1];
+				String action = temp[2];
+				
+				if(action.equals("IN")) {
+					if(!tree.containsKey(num)) tree.put(num, 0);
+					map.put(num, time);
+				}
+				else {
+					
+					tree.put(num, tree.get(num) + (time - map.get(num)));
+					map.remove(num);
+				}
+			}
+				
+			if(!map.isEmpty()) {
+				for(String key : map.keySet()) {
+					tree.put(key, tree.get(key) + (23*60+59) - map.get(key));
+					
+				}
+			}
+			
+			ArrayList<Integer>answerList = new ArrayList<>();
+			
+			for(String key : tree.keySet()) {
+				
+				double time = tree.get(key);
+				
+				if(time<=fees[0]) {
+					answerList.add(fees[1]);
+		        }else {
+					time = time - fees[0];
+					double cal = time/fees[2];
+					int extraTime = (int) Math.ceil(cal);
+					int fee = (extraTime * fees[3]) + fees[1];
+					answerList.add(fee);			
+				}
+			}
+				
+			int[]answer = new int[answerList.size()];
+			for(int i=0;i<answerList.size();i++)answer[i] = answerList.get(i);
+			
+			for(int i : answer )System.out.println(i);
+				
+			}
+			static int timeChange(String str) {
+				
+				String[]temp = str.split(":");
+				
+				int hour = Integer.parseInt(temp[0]) * 60;
+				int min = Integer.parseInt(temp[1]) + hour;
+				
+				return min;
+				
+				
+			}
+			
+		}
+
diff --git a/Basic_Of_Algorithm/src/test/snail.java b/Basic_Of_Algorithm/src/test/snail.java
new file mode 100644
index 0000000..17833e0
--- /dev/null
+++ b/Basic_Of_Algorithm/src/test/snail.java
@@ -0,0 +1,109 @@
+package test;
+
+import java.io.*;
+
+public class snail {
+	
+	public static void main(String[] args) throws IOException {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int n = Integer.parseInt(br.readLine());
+		int t = Integer.parseInt(br.readLine());
+		solve1(n,t); // 바깥쪽에서 안쪽
+		solve2(n,t); // 안쪽에서 바깥쪽
+		
+	}
+
+	// 바깥쪽에서 안쪽으로 돌기
+	static void solve1(int n, int t) {
+		int[][] map = new int[n][n];
+		int value = n*n;
+		int x=0,y=0;
+		int time=0;
+		int limit =n;
+		while(value>0) {
+			x=time;
+			for(int i=y; i<limit; i++) {
+				map[i][x] = value--;
+			}
+			
+			y=limit-1;
+			for(int i=x+1; i<limit; i++) {
+				map[y][i] = value--;
+			}
+			
+			x=limit-1;
+			for(int i=y-1; i>=time; i--) {
+				map[i][x] = value--;
+			}
+			
+			y=time;
+			for(int i=x-1; i>time; i--) {
+				map[y][i] = value--;
+			}
+			time++;
+			limit--;
+			y=time;
+		}
+		
+		StringBuilder sb = new StringBuilder();
+		int tx=0, ty=0;
+		for(int i=0; i<n; i++) {
+			for(int j=0; j<n; j++) {
+				if(t==map[i][j]) {
+					ty=i+1;
+					tx=j+1;
+				}
+				sb.append(map[i][j] +" ");
+			}
+			sb.append("\n");
+		}
+		sb.append(ty+" "+tx);
+		System.out.println(sb.toString());
+	}
+
+	// 안쪽에서 바깥쪽으로 돌기
+	static void solve2(int n, int t){
+		int[][] map = new int[n][n];
+		int value =1;
+		
+		int x = n/2, y=n/2;
+		
+		int limit =1;
+		while(true) {
+			for(int i=0; i<limit; i++) {
+				map[y--][x] = value++;
+			}
+			if(value-1 == n*n) break;
+			for(int i=0; i<limit; i++) {
+				map[y][x++] = value++;
+			}
+			
+			limit++;
+			for(int i=0; i<limit; i++) {
+				map[y++][x] = value++;
+			}
+			
+			for(int i=0; i<limit; i++) {
+				map[y][x--] = value++;
+			}
+			limit++;
+		}
+		
+		StringBuilder sb = new StringBuilder();
+		int tx=0, ty=0;
+		for(int i=0; i<n; i++) {
+			for(int j=0; j<n; j++) {
+				if(t==map[i][j]) {
+					ty=i+1;
+					tx=j+1;
+				}
+				sb.append(map[i][j] +" ");
+			}
+			sb.append("\n");
+		}
+		sb.append(ty+" "+tx);
+		System.out.println(sb.toString());
+	}
+	
+}
diff --git "a/Basic_Of_Algorithm/src/test/\352\267\200\353\202\251\353\262\225.java" "b/Basic_Of_Algorithm/src/test/\352\267\200\353\202\251\353\262\225.java"
new file mode 100644
index 0000000..ae7f8f7
--- /dev/null
+++ "b/Basic_Of_Algorithm/src/test/\352\267\200\353\202\251\353\262\225.java"
@@ -0,0 +1,34 @@
+package test;
+
+import java.util.Scanner;;
+
+public class 귀납법 {
+
+	public static void main(String[] args) {
+		
+		
+		Scanner scan = new Scanner(System.in);
+		
+		int n = scan.nextInt();
+		
+		int m = test(n);
+		
+		int l = 0;
+		
+		for(int i=n;i>-1;i--) {
+			l += i;
+		}
+		
+		if(l==m) System.out.println("이게 귀납법");
+		
+		System.out.println(l);
+		System.out.println(m);
+	}
+	
+	static int test(int n) {
+		
+		if(n==0) return n;
+		return n+test(n-1);
+		
+	}
+}
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..8376b04
--- /dev/null
+++ b/README.md
@@ -0,0 +1,2 @@
+# Basic_Of_Algorithm
+알고리즘 기초 예제 및 테스트