Basic of algorithm

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>

Basic_Of_Algorithm/.gitignore

@@ -0,0 +1 @@
+/bin/

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>

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

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});
+				}
+
+			}
+
+
+
+		}
+
+
+
+
+
+
+
+
+	}
+}

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);
+
+	}
+
+}

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;
+			}
+		}
+
+	}
+
+}

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);
+
+			}
+
+		}
+
+
+	}
+
+}

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);
+
+
+	}
+
+}