[유병규-12주차 알고리즘 스터디]

유병규_12주차/[BOJ-1327] 소트 게임.java

@@ -0,0 +1,88 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+	private static int n, k;
+	private static Set<String> set;
+	private static int result;
+	private static String goal;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        n = Integer.parseInt(st.nextToken());
+        k = Integer.parseInt(st.nextToken());
+
+        int[] number = new int[n];
+        int[] temp = new int[n];
+        st = new StringTokenizer(br.readLine());
+        for(int i=0; i<n; i++) {
+        	temp[i] = number[i] = Integer.parseInt(st.nextToken());
+        }
+
+        Arrays.sort(temp);
+        goal = Arrays.toString(temp);
+
+        set = new HashSet<>();
+        set.add(Arrays.toString(number));
+
+        result = Integer.MAX_VALUE;
+        bfs(number);
+
+        if(result == Integer.MAX_VALUE) System.out.println(-1);
+        else System.out.println(result);
+    }
+
+    private static void bfs(int[] arr) {
+    	Queue<Node> q = new LinkedList<>();
+    	q.offer(new Node(arr, 0));
+    	set.add(Arrays.toString(arr));
+
+    	while(!q.isEmpty()) {
+    		Node node = q.poll();
+
+    		if(node.count > result) continue;
+    		if(goal.equals(node.toString())) {
+    			result = node.count;
+    			continue;
+    		}
+
+    		for(int i=0; i+k-1<n; i++) {
+    			node.swap(i, i+k-1);
+    			if(set.contains(node.toString())) {
+    				node.swap(i, i+k-1);
+    				continue;
+    			}
+    			q.offer(new Node(node.arr, node.count+1));
+    			set.add(node.toString());
+    			node.swap(i, i+k-1);
+    		}
+    	}
+    }
+
+	private static class Node{
+		int[] arr;
+		int count;
+
+		public Node(int[] arr, int count) {
+			this.arr = Arrays.copyOf(arr, arr.length);
+			this.count = count;
+		}
+
+		public void swap(int left, int right) {
+			while(left < right) {
+				int temp = arr[left];
+				arr[left] = arr[right];
+				arr[right] = temp;
+				left++;
+				right--;
+			}
+		}
+
+		@Override
+		public String toString() {
+			return Arrays.toString(arr);
+		}
+	}
+}

유병규_12주차/[BOJ-1405] 미친 로봇.java

@@ -0,0 +1,53 @@
+import java.io.*;
+import java.util.*;
+import java.math.BigDecimal;
+
+public class Main {
+	private static boolean[][] visited;
+	private static int n;
+	private static double[] percent;
+	private static int[][] d = {{0,1},{0,-1},{1,0},{-1,0}};
+	private static double total;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        n = Integer.parseInt(st.nextToken());
+        percent = new double[4];
+        for(int i=0; i<4; i++) {
+        	percent[i] = Integer.parseInt(st.nextToken()) / 100.0;
+        }
+
+        if(n == 1) {
+        	System.out.println(1.0);
+        	return;
+        }
+
+        visited = new boolean[2*n+1][2*n+1];
+        visited[n][n] = true;
+        dfs(1, n, n, 0, "");
+
+        BigDecimal bd = new BigDecimal(Double.toString(total));
+        System.out.println(bd.toPlainString());
+    }
+    private static String[] p = {"E","W","S","N"};
+    private static void dfs(double current, int x, int y, int dept, String path) {
+    	if(dept == n) {
+    		total += current;
+    		return;
+    	}
+
+    	for(int i=0; i<d.length; i++) {
+    		if(percent[i] == 0) continue;
+    		int nx = x+d[i][0];
+    		int ny = y+d[i][1];
+    		if(visited[nx][ny]) continue;
+    		visited[nx][ny] = true;
+    		dfs(current * percent[i], nx, ny, dept+1, path+p[i]);
+    		visited[nx][ny] = false;
+    	}
+
+    }
+}

유병규_12주차/[BOJ-21278] 호석이 두 마리 치킨.java

