2조 김민성/11월 1주차 / 목

minsung/S2_BinarySearch/BOJ_12015_LonggestIncreas.java

@@ -0,0 +1,142 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+
+public class BOJ_12015_LonggestIncreas {
+	public static void main(String[] args) throws NumberFormatException, IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int N = Integer.parseInt(br.readLine());
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		// 이떄 맨 앞 부터 linkedlist 에 넣어주는데,
+		// 두가지 케이스
+		// 1. 증가가 가능한 상태라면, 가장 뒤 인덱스에 넣어줌
+		// 2. 증가가 불가능한 상태라면?
+		// 넣을 위치를 이분탐색으로 찾고, 교체 함
+		// 왜 교체냐? 추후에 수열의 구성이 바뀔 수 있음
+		// 교체를 해도 문제가 없는이유? 어차피 증가수열의 최대 길이만 궁금하기 떄문에 길이에는 변화가 없음
+
+		int[] arr = new int[N];
+
+		for (int i = 0; i < N; i++) {
+			arr[i] = Integer.parseInt(st.nextToken());
+		}
+		ArrayList<Integer> ans = new ArrayList<>();
+		// 인덱스 예쁘게 맞춰주자
+		ans.add(0);
+
+		for (int i = 0; i < N; i++) {
+			int input = arr[i];
+			// 증가가 가능한 경우
+			if (input > ans.get(ans.size() - 1)) {
+				ans.add(input);
+			} else {
+				// 교체할 위치를 찾자
+				int left = 1;
+				int right = ans.size() - 1;
+
+				while (left <= right) {
+					int mid = (left + right) / 2;
+
+					if (ans.get(mid) < input)
+						left = mid + 1;
+					else
+						right = mid - 1;
+
+				}
+				ans.set(left, input);
+			}
+		}
+
+		System.out.println(ans.size() - 1);
+
+	}
+}
+
+//import java.io.BufferedReader;
+//import java.io.IOException;
+//import java.io.InputStreamReader;
+//import java.util.ArrayList;
+//import java.util.List;
+//import java.util.StringTokenizer;
+//
+//public class BOJ_12015_LonggestIncreas {
+//	static int[] arr;
+//	static int mid;
+//
+//	public static void main(String[] args) throws NumberFormatException, IOException {
+//
+//		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+//
+//		int N = Integer.parseInt(br.readLine());
+//
+//		StringTokenizer st = new StringTokenizer(br.readLine());
+//
+//		arr = new int[N];
+//
+//		for (int i = 0; i < N; i++) {
+//			arr[i] = Integer.parseInt(st.nextToken());
+//		}
+//
+//		// 증가하는 수열의 갯수로 가능한 수를 이분탐색으로 찾아볼것임
+//		// 최소 한개는 증가수열
+//		int left = 1;
+//		// 최대 N개가 증가수열
+//		int right = N;
+//		boolean flag = false;
+//		while (left <= right) {
+//			// mid 개로 증가수열 가능?
+//			mid = (left + right) / 2;
+//			// mid개로 조합 뽑아
+//			combination = new ArrayList<>();
+//			comb(0);
+//			// 모든 조합중에서 항상 증가수열인게 있는가?
+//			for (List<Integer> li : combination) {
+//				flag = false;
+//				for (int i = 0; i < mid - 1; i++) {
+//					// 한번이라도 감소 or 같다면
+//					if (li.get(i + 1) - li.get(i) <= 0) {
+//						flag = true;
+//						break;
+//					}
+//
+//				}
+//				// 한번도 감소를 안했다면 ->증가수열
+//				if (!flag)
+//					break;
+//			}
+//
+//			// mid 개로 증가수열 가능하다 -> 하지만 더 많은 개수로 가능하다면 그게 답이 된다.
+//			// 더 큰 범위를 탐색해봐야한다.
+//			if (!flag)
+//				left = mid + 1;
+//			// mid 개로 증가수열을 만들 수 없다면 -> 더 좁은 범위를 탐색해 봐야한다.
+//			else
+//				right = mid - 1;
+//
+//		}
+//
+//		System.out.println(right);
+//
+//	}
+//
+//	static List<List<Integer>> combination = new ArrayList<>();
+//	static List<Integer> current = new ArrayList<>();
+//
+//	static void comb(int idx) {
+//		if (current.size() == mid) {
+//			combination.add(new ArrayList<>(current));
+//			return;
+//		}
+//
+//		for (int i = idx; i < arr.length; i++) {
+//			current.add(arr[i]);
+//			comb(i + 1);
+//			current.remove(current.size() - 1);
+//		}
+//
+//	}
+//
+//}

minsung/S2_BinarySearch/BOJ_1477_BuildRestArea.java

