diff --git a/Basic_Of_Algorithm/.classpath b/Basic_Of_Algorithm/.classpath
new file mode 100644
index 0000000..51a8bba
--- /dev/null
+++ b/Basic_Of_Algorithm/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/Basic_Of_Algorithm/.gitignore b/Basic_Of_Algorithm/.gitignore
new file mode 100644
index 0000000..ae3c172
--- /dev/null
+++ b/Basic_Of_Algorithm/.gitignore
@@ -0,0 +1 @@
+/bin/
diff --git a/Basic_Of_Algorithm/.project b/Basic_Of_Algorithm/.project
new file mode 100644
index 0000000..4c36376
--- /dev/null
+++ b/Basic_Of_Algorithm/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Basic_Of_Algorithm</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/Basic_Of_Algorithm/.settings/org.eclipse.jdt.core.prefs b/Basic_Of_Algorithm/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..ec1937b
--- /dev/null
+++ b/Basic_Of_Algorithm/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,12 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.release=disabled
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/bfs.java b/Basic_Of_Algorithm/src/Today22_05_11/bfs.java
new file mode 100644
index 0000000..1d7af4b
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today22_05_11/bfs.java
@@ -0,0 +1,76 @@
+package Today22_05_11;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+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;
+		
+		int[][]temp = new int[maps.length][maps[0].length];
+		
+		temp[0][0] = 1;
+		
+		long start = System.nanoTime();
+		
+		bfs(maps,temp);
+		
+		answer = temp[maps.length-1][maps[0].length-1];
+		
+		System.out.println(answer);
+		
+		long end = System.nanoTime();
+		
+		System.out.println("걸린 시간 : " + (end-start)+" 나노초"); //10억분의 1초 반환
+		
+		
+	}
+	
+	static void bfs(int[][]maps,int[][]temp) {
+		
+		Queue<int[] > q = new LinkedList<>();
+		
+		q.add(new int[] {0,0});
+
+		int []id = {1,0,-1,0};
+		int []jd = {0,1,0,-1};
+		
+		while(!q.isEmpty()) {
+			
+			int [] currentCount = q.poll();
+			
+			int ci = currentCount[0];
+			int cj = currentCount[1];
+			
+			for(int d=0;d<4;d++) {
+				
+				int ni = ci+id[d];
+				int nj = cj+jd[d];
+				
+				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[ci][cj] +1;
+					q.add(new int[] {ni,nj});
+				}
+				
+			}
+			
+			
+			
+		}
+		
+		
+		
+		
+		
+		
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/bfsAgain.java b/Basic_Of_Algorithm/src/Today22_05_11/bfsAgain.java
new file mode 100644
index 0000000..0a1800b
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today22_05_11/bfsAgain.java
@@ -0,0 +1,68 @@
+package Today22_05_11;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class bfsAgain {
+
+	static int answer = 0;
+	
+	public static void main(String[] args) {
+		
+		String [] saem = {"SOOOX","OXXOX","OXOOX","OXOXX","EOOXX"};
+		
+		char[][]maps = new char[saem.length][saem[0].length()];
+
+		int[] start = {};
+		
+		for(int i=0;i<saem.length;i++) {
+			for(int j=0;j<saem[0].length();j++) {
+				maps[i][j] = saem[i].charAt(j);
+				if(maps[i][j]=='S') start = new int[] {i,j};
+			}
+		}
+		
+		int [][]temp = new int[maps.length][maps[0].length];
+		
+		temp[start[0]][start[1]] = 0;
+		
+		
+		Queue<int[]>q = new LinkedList<>();
+		
+		q.offer(new int[] {start[0],start[1]});
+		
+		int [] di = {1,0,-1,0};
+		int [] dj = {0,1,0,-1};
+		
+		outerLoop:
+		while(!q.isEmpty()) {
+			
+			int []cur = q.poll();
+			
+			int ci = cur[0];
+			int cj = cur[1];
+			
+			for(int d=0;d<4;d++) {
+				int ni = ci + di[d];
+				int nj = cj + dj[d];
+				if(ni<0||nj<0||maps.length-1<ni||maps[0].length-1<nj) continue;
+				if(maps[ni][nj]=='E') {
+					temp[ni][nj] = temp[ci][cj]+1;
+					answer = temp[ni][nj] ;
+					break outerLoop;
+				}
+				if(maps[ni][nj]=='O'&&temp[ni][nj]==0) {
+					temp[ni][nj] = temp[ci][cj]+1;
+					q.offer(new int[] {ni,nj});
+				}
+				
+				
+			}
+		
+		}
+		
+		System.out.println(answer);
+		
+	}
+	
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/combi_dfs.java b/Basic_Of_Algorithm/src/Today22_05_11/combi_dfs.java
new file mode 100644
index 0000000..693874f
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today22_05_11/combi_dfs.java
@@ -0,0 +1,52 @@
+package Today22_05_11;
+
+public class combi_dfs {
+
+	public static void main(String[] args) {
+		
+		int[]arr = {1,2,3};
+		
+		boolean[] visited = new boolean[arr.length];
+		
+		 combi(arr,visited,0,2);
+		 
+		 dfs(arr,visited,"");
+		
+		
+	}
+	static void combi(int[]arr,boolean[]visited,int start,int r) {
+		
+		if(r==0) {
+			for(int i=0;i<arr.length;i++) {
+				if(visited[i]) System.out.print(arr[i]+" ");
+			}
+			System.out.println();
+		}
+		
+		for(int i=start;i<arr.length;i++) {
+			
+			visited[i] = true;
+			combi(arr,visited,i+1,r-1);
+			visited[i] = false;
+			
+		}
+	}
+	
+	static void dfs(int[]arr,boolean[]visited,String print) {
+		
+		System.out.println(print);
+		
+		if(print.length()==arr.length)return;
+		
+		for(int i=0;i<arr.length;i++) {
+			if(!visited[i]) {
+				visited[i] = true;
+				String newOne = print + arr[i];
+				dfs(arr,visited,newOne);
+				visited[i] = false;
+			}
+		}
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/dfs.java b/Basic_Of_Algorithm/src/Today22_05_11/dfs.java
new file mode 100644
index 0000000..3190a0d
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today22_05_11/dfs.java
@@ -0,0 +1,55 @@
+package Today22_05_11;
+
+public class dfs {
+	
+	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;
+		
+		int[][]temp = new int[maps.length][maps[0].length];
+		
+		temp[0][0] = 1;
+		
+		long start = System.nanoTime();
+		
+		dfs(maps,temp,0,0);
+		
+		answer = temp[maps.length-1][maps[0].length-1];
+		
+		System.out.println(answer);
+		
+		long end = System.nanoTime();
+		
+		System.out.println("걸린 시간 : " + (end-start)+" 나노초"); //10억분의 1초 반환
+		
+	}
+	
+	static void dfs(int[][]maps,int[][]temp,int i,int j) {
+		
+		int[]id = {1,0,-1,0};
+		int[]jd = {0,1,0,-1};
+		
+		
+		for(int d=0;d<4;d++) {
+			
+			int newI = i + id[d];
+			int newJ = j + jd[d];
+			
+			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;
+				temp[i][j] = 1;
+				dfs(maps,temp,newI,newJ);
+				
+			}
+			
+		}
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/test.java b/Basic_Of_Algorithm/src/Today22_05_11/test.java
new file mode 100644
index 0000000..d86f3b7
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today22_05_11/test.java
@@ -0,0 +1,79 @@
+package Today22_05_11;
+
+import java.util.*;
+
+public class test {
+
+	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[]result = new int[query.length];
+		
+		
+		for(int i=0;i<info.length;i++) {
+			String[]temp = info[i].split(" ");
+			dfs(temp,"",0);
+		}
+		
+		for(String key : infoMap.keySet()) {
+			Collections.sort(infoMap.get(key));
+		}
+		
+		for(int i=0;i<query.length;i++) {
+			
+			query[i] = query[i].replaceAll(" and ", "");
+			String[]temp = query[i].split(" ");
+			result[i] = infoMap.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 = infoMap.get(key);
+		
+		int start = 0;
+		int end = list.size()-1;
+		
+		while(start<=end) {
+			
+			int mid = (start+end)/2;
+			
+			if(score>list.get(mid)) start = mid+1;
+			else if(score<=list.get(mid)) end = mid-1;
+			
+		}
+		
+		
+		return list.size() - start;
+		
+	}
+	
+	static void dfs(String temp[],String now,int depth) {
+		
+		if(depth==4) {
+			if(!infoMap.containsKey(now)) {
+				infoMap.put(now, new ArrayList<>());
+			}
+			infoMap.get(now).add(Integer.parseInt(temp[4]));
+			return;
+		}
+		
+		
+		dfs(temp,now+"-",depth+1);
+		dfs(temp,now+temp[depth],depth+1);
+		
+		
+	}
+
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/twoPointer.java b/Basic_Of_Algorithm/src/Today22_05_11/twoPointer.java
new file mode 100644
index 0000000..202e7d6
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today22_05_11/twoPointer.java
@@ -0,0 +1,76 @@
+package Today22_05_11;
+
+import java.util.Arrays;
+
+public class twoPointer {
+
+	
+	public static void main(String[] args) {
+		
+		
+		int []arr = {1,2,2,3,3,4,5};
+		int target = 4;
+		//두개 합쳐서 4가 나오는 경우
+		
+		Arrays.sort(arr);
+		
+		int start = 0;
+		int end = arr.length-1;
+		int answer = 0;
+		
+		while(start<=end) {
+			
+			int sum = arr[start] + arr[end];
+			
+			if(sum>target) end--;
+			else if(sum==target) {
+				System.out.println(start+","+end);
+				answer++;
+				start++;
+				end--;
+			}else if(sum<target) {
+				start++;
+			}
+			
+			
+			
+			
+		}
+		
+		System.out.println("답: "+ answer);
+		
+		System.out.println();
+		
+		start = 0;
+		end = arr.length-1;
+		answer = 0;
+				
+		
+		while(true) {
+			
+			if(start==end) break;
+			
+			
+			int sum = arr[start] + arr[end];
+			
+			//=일때 end--해주고 어차피 밑에서 같은 값이면 answer++해주니까 두번 쓰지 말자 이거지..
+			//물론 세번으로 나눠도 크게 상관 없을듯. 가독성에 더 좋을지도
+			//아무튼, 인덱스 값만 조절, 같은지 다른지는 밑에서 파별 후 answer++ 
+			if(sum>=target) end--;
+			else if(sum<target) start++;
+			
+			
+			if(sum==target) {
+				System.out.println(start+","+end);
+				answer++;
+			}
+			
+			
+			
+		}
+		
+		System.out.println("답: "+ answer);
+		
+		
+	}
+}
diff --git a/Basic_Of_Algorithm/src/Today22_05_11/twoPointerRangeSum.java b/Basic_Of_Algorithm/src/Today22_05_11/twoPointerRangeSum.java
new file mode 100644
index 0000000..e515221
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today22_05_11/twoPointerRangeSum.java
@@ -0,0 +1,39 @@
+package Today22_05_11;
+
+import java.util.Arrays;
+
+public class twoPointerRangeSum {
+	
+	public static void main(String[] args) {
+		
+		int [] arr = {2,1,1};
+		int target = 2;
+		//구간 합이 3이 되는 애들 (답 3나와야됨)
+		
+		Arrays.sort(arr);
+		
+		int l = 0;
+		int r = 0;
+		int sum = 0;
+		int answer = 0;
+		
+		while(true) {
+	
+			//인덱스에서 뽑아낸 애들보다 원래 값이 뒤에 온다고 생각해야됨
+			if(sum>=target) sum -= arr[l++];
+			else if(r==arr.length) break;
+			else if(sum<target) sum += arr[r++];
+			
+			if(sum==target) answer++;
+			
+			
+		}
+		
+	
+		
+		System.out.println(answer);
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_10/bfs.java b/Basic_Of_Algorithm/src/Today_22_05_10/bfs.java
new file mode 100644
index 0000000..1059f22
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_10/bfs.java
@@ -0,0 +1,48 @@
+package Today_22_05_10;
+
+import java.util.*;
+
+public class bfs {
+
+	public static void main(String[] args) {
+			
+		//index랑 맞추려고 첫번째꺼는 비워놓을거임
+		int [][] graph = {{}, {2,3,8}, {1,6,8}, {1,5}, {5,7}, {3,4,7}, {2}, {4,5}, {1,2}};
+
+		boolean[] visited = new boolean[graph.length];
+		
+		int start = 1;
+		
+		System.out.println(bfs(start,graph,visited));
+
+		
+		
+	}
+	static String bfs(int start,int[][]graph,boolean[]visited) {
+		
+		StringBuilder sb = new StringBuilder();
+		
+		Queue<Integer> q = new LinkedList<Integer>();
+		
+		q.offer(start);
+		
+		visited[start] = true;
+		
+		while(!q.isEmpty()) {
+			int nodeIndex = q.poll();
+			sb.append(nodeIndex + " -> ");
+			
+			for(int i=0;i<graph[nodeIndex].length;i++) {
+				int temp = graph[nodeIndex][i];
+				
+				if(!visited[temp]) {
+					visited[temp] = true;
+					q.offer(temp);
+				}
+			}
+		}
+		
+		return sb.toString();
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_10/bfsExProgrammers.java b/Basic_Of_Algorithm/src/Today_22_05_10/bfsExProgrammers.java
new file mode 100644
index 0000000..3cb1090
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_10/bfsExProgrammers.java
@@ -0,0 +1,63 @@
+package Today_22_05_10;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class bfsExProgrammers {
+
+	public static void main(String[] args) throws Exception {
+		
+		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;
+		int[][]move = {{1,0},{0,1},{-1,0},{0,-1}};
+		Queue<Position> que = new LinkedList<>();
+		int[][] count = new int[maps.length][maps[0].length];
+		
+		que.add(new Position(0,0));
+		count[0][0] = 1;
+		
+		while(!que.isEmpty()) {
+			
+			Position cur = que.poll();
+			
+			int currentCount = count[cur.y][cur.x];
+			
+			for(int i=0;i<4;i++) {
+				Position p = new Position(cur.x+move[i][1],cur.y+move[i][0]);
+				
+				if(p.x<0||p.y<0||maps[0].length-1<p.x||maps.length-1<p.y)continue;
+				
+				if(maps[p.y][p.x]==0)continue;
+				
+				count[p.y][p.x] = currentCount+1;
+				maps[p.y][p.x] = 0;
+				que.offer(p);
+				
+			}
+			
+			
+		}
+		
+		
+		
+		
+		
+		
+		answer = count[maps.length-1][maps[0].length-1];
+		if(answer==0)System.out.println(-1);
+		else System.out.println(answer);
+		
+		
+	}
+	
+}
+
+class Position{
+	int x,y;
+	
+	public Position(int x,int y) {
+		this.x = x;
+		this.y = y;
+	}
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/Today_22_05_10/combi_dfs.java b/Basic_Of_Algorithm/src/Today_22_05_10/combi_dfs.java
new file mode 100644
index 0000000..42c2869
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_10/combi_dfs.java
@@ -0,0 +1,81 @@
+package Today_22_05_10;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class combi_dfs {
+	
+	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/Today_22_05_10/combination.java b/Basic_Of_Algorithm/src/Today_22_05_10/combination.java
new file mode 100644
index 0000000..5f21d8d
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_10/combination.java
@@ -0,0 +1,80 @@
+package Today_22_05_10;
+
+public class combination {
+	
+	public static void main(String[] args) {
+		
+
+		int[]arr = {1,2,3};
+		
+		boolean[]visited = new boolean[arr.length];
+		
+		CombinationClass combi = new CombinationClass();
+		
+		
+		for(int i=1;i<=arr.length;i++) {
+			
+			combi.combi(arr,i,visited,0);
+		}
+		
+	}
+
+}
+
+ class CombinationClass{
+	
+		
+	 void combi(int[]arr,int goal,boolean[]visited,int start) {
+		 
+		 
+		 if(goal==0) {
+			 print(arr,visited);
+			 return;
+		 }
+		 
+		 for(int i=start;i<arr.length;i++) {
+			 if(!visited[i]) {
+				 visited[i] = true;
+				 combi(arr,goal-1,visited,i+1);
+				 visited[i] = false;
+			 }
+		 }
+		 
+		 
+		 
+	 }
+	
+		
+		
+	
+	
+	 void print(int[]arr,boolean [] visited) {
+		 
+		int check = 0 ;
+		String now = "";
+		 for(int i=0;i<arr.length;i++) {
+			 if(visited[i]) {
+				 now += arr[i] + " ";
+				 check++;
+			 }
+			 
+		 }
+		 
+		 if(check>2) {
+			 System.out.println("3개 조합");
+			 System.out.println(now);
+		 }else if(check>1) {
+			 System.out.println("2개 조합");
+			 System.out.println(now);
+		 }else {
+			 System.out.println("1개 조합");
+			 System.out.println(now);
+		 }
+		 
+		 
+		 
+	 }
+	
+	
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_10/dfs.java b/Basic_Of_Algorithm/src/Today_22_05_10/dfs.java
new file mode 100644
index 0000000..5f88868
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_10/dfs.java
@@ -0,0 +1,46 @@
+package Today_22_05_10;
+
+public class dfs {
+	
+	public static void main(String[] args) {
+		
+		int[]arr = {1,2,3};
+		
+		boolean[]visited = new boolean[arr.length];
+		
+		dfsClass dfsclass = new dfsClass();
+		
+		dfsclass.dfs(arr,visited,"",arr.length);
+		
+	}
+
+}
+class dfsClass{
+	
+		//dfs를 위한 메소드
+		 void dfs(int[]arr,boolean[]visited,String now,int count){
+			
+			print(now);
+			
+			if(count==0) return;
+			
+			for(int i=0;i<arr.length;i++) {
+				if(!visited[i]) {
+					visited[i] = true;
+					String newOne = now + arr[i];
+					dfs(arr,visited,newOne,count-1);
+					visited[i] = false;
+				}
+			}
+			
+			
+		}
+		
+		//출력을 위한 메소드
+		 void print(String now) {
+			System.out.println(now);
+		}
+		
+		
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_10/dfsExProgrammers.java b/Basic_Of_Algorithm/src/Today_22_05_10/dfsExProgrammers.java
new file mode 100644
index 0000000..93e3633
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_10/dfsExProgrammers.java
@@ -0,0 +1,51 @@
+package Today_22_05_10;
+
+
+public class dfsExProgrammers {
+
+	public static void main(String[] args) throws Exception {
+		
+		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;
+		
+		int[][]temp = new int[maps.length][maps[0].length];
+		
+		temp[0][0] = 1;
+		
+		dfs(0,0,maps,temp);
+		
+		answer = temp[temp.length-1][temp[0].length-1];
+		
+		System.out.println(answer);
+		
+		
+	}
+	
+	static void dfs(int i,int j,int[][]maps,int[][]temp) {
+		
+		int[]di = {1,0,-1,0};
+		int[]dj = {0,1,0,-1};
+		
+		
+		for(int d=0;d<4;d++) {
+			
+			int newI = i + di[d];
+			int newJ = j + dj[d];
+			
+			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;
+				temp[i][j] = 1;
+				dfs(newI,newJ,maps,temp);
+				
+			}
+			
+		}
+		
+		
+		
+	}
+	
+}
\ No newline at end of file
diff --git a/Basic_Of_Algorithm/src/Today_22_05_10/test.java b/Basic_Of_Algorithm/src/Today_22_05_10/test.java
new file mode 100644
index 0000000..17d323f
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_10/test.java
@@ -0,0 +1,61 @@
+package Today_22_05_10;
+
+import java.util.*;
+
+public class test {
+	
+	public static void main(String[] args) {
+		
+		int [][] graph = {{}, {2,3,8}, {1,6,8}, {1,5}, {5,7}, {3,4,7}, {2}, {4,5}, {1,2}};
+		
+		boolean [] visited = new boolean[graph.length];
+		
+		int start = 1;
+		
+		visited[start] = true;
+	
+		String answer = bfs(graph,visited,start);
+		
+		
+		System.out.println(answer);
+		
+		
+	}
+	
+	static String bfs(int[][]graph,boolean[]visited,int start) {
+		
+		StringBuilder sb = new StringBuilder();
+		
+		Queue<Integer> q= new LinkedList<>();
+		
+		q.offer(start);
+		
+		while(!q.isEmpty()) {
+			
+			int index = q.poll();
+			
+			sb.append(index + "-> ");
+			
+			for(int i=0;i<graph[index].length;i++) {
+				
+				int temp = graph[index][i];
+				
+				if(!visited[temp]) {
+					visited[temp] = true;
+					q.offer(temp);
+					
+				}
+				
+			}
+
+		}
+		
+			
+		return sb.toString();
+		
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_10/testCode.java b/Basic_Of_Algorithm/src/Today_22_05_10/testCode.java
new file mode 100644
index 0000000..e60419a
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_10/testCode.java
@@ -0,0 +1,89 @@
+package Today_22_05_10;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class testCode {
+	
+	public static void main(String[] args) {
+		
+		String[]hansaem = {"SOOOX","OXXOX","OXOOX","OXOXX","EOOXX"};
+		
+		char[][] map = new char[hansaem.length][hansaem[0].length()];
+		
+		for(int i=0;i<hansaem.length;i++) {
+			for(int j=0;j<hansaem[0].length();j++) {
+				map[i][j] = hansaem[i].charAt(j);
+			}
+		}
+		
+		int[][] count = new int[map.length][map[0].length];
+		
+		
+		int [] start = {};
+		int [] end = {};
+		
+		int[][]move = {{0,1},{1,0},{-1,0},{-1,-0}};
+		
+		for(int i=0;i<map.length;i++) {
+			for(int j=0;j<map[0].length;j++) {
+				if(map[i][j]=='S') start = new int[]{i,j};
+				if(map[i][j]=='E') end = new int[] {i,j};
+			}
+		}
+		
+		Queue<Position2> que = new LinkedList<>();
+		
+		que.add(new Position2(start[0],start[1]));
+		
+		count[start[0]][start[1]] = 0;
+		
+		int answer = -1;
+		
+		while(!que.isEmpty()) {
+			
+			Position2 current = que.poll();
+			
+			int currentCount = count[current.y][current.x];
+			if(map[current.y][current.x]=='E') {
+				
+				answer = currentCount;
+				
+				break;
+			}
+			
+			
+			for(int i=0;i<4;i++) {
+				
+				Position2 p = new Position2(current.y+move[i][0],current.x+move[i][1]);
+				
+				if(p.y<0||p.x<0||map.length-1<p.y||map[0].length-1<p.x)continue;
+				if(map[p.y][p.x]=='X') continue;
+				
+				count[p.y][p.x] = currentCount+1;
+				que.add(p);
+				
+				
+			}
+			
+			
+		}
+		
+		
+		System.out.println(answer);
+		
+	}
+
+}
+
+class Position2 {
+	
+	int x, y;
+	
+	public Position2(int x, int y) {
+		this.x  = x;
+		this.y = y;
+		
+	}
+	
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_10/twoPointer.java b/Basic_Of_Algorithm/src/Today_22_05_10/twoPointer.java
new file mode 100644
index 0000000..36d4826
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_10/twoPointer.java
@@ -0,0 +1,53 @@
+package Today_22_05_10;
+
+import java.util.Arrays;
+
+public class twoPointer {
+	
+	public static void main(String[] args) {
+		
+		int[] arr = {1,3,2,2,3,1};
+		int target = 4;
+		//2개 뽑아 더해서 4가 되는 경우 {1,3}{2,2}{2,2} 3개 나와야 됨
+ 		
+		Arrays.sort(arr);
+		
+		for(int i : arr)System.out.print(i+",");
+		
+		System.out.println();
+		
+		
+		int answer = 0 ;
+		
+		int start = 0;
+		int end = arr.length-1;
+		
+		
+		while(start<=end) {
+			
+		int sum = arr[start] + arr[end];
+		
+		if(sum<target) {
+			start++;
+		}else if(sum>target) {
+			end--;
+		}else if(sum==target) {
+			System.out.println("index : {"+start+" , "+end+"}");
+			answer++;
+			end--;
+			
+		}
+		
+			
+			
+			
+			
+		}
+		
+		System.out.println(answer);
+		
+		
+		
+	}
+
+}
diff --git a/Basic_Of_Algorithm/src/Today_22_05_10/twoPointerRangeSum.java b/Basic_Of_Algorithm/src/Today_22_05_10/twoPointerRangeSum.java
new file mode 100644
index 0000000..8d503d4
--- /dev/null
+++ b/Basic_Of_Algorithm/src/Today_22_05_10/twoPointerRangeSum.java
@@ -0,0 +1,45 @@
+package Today_22_05_10;
+
+import java.util.Arrays;
+
+public class twoPointerRangeSum {
+
+	public static void main(String[] args) {
+		
+		
+		int[]arr = {1,1,2,4};
+	
+		//조합 뽑아내서 8이 되는 경우의 수
+		
+		
+		int target = 4;
+		
+		int answer = 0;
+		
+		int l = 0;
+		int r = 0;
+		int sum = 0;
+		
+		while(true) {
+			
+			if(sum>target) sum -= arr[l++];
+			else if(sum==target) {
+				System.out.println(sum+","+l+","+r);
+				answer++;
+				sum -=arr[l++];
+			}else if(sum<target) {
+				sum += arr[r++];
+			}
+		
+			if(l==arr.length&&r==arr.length)break;
+			
+			
+		}
+		
+		
+		System.out.println(answer);
+		
+		
+	}
+	
+}