오랜만에 프로그래머스

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

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

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