@@ -0,0 +1,119 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.StringTokenizer;
+
+public class BOJ_1477_BuildRestArea {
+
+	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());
+		int L = Integer.parseInt(st.nextToken());
+
+		List<Integer> highway = new LinkedList<>();
+		st = new StringTokenizer(br.readLine());
+		for (int i = 0; i < N; i++) {
+
+			highway.add(Integer.parseInt(st.nextToken()));
+
+		}
+
+		highway.add(0);
+		highway.add(L);
+
+		Collections.sort(highway);
+		// 휴게소의 간격을 찾는 이분탐색방법
+		int left = 1;
+		int right = L;
+		int mid = 0;// 찾고자 하는 휴게소의 간격
+		while (left <= right) {
+
+			mid = (left + right) / 2;
+
+			int cnt = 0; // 해당 간격일 때 지어지는 화장실 수
+			for (int i = 0; i < N + 1; i++) {
+
+				cnt += (highway.get(i + 1) - highway.get(i) - 1) / mid;
+
+			}
+
+			// 더 지어야 한다면? 간격을 좁혀라
+			if (cnt <= M) {
+				right = mid - 1;
+			} else {
+				// 개수가 지어야할 수 보다 많으면? 화장실 간격을 넖혀야 함
+				left = mid + 1;
+			}
+
+		}
+
+		System.out.println(left);
+
+	}
+}
+
+//최초의 풀이 : 그리디 방식 -> 그리디는 언제 최적해를 찾지 못하는가??
+//	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());
+//		int L = Integer.parseInt(st.nextToken());
+//
+//		List<Integer> highway = new LinkedList<>();
+//		st = new StringTokenizer(br.readLine());
+//		for (int i = 0; i < N; i++) {
+//
+//			highway.add(Integer.parseInt(st.nextToken()));
+//
+//		}
+//
+//		highway.add(0);
+//		highway.add(L);
+//
+//		Collections.sort(highway);
+//
+//		for (int i = 0; i < M; i++) {
+//			int maxDiff = -1;
+//			int build = -1;
+//			int idx = -1;
+//			for (int j = 0; j < highway.size() - 1; j++) {
+//
+//				int f = highway.get(j);
+//				int r = highway.get(j + 1);
+//
+//				if (r - f > maxDiff) {
+//					maxDiff = r - f;
+//					build = (r + f) / 2;
+//					idx = j + 1;
+//				}
+//			}
+//
+//			highway.add(idx, build);
+//		}
+//
+//		int ans = -1;
+//		for (int j = 0; j < highway.size() - 1; j++) {
+//
+//			int f = highway.get(j);
+//			int r = highway.get(j + 1);
+//
+//			ans = Math.max(ans, r - f);
+//		}
+//
+//		System.out.println(ans);
+//
+//		br.close();
+//
+//	}

minsung/S2_BinarySearch/BOJ_2295_SumOfThreeNums.java

@@ -0,0 +1,48 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.HashSet;
+
+public class BOJ_2295_SumOfThreeNums {
+
+	public static void main(String[] args) throws NumberFormatException, IOException {
+
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+		int N = Integer.parseInt(br.readLine());
+
+		int[] arr = new int[N];
+
+		for (int i = 0; i < N; i++) {
+			arr[i] = Integer.parseInt(br.readLine());
+
+		}
+
+		Arrays.sort(arr);
+
+		HashSet<Integer> hashset = new HashSet<>();
+
+		for (int i = 0; i < N; i++) {
+			for (int j = i; j < N; j++) {
+				hashset.add(arr[i] + arr[j]);
+			}
+		}
+		int ans = 01;
+		out: for (int i = N - 1; i >= 0; i--) {
+			for (int j = i; j >= 0; j--) {
+				if (hashset.contains(arr[i] - arr[j])) {
+					ans = i;
+
+					break out;
+				}
+			}
+		}
+
+		System.out.println(arr[ans]);
+
+		br.close();
+
+	}
+
+}

minsung/S2_BinarySearch/BOJ_2792_JewelryBox.java

@@ -0,0 +1,52 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class BOJ_2792_JewelryBox {
+
+	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());
+
+		int[] jewelry = new int[M];
+		for (int i = 0; i < M; i++) {
+			jewelry[i] = Integer.parseInt(br.readLine());
+		}
+
+		Arrays.sort(jewelry);
+
+		// 나눠주는 최소 보석 갯수
+		int left = 1;
+		// 나눠주는 최대 보석 갯수
+		int right = jewelry[M - 1];
+
+		while (left <= right) {
+			int mid = (left + right) / 2;
+			// 몇명에게 나눠 주었나.
+			int cnt = 0;
+
+			for (int i = 0; i < M; i++) {
+				if (jewelry[i] % mid == 0)
+					cnt += jewelry[i] / mid;
+				else
+					cnt += 1 + jewelry[i] / mid;
+			}
+
+			if (cnt <= N)
+				right = mid - 1;
+			else
+				left = mid + 1;
+
+		}
+
+		System.out.println(left);
+
+	}
+
+}