00. 정렬 알고리즘 (Sorting)
Sorting이 무엇인가?
Sorting은 무언가를 정리하는 것이다.
A부터 Z까지 기준으로 정렬하든가, 큰 수에서 작은 수 기준으로 정렬할 수도 있다.
버블정렬(Bubble Sort)
배열의 2개의 아이템을 선택하고
둘을 비교한다.
왼쪽이 오른쪽보다 크면 교환한다.
오른쪽으로 이동해서 해당 프로세스를 반복한다.
다음과 같은 경우는 5와 2로 시작한다.
5는 2보다 크니까 SWAP!
이번엔 5와 6인데 5는 작으니까 교환하지 않는다.
이번엔 6이 3보다 큰지 비교하고, 크기 때문에 SWAP!
동일하게 반복하면 결국은 2 5 3 1 4 6 로 정렬된다.
비교하고, SWAP(교환)하고의 반복이 전부이다.
그렇다면 버블정렬의 시간복잡도는?
배열의 N-1의 아이템을 비교해야 한다.
N-2, N-3 .. 이런 식으로 말이다.
아이템이 6개면 5번 비교를 해야한다.
최악의 경우, 작은 수에서 큰 수로 정렬하고 싶은데 내가 가지고 있는 배열이 큰 수에서 작은 수로 정렬되어 있다면 모든 아이템을 swap(교환)해야 한다.
즉 모든 사이클마다 모든 아이템을 교환해야한다.
따라서 버블정렬의 시간복잡도는 O(n^2) 이다.
이는 좋은 알고리즘은 아니다.
선택정렬(Selection Sort)
버블정렬을 설명하며 썼던 예제를 동일하게 사용해보자
전체 아이템 중 가장 작은 아이템의 위치를 변수에 저장한다.
자, 여기서 가장 작은 숫자는 5이다. 여기선 5보다 작은 숫자 2가 있다.
따라서 2의 위치를 변수에 저장하고,
계속 체크하다가 1에 도착하게 되면 1의 위치를 저장하고 사이클을 끝낸다.
이제 배열에서 가장 작은 숫자가 어디에 있는지를 안다.
그리고 이제 SWAP(교환)을 해야 한다.
가장 작은 숫자(위치를 안다, =1)을 첫번째 아이템과 바꾼다
그 다음 사이클을 시작할 때, 1로 시작하지 않는다.
1은 정렬된 파트이므로, 정렬되지 않은 부분 중에서 가장 작은 숫자를 찾을 것이다.
그 다음 가장 작은 숫자 '2'를 찾는다. 2는 이미 올바른 위치에 있으므로 SWAP하지 않는다.
이걸 계속 반복하는거다. 작은 숫자 찾고, SWAP 하기!
그렇다면 선택정렬의 시간복잡도는?
버블정렬과 유사하게 SWAP(교환)도 있고, 비교도 있다.
정렬되지 않은 배열에서 가장 작은 숫자를 찾으므로 즉, 이는 N-1 비교를 하는 것이다.
이건 버블정렬과 동일하다.
하지만 버블정렬과 다르게 N번의 스왑을 하지 않는다. (최악의 경우)
선택정렬에서는 매번 사이클마다 1번의 SWAP만 하면 된다.
즉, 선택정렬은 버블정렬보다 효율적이다.
선택정렬이 버블정렬보다 2배 더 빠를 수 있음에도 불구하고,
선택정렬의 시간복잡도도 역시 O(n^2) 이다.
삽입정렬(Insertion Sort)
동일한 배열을 삽입정렬로 정리하면 이런 모습이 된다.
인덱스 1번을 보면 숫자 '2'인 것을 확인할 수 있다.
왼쪽에 이 숫자 '2'보다 큰 숫자가 있는지 살펴본다.
그 경우 '5'를 오른쪽으로 밀고, 2번째 사이클을 시작한다.
2번째 사이클을 시작하면 '6'을 선택한다. 그리고 왼쪽에 더 큰 숫자가 있는지 살펴보자.
없는 경우엔 계속 진행한다.
3번째 사이클의 숫자는 '3'이다. '3'의 왼쪽에 더 큰 숫자인 '6'이 있다.
따라서 '6'을 오른쪽으로 이동하고,
그리고 다시 '3'을 '5'와 비교한다.
'5'가 더 크므로, 오른쪽으로 이동한다.
그리고 '2'가 '3'보다 크지 않으므로 올바른 위치에 있다고 말할 수 있다.
'1'로도 동일한 작업을 계속 한다.
'1'보다 큰 숫자는 다 오른쪽으로 이동, 그리고 그 공간을 '1'로 채운다.
동일한 작업을 '4'로 하면 끝이다.
그렇다면 삽입정렬의 시간복잡도는?
삽입정렬은 선택정렬보다 빠르다. 왜냐면 삽입정렬은 필요한 아이템만 스캔을 한다.
선택정렬은 모든 아이템을 스캔하는데 말이다!
하지만 삽입정렬이 선택정렬보다 빨라도, 버블정렬보다 빨라도
삽입정렬의 시간복잡도는 동일하게 O(n^2) 이다.
3종류의 알고리즘이 모두 시간복잡도가 O(n^2)?
흠? 그럼 Big O는 엉터리인가?
이렇게 3가지 종류의 알고리즘이 있고 각기 매우 다른데 시간복잡도는 동일하다는 것이지?
이 경우 최악의 시나리오를 보지 말고 평균 시나리오를 살펴봐야 한다.
최악/최고의 케이스는 자주 발생하지 않는다. 대부분 '평균'적인 경우에 속한다.
이걸 감안하고 해당 알고리즘들을 보면 삽입정렬, 선택정렬 둘 다 최악의 경우 O(n^2) 시간복잡도를 가지고 있다.
그러나 삽입정렬의 경우 O(N)의 최고의 시나리오에서 발생한다.
O(N)은 O(N^2)과 비교해선 더욱 좋은 알고리즘이다.
보다시피 디테일이 정말 중요하다.
이렇게 동일한 시간복잡도를 갖고있다 하더라도 매우 다르게 나타날 수 있다.
삽입, 선택 정렬은 작은 DB 기준으로는 훌륭한 알고리즘이다.
물론 데이터가 커지면 커질수록 좀 느려지겠지만.. 그때 다른걸 좀 살펴봐야겠지?
Quick Sort, Merge Sort와 같은! 이는 추후에 공부하도록 하자.
01. 선택 정렬
설명
N개의 숫자가 입력되면 오름차순으로 정렬하여 출력하는 프로그램을 작성하세요.
정렬하는 방법은 선택정렬입니다.
입력
첫 번째 줄에 자연수 N(1<=N<=100)이 주어집니다.
두 번째 줄에 N개의 자연수가 공백을 사이에 두고 입력됩니다. 각 자연수는 정수형 범위 안에 있습니다.
출력
오름차순으로 정렬된 수열을 출력합니다.
예시 입력 1
6
13 5 11 7 23 15
예시 출력 1
5 7 11 13 15 23
코드
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
//선택 정렬
public class Main {
public int[] solution(int n, int[] arr) {
//굳이 마지막 배열 인덱스까지 for문 안돌려도 된다.
//n-1번 인덱스까지 계산해도 마지막 배열 인덱스의 값은 제일 큰 수가 들어오기 때문
for (int i = 0; i < n-1; i++) {
int idx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[idx]) idx = j;
}
//i 인덱스 값보다 작은 값이 있었다면 idx 인덱스 번호가 변경 되었을 걸
//i번 인덱스와 idx 인덱스 번호의 값의 위치를 서로 바꿔주는 작업
int tmp = arr[i];
arr[i] = arr[idx];
arr[idx] = tmp;
}
return arr;
}
public static void main(String[] args) {
Main T = new Main();
Scanner kb = new Scanner(System.in);
int n = kb.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = kb.nextInt();
}
for (int x : T.solution(n, arr)) {
System.out.print(x+" ");
}
}
}02. 버블 정렬
설명
N개의 숫자가 입력되면 오름차순으로 정렬하여 출력하는 프로그램을 작성하세요.
정렬하는 방법은 버블정렬입니다.
입력
첫 번째 줄에 자연수 N(1<=N<=100)이 주어집니다.
두 번째 줄에 N개의 자연수가 공백을 사이에 두고 입력됩니다. 각 자연수는 정수형 범위 안에 있습니다.
출력
오름차순으로 정렬된 수열을 출력합니다.
예시 입력 1
6
13 5 11 7 23 15
예시 출력 1
5 7 11 13 15 23
코드
import java.util.Scanner;
//버블 정렬
public class Main {
public int[] solution(int n, int[] arr) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i -1; j++) {
if (arr[j] > arr[j + 1]) {
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j + 1] = tmp;
}
}
}
return arr;
}
public static void main(String[] args) {
Main T = new Main();
Scanner kb = new Scanner(System.in);
int n = kb.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = kb.nextInt();
}
for (int x : T.solution(n, arr)) {
System.out.print(x+" ");
}
}
}03. 삽입 정렬
설명
N개의 숫자가 입력되면 오름차순으로 정렬하여 출력하는 프로그램을 작성하세요.
정렬하는 방법은 삽입정렬입니다.
입력
첫 번째 줄에 자연수 N(1<=N<=100)이 주어집니다.
두 번째 줄에 N개의 자연수가 공백을 사이에 두고 입력됩니다. 각 자연수는 정수형 범위 안에 있습니다.
출력
오름차순으로 정렬된 수열을 출력합니다.
예시 입력 1
6
11 7 5 6 10 9
예시 출력 1
5 6 7 9 10 11
코드
import java.util.Scanner;
// 삽입 정렬
public class Main {
public int[] solution(int n, int[] arr) {
for (int i = 1; i < n; i++) {
//arr[i]가 정렬이 진행되면서 계속해서 값이 변경되므로 j의 for문이 돌기 전에 arr[i]를 tmp에 저장한다.
//j는 for문이 끝난 후 tmp > arr[j] 순간에 tmp를 arr[j+1]에 대입해야 하므로 선언을 미리한다.
int tmp = arr[i], j;
//i번째보다 -1인 인덱스부터 0번 인덱스까지 값을 비교하는 for문
for (j = i-1; j >= 0; j--) {
//tmp > arr[j]라면 arr[j+1]에 arr[j] 대입
if (tmp < arr[j]) arr[j + 1] = arr[j];
//tmp > arr[j] 순간에 빠져나가고
else break;
}
//arr[j+1] 에 tmp를 저장
arr[j + 1] = tmp;
}
return arr;
}
public static void main(String[] args) {
Main T = new Main();
Scanner kb = new Scanner(System.in);
int n = kb.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = kb.nextInt();
}
for (int x : T.solution(n, arr)) {
System.out.print(x + " ");
}
}
}
04. Least Recently Used
설명
캐시메모리는 CPU와 주기억장치(DRAM) 사이의 고속의 임시 메모리로서 CPU가 처리할 작업을 저장해 놓았다가
필요할 바로 사용해서 처리속도를 높이는 장치이다. 워낙 비싸고 용량이 작아 효율적으로 사용해야 한다.
철수의 컴퓨터는 캐시메모리 사용 규칙이 LRU 알고리즘을 따른다.
LRU 알고리즘은 Least Recently Used 의 약자로 직역하자면 가장 최근에 사용되지 않은 것 정도의 의미를 가지고 있습니다.
캐시에서 작업을 제거할 때 가장 오랫동안 사용하지 않은 것을 제거하겠다는 알고리즘입니다.
캐시의 크기가 주어지고, 캐시가 비어있는 상태에서 N개의 작업을 CPU가 차례로 처리한다면 N개의 작업을 처리한 후
캐시메모리의 상태를 가장 최근 사용된 작업부터 차례대로 출력하는 프로그램을 작성하세요.
입력
첫 번째 줄에 캐시의 크기인 S(3<=S<=10)와 작업의 개수 N(5<=N<=1,000)이 입력된다.
두 번째 줄에 N개의 작업번호가 처리순으로 주어진다. 작업번호는 1 ~100 이다.
출력
마지막 작업 후 캐시메모리의 상태를 가장 최근 사용된 작업부터 차례로 출력합니다.
예시 입력 1
5 9
1 2 3 2 6 2 3 5 7
예시 출력 1
7 5 3 2 6
코드
import java.util.Scanner;
//Least Recently Used
public class Main {
public int[] solution(int s, int n, int[] arr) {
int[] cache = new int[s];
for (int x : arr) {
int pos = -1; //pos: 인덱스 번호(position)
for (int i = 0; i < s; i++) {
//x값이 cache[i]값과 같다면 cache hit 라는 것 -> hit된 지점 pos에 저장
if(x==cache[i]) pos = i;
}
//cache miss 일 때
if (pos == -1) {
//인덱스 번호 4번부터 1번까지 값 들어올 때마다 위치 +1씩 해서 옮기기
for (int i = s - 1; i >= 1; i--) {
cache[i] = cache[i - 1];
}
} // cache hit 일 때
else {
for (int i = pos; i >= 1; i--) { //pos 지점부터 (=hit된 지점)
cache[i] = cache[i - 1];
}
}
cache[0] = x;
}
return cache;
}
public static void main(String[] args) {
Main T = new Main();
Scanner kb = new Scanner(System.in);
int s = kb.nextInt();
int n = kb.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = kb.nextInt();
}
for (int x : T.solution(s, n, arr)) {
System.out.print(x+ " ");
}
}
}
05. 중복 확인
설명
현수네 반에는 N명의 학생들이 있습니다.
선생님은 반 학생들에게 1부터 10,000,000까지의 자연수 중에서 각자가 좋아하는 숫자 하나 적어 내라고 했습니다.
만약 N명의 학생들이 적어낸 숫자 중 중복된 숫자가 존재하면 D(duplication)를 출력하고,
N명이 모두 각자 다른 숫자를 적어냈다면 U(unique)를 출력하는 프로그램을 작성하세요.
입력
첫 번째 줄에 자연수 N(5<=N<=100,000)이 주어진다.
두 번째 줄에 학생들이 적어 낸 N개의 자연수가 입력된다.
출력
첫 번째 줄에 D 또는 U를 출력한다.
예시 입력 1
8
20 25 52 30 39 33 43 33
예시 출력 1
D
코드
import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;
//중복 확인
public class Main {
public String soltuion(int n, int[] arr) {
String answer = "U";
/**
* 정렬로 푸는 방법 : nlogn
*/
Arrays.sort(arr); //오름차순 정렬
for (int i = 0; i < n-1; i++) { //0번부터 n-1번까지
if (arr[i] == arr[i + 1]) { //n번째와 n+1과 같으면 D 반환
return "D";
}
}
/**
* HashMap으로 푸는 방법 : O(n)
*/
// HashMap<Integer, Integer> hashMap = new HashMap<>();
// for (int x : arr) {
// hashMap.put(x, hashMap.getOrDefault(x, 0) + 1);
// if (hashMap.get(x) >= 2) {
// return "D";
// }
// }
return answer;
}
public static void main(String[] args) {
Main T = new Main();
Scanner kb = new Scanner(System.in);
int n = kb.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = kb.nextInt();
}
System.out.println(T.soltuion(n,arr));
}
}
06. 장난꾸러기
설명
새 학기가 시작되었습니다. 철수는 새 짝꿍을 만나 너무 신이 났습니다.
철수네 반에는 N명의 학생들이 있습니다.
선생님은 반 학생들에게 반 번호를 정해 주기 위해 운동장에 반 학생들을 키가 가장 작은 학생부터 일렬로 키순으로 세웠습니다.
제일 앞에 가장 작은 학생부터 반 번호를 1번부터 N번까지 부여합니다. 철수는 짝꿍보다 키가 큽니다.
그런데 철수가 앞 번호를 받고 싶어 짝꿍과 자리를 바꿨습니다.
선생님은 이 사실을 모르고 학생들에게 서있는 순서대로 번호를 부여했습니다.
철수와 짝꿍이 자리를 바꾼 반 학생들의 일렬로 서있는 키 정보가 주어질 때 철수가 받은 번호와 철수 짝꿍이 받은 번호를
차례로 출력하는 프로그램을 작성하세요.
입력
첫 번째 줄에 자연수 N(5<=N<=100)이 주어진다.
두 번째 줄에 제일 앞에부터 일렬로 서있는 학생들의 키가 주어진다.
키(높이) 값 H는 (120<=H<=180)의 자연수 입니다.
출력
첫 번째 줄에 철수의 반 번호와 짝꿍의 반 번호를 차례로 출력합니다.
예시 입력 1
9
120 125 152 130 135 135 143 127 160
예시 출력 1
3 8
코드
package section6;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
//장난꾸러기
public class ExampleSix {
/**
* 정렬을 했을 때 쉽게 풀리는 문제
*/
public List<Integer> solution(int n, int[] arr) {
List<Integer> answer = new ArrayList<>();
int[] tmp = arr.clone();
Arrays.sort(arr);
for (int i = 0; i < n; i++) {
if (arr[i] != tmp[i]) {
answer.add(i+1);
}
}
return answer;
}
public static void main(String[] args) {
ExampleSix T = new ExampleSix();
Scanner kb = new Scanner(System.in);
int n = kb.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = kb.nextInt();
}
for (int x : T.solution(n, arr)) {
System.out.print(x+" ");
}
}
}
07. 좌표 정렬
설명
N개의 평면상의 좌표(x, y)가 주어지면 모든 좌표를 오름차순으로 정렬하는 프로그램을 작성하세요.
정렬기준은 먼저 x값의 의해서 정렬하고, x값이 같을 경우 y값에 의해 정렬합니다.
입력
첫째 줄에 좌표의 개수인 N(3<=N<=100,000)이 주어집니다.
두 번째 줄부터 N개의 좌표가 x, y 순으로 주어집니다. x, y값은 양수만 입력됩니다.
출력
N개의 좌표를 정렬하여 출력하세요.
예시 입력 1
5
2 7
1 3
1 2
2 5
3 6
예시 출력 1
1 2
1 3
2 5
2 7
3 6
Comparable 구현 시 compareTo 메서드
0 (제로): 이는 현재 객체와 다른 객체가 같음을 나타낸다. 즉, 두 객체가 동등하다는 것을 의미한다.
양수: 양수는 현재 객체가 다른 객체보다 크다는 것을 나타낸다. 이때 반환되는 양수의 크기는 크기 차이를 나타낸다. 컬렉션(리스트 등)이 있을 때 큰 값을 반환하므로 내림차순을 반환하게 된다.
음수: 음수는 현재 객체가 다른 객체보다 작다는 것을 나타낸다. 반환되는 음수의 크기는 작기 차이를 나타낸다. 컬렉션(리스트 등)이 있을 때 작은 값을 반환하므로 오름차순을 반환하게 된다.
코드
package section6;
import java.util.*;
//Comparable의 구현 클래스
class Point implements Comparable<Point> {
public int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public int compareTo(Point o) {
if (this.x == o.x) return this.y - o.y; //x값이 같을 땐 y값에 의해 정렬 (음수: 작은 것을 반환, 오름차순 / 양수: 내림차순)
else return this.x - o.x; //x값에 의해 정렬 (음수: 작은 것을 반환, 오름차순 / 양수: 내림차순)
}
}
//좌표 정렬
public class ExampleSeven {
public static void main(String[] args) {
ExampleSeven T = new ExampleSeven();
Scanner kb = new Scanner(System.in);
int n = kb.nextInt();
List<Point> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
int x = kb.nextInt();
int y = kb.nextInt();
list.add(new Point(x, y));
}
//정렬 -> Comparable의 인터페이스를 통해서 Point 객체를 정렬, 이때 정렬의 기준이 compareTo() 메서드
Collections.sort(list);
for (Point o : list) {
System.out.println(o.x+" "+o.y);
}
}
}
08. 이분검색
설명
임의의 N개의 숫자가 입력으로 주어집니다. N개의 수를 오름차순으로 정렬한 다음 N개의 수 중 한 개의 수인 M이 주어지면
이분검색으로 M이 정렬된 상태에서 몇 번째에 있는지 구하는 프로그램을 작성하세요. 단 중복값은 존재하지 않습니다.
입력
첫 줄에 한 줄에 자연수 N(3<=N<=1,000,000)과 M이 주어집니다.
두 번째 줄에 N개의 수가 공백을 사이에 두고 주어집니다.
출력
첫 줄에 정렬 후 M의 값의 위치 번호를 출력한다.
예시 입력 1
8 32
23 87 65 12 57 32 99 81
예시 출력 1
3
코드
import java.util.Arrays;
import java.util.Scanner;
//이분검색
public class Main {
public int solution(int n, int m, int[] arr) {
int answer = 0;
Arrays.sort(arr);
int lt =0, rt = n-1;
while (lt <= rt) {
int mid = (lt + rt) / 2;
//1. mid(중간) 값이 m과 같을때
if (arr[mid] == m) {
//answer는 0번 인덱스가 곧 1로 count
answer = mid + 1;
break;
}
//2. mid(중간) 값이 m보다 클 때
else if (arr[mid] > m) {
rt = mid-1;
}
//3. mid(중간) 값이 m보다 작을 때
else lt = mid + 1;
}
return answer;
}
public static void main(String[] args) {
Main T = new Main();
Scanner kb = new Scanner(System.in);
int n = kb.nextInt();
int m = kb.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = kb.nextInt();
}
System.out.println(T.solution(n,m,arr));
}
}
Binary Search
선형검색보다 더 효율적이나, 이진검색 알고리즘은 모든 배열에 쓸 수는 없다.
"정렬된 배열(Sorted Array)"에서만 사용 가능하다.
정렬된 배열에 '이진검색'을 해보도록 하자
'이진검색'은 하나를 두개로 쪼개는 것을 뜻한다.
선형 검색과 달리 이진 검색에서는 인덱스 0번부터 처음부터 검색을 하지 않는다.
이진 검색에서는 중간에서 시작한다.
정 가운데에 있는 숫자가 우리 목표 숫자보다 큰지, 작은지를 확인한다.
만약 아이템이 목표 숫자보다 크다면 목표 숫자가 아이템의 왼쪽으로 가게 된다.
반대로 아이템이 목표숫자보다 작다면 목표 숫자가 아이템의 오른쪽으로 간다.
1에서 10까지 정렬된 상황에서 중간에서 시작하면 숫자는 5이다.
우리의 목표는 9이다. 따라서 5는 9보다 작으니까 아이템이 오른쪽으로 이동한다.
왼쪽은 싸그리 무시하게 된다.
해당 배열의 중간으로 이동한다. 이 경우엔 숫자가 8이 된다.
8은 9보다 작으므로 해당 아이템의 왼쪽은 무시하게 된다.
다음 프로세스에서 목표값을 찾게 된다.
이렇게 하면 3번만에 찾을 수 있다.
"선형검색"으로 하면 9번의 시도가 필요하지만 "이진검색"으로 3번으로 줄였다.
Binary Search에 대한 개념 정리본 확인 (이진검색)
https://velog.io/@10000ji_/%EB%B0%B1%EC%A4%80-Two-pointers-Sliding-window%ED%9A%A8%EC%9C%A8%EC%84%B1-On2On#binary-search%EC%9D%B4%EC%A7%84%EA%B2%80%EC%83%89-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98
09. 뮤직비디오(결정알고리즘)
설명
지니레코드에서는 불세출의 가수 조영필의 라이브 동영상을 DVD로 만들어 판매하려 한다.
DVD에는 총 N개의 곡이 들어가는데, DVD에 녹화할 때에는 라이브에서의 순서가 그대로 유지되어야 한다.
순서가 바뀌는 것을 우리의 가수 조영필씨가 매우 싫어한다. 즉, 1번 노래와 5번 노래를 같은 DVD에 녹화하기 위해서는
1번과 5번 사이의 모든 노래도 같은 DVD에 녹화해야 한다. 또한 한 노래를 쪼개서 두 개의 DVD에 녹화하면 안된다.
지니레코드 입장에서는 이 DVD가 팔릴 것인지 확신할 수 없기 때문에 이 사업에 낭비되는 DVD를 가급적 줄이려고 한다.
고민 끝에 지니레코드는 M개의 DVD에 모든 동영상을 녹화하기로 하였다. 이 때 DVD의 크기(녹화 가능한 길이)를 최소로 하려고 한다.
그리고 M개의 DVD는 모두 같은 크기여야 제조원가가 적게 들기 때문에 꼭 같은 크기로 해야 한다.
입력
첫째 줄에 자연수 N(1≤N≤1,000), M(1≤M≤N)이 주어진다.
다음 줄에는 조영필이 라이브에서 부른 순서대로 부른 곡의 길이가 분 단위로(자연수) 주어진다.
부른 곡의 길이는 10,000분을 넘지 않는다고 가정하자.
출력
첫 번째 줄부터 DVD의 최소 용량 크기를 출력하세요.
예시 입력 1
9 3
1 2 3 4 5 6 7 8 9
예시 출력 1
17
코드
import java.util.Arrays;
import java.util.Scanner;
//뮤직비디오(결정알고리즘
public class Main {
public int count(int[] arr, int capacity) {
//cnt: dvd 장수, sum: dvd에 담아내는 곡들의 크기
int cnt = 1, sum = 0;
for (int x : arr) {
//sum과 arr의 인덱스들의 값을 더하는데 dvd 한장의 용량을 넘어가는 순간 ({1 2 3 4 5} 이후..)
if (sum + x > capacity) {
//새로운 장수가 필요함 (한 장은 이미 꽉 차고 두번째 장수를 채우는 것) ({6,7}로 채워가자)
cnt++;
sum = x;
} else sum += x;
}
return cnt;
}
public int solution(int n, int m, int[] arr) {
int answer = 0;
int lt = Arrays.stream(arr).max().getAsInt(); //steam 리덕션
int rt = Arrays.stream(arr).sum();
while (lt <= rt) {
int mid = (lt + rt) / 2; //dvd 한장의 용량
//dvd 몇 장으로 담을 수 있는가? 주어진 m장보다 작거나 같다면~
if (count(arr, mid) <= m) {
answer = mid; //dvd 한장의 용량을 리턴할 수 있게 answer에 담는다
rt = mid - 1; // 더 좁혀 나가면서 mid를 설정한다
}
else lt = mid + 1;
}
return answer;
}
public static void main(String[] args) {
Main T = new Main();
Scanner kb = new Scanner(System.in);
int n = kb.nextInt();
int m = kb.nextInt();
int arr[] = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = kb.nextInt();
}
System.out.println(T.solution(n,m,arr));
}
}10. 마구간 정하기(결정알고리즘)
설명
N개의 마구간이 수직선상에 있습니다. 각 마구간은 x1, x2, x3, ......, xN의 좌표를 가지며, 마구간간에 좌표가 중복되는 일은 없습니다.
현수는 C마리의 말을 가지고 있는데, 이 말들은 서로 가까이 있는 것을 좋아하지 않습니다. 각 마구간에는 한 마리의 말만 넣을 수 있고,
가장 가까운 두 말의 거리가 최대가 되게 말을 마구간에 배치하고 싶습니다.
C마리의 말을 N개의 마구간에 배치했을 때 가장 가까운 두 말의 거리가 최대가 되는 그 최대값을 출력하는 프로그램을 작성하세요.
입력
첫 줄에 자연수 N(3<=N<=200,000)과 C(2<=C<=N)이 공백을 사이에 두고 주어집니다.
둘째 줄에 마구간의 좌표 xi(0<=xi<=1,000,000,000)가 차례로 주어집니다.
출력
첫 줄에 가장 가까운 두 말의 최대 거리를 출력하세요.
예시 입력 1
5 3
1 2 8 4 9
예시 출력 1
3
코드
import java.util.Arrays;
import java.util.Scanner;
//마구간 정하기(결정알고리즘)
public class Main {
public int count(int[] arr, int mid) {
int cnt = 1;
int ep = arr[0];
for (int i = 1; i < arr.length; i++) {
//현재 마구간의 좌표 - 직전에 지정한 마구간의 좌표
if (arr[i] - ep >= mid) {
cnt++;
ep = arr[i];
}
}
return cnt;
}
public int solution(int n, int c, int[] arr) {
int answer = 0;
Arrays.sort(arr);
//두 말 사이의 거리이므로 제일 짧은 간격은 1일 것
int lt = 1;
//두 말 사이의 거리이므로 가장 긴 간격은 arr의 마지막 숫자
int rt = arr[n - 1];
while (rt >= lt) {
//가장 가까운 두 말의 최대 거리
int mid = (rt + lt) / 2;
if (count(arr, mid) >= c) {
answer = mid;
lt = mid + 1;
} else rt = mid - 1;
}
return answer;
}
public static void main(String[] args) {
Main T = new Main();
Scanner kb = new Scanner(System.in);
int n = kb.nextInt();
int c = kb.nextInt();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = kb.nextInt();
}
System.out.println(T.solution(n, c, arr));
}
}