@@ -0,0 +1,67 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int n = Integer.parseInt(st.nextToken());
+        int m = Integer.parseInt(st.nextToken());
+
+        //1. dist 배열 준비
+        //1-1. dist 배열 최댓값으로 초기화
+        int[][] dist = new int[n][n];
+        for(int i=0; i<n; i++) {
+        	Arrays.fill(dist[i], (int) 1e9);
+        }
+
+        //1-2. 자기 자신 거리는 0으로 설정
+        for(int i=0; i<n; i++) {
+        	for(int j=0; j<n; j++) {
+        		if(i==j) dist[i][j] = 0;
+        	}
+        }
+
+        //1-3. 연결된 노드는 거리 값으로 설정
+        for(int i=0; i<m; i++) {
+        	st = new StringTokenizer(br.readLine());
+        	int a = Integer.parseInt(st.nextToken())-1;
+        	int b = Integer.parseInt(st.nextToken())-1;
+
+        	dist[a][b] = 1;
+        	dist[b][a] = 1;
+        }
+
+        //2. 플로이드-워셜 알고리즘으로 모든 노드별 모든 노드까지 최단 거리로 설정
+        for(int k=0; k<n; k++) {
+        	for(int i=0; i<n; i++) {
+        		for(int j=0; j<n; j++) {
+        			dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
+        		}
+        	}
+        }
+
+        //3. 정답 찾기
+        int min = Integer.MAX_VALUE;// 최단 거리 합
+        int a = 0;// 치킨 집 1호점
+        int b = 0;// 치킨 집 2호점
+
+        for(int i=0; i<n; i++) {// 1호점 위치
+        	for(int j=0; j<n; j++) {// 2호점 위치
+        		int sum = 0;
+        		for(int h=0; h<n; h++) {// 모든 집에서 가장 가까운 치킨 집까지의 접근성 계산
+        			sum += Math.min(dist[h][i], dist[h][j]) * 2;
+        		}
+        		if(sum < min) {// 더 작다면 값 수정
+        			min = sum;
+        			a = i+1;
+        			b = j+1;
+        		}
+        	}
+        }
+
+        System.out.println(a + " " + b + " " + min);
+    }
+}

유병규_12주차/[BOJ-2629] 양팔저울.java

@@ -0,0 +1,45 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        int n = Integer.parseInt(br.readLine());
+        int[] chu = new int[n+1];
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        int total = 0;
+        for(int i=1; i<=n; i++) {
+        	chu[i] = Integer.parseInt(st.nextToken());
+        	total += chu[i];
+        }
+
+        int[][] dp = new int[n+1][total+1];
+        //1번 추 추가
+        dp[1][chu[1]] = 1;
+
+        //2번 추부터 ~ n번까지 추가
+        for(int i=2; i<=n; i++) {
+        	for(int j=0; j<=total; j++) {
+        		if(dp[i-1][j] == 0) continue;
+        		dp[i][j] = dp[i-1][j];
+        		dp[i][j+chu[i]]++;
+        		dp[i][Math.abs(j-chu[i])]++;
+        	}
+        	dp[i][chu[i]]++;
+        }
+
+
+        int m = Integer.parseInt(br.readLine());
+        st = new StringTokenizer(br.readLine());
+        StringBuilder sb = new StringBuilder();
+        for(int i=0; i<m; i++) {
+        	int a = Integer.parseInt(st.nextToken());
+        	if(a <= total && dp[n][a] > 0) sb.append("Y ");
+        	else sb.append("N ");
+        }
+
+        System.out.println(sb.toString().trim());
+    }
+}

유병규_12주차/[BOJ-3079] 입국심사.java

@@ -0,0 +1,50 @@
+import java.io.*;
+import java.util.*;
+
+public class Main {
+	private static long[] process;
+	private static long result;
+	private static long m;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        long n = Long.parseLong(st.nextToken());
+        m = Long.parseLong(st.nextToken());
+
+        process = new long[(int) n];
+        long max = 0;
+        for(int i=0; i<n; i++) {
+        	process[i] = Long.parseLong(br.readLine());
+        	max = Math.max(max, process[i]);
+        }
+        result = Long.MAX_VALUE;
+
+        long left = 0;
+        long right = max*m;
+        while(left <= right) {
+        	long mid = left + (right-left)/2;
+
+        	long count = counting(mid);
+        	if(count >= m) {
+        		result = Math.min(result, mid);
+        		right = mid-1;
+        		continue;
+        	}
+        	left = mid+1;
+        }
+
+        System.out.println(result);
+    }
+
+	private static long counting(long mid) {
+		long count = 0;
+		for(int i=0; i<process.length; i++) {
+			if(count > m) break;
+			count += mid/process[i];
+		}
+
+		return count;
+	}
+}