[알고리즘, BOJ] 2437 저울 - java

문제

하나의 양팔 저울을 이용하여 물건의 무게를 측정하려고 한다. 이 저울의 양 팔의 끝에는 물건이나 추를 올려놓는 접시가 달려 있고, 양팔의 길이는 같다. 또한, 저울의 한쪽에는 저울추들만 놓을 수 있고, 다른 쪽에는 무게를 측정하려는 물건만 올려놓을 수 있다.

무게가 양의 정수인 N개의 저울추가 주어질 때, 이 추들을 사용하여 측정할 수 없는 양의 정수 무게 중 최솟값을 구하는 프로그램을 작성하시오.

예를 들어, 무게가 각각 3, 1, 6, 2, 7, 30, 1인 7개의 저울추가 주어졌을 때, 이 추들로 측정할 수 없는 양의 정수 무게 중 최솟값은 21이다. 

입력

첫 째 줄에는 저울추의 개수를 나타내는 양의 정수 N이 주어진다. N은 1 이상 1,000 이하이다. 둘째 줄에는 저울추의 무게를 나타내는 N개의 양의 정수가 빈칸을 사이에 두고 주어진다. 각 추의 무게는 1 이상 1,000,000 이하이다.

출력

첫째 줄에 주어진 추들로 측정할 수 없는 양의 정수 무게 중 최솟값을 출력한다.

풀이

정렬과 그리디를 함께 활용해야 하는 문제이다. 개인적으로 그리디 알고리즘 문제를 좋아하지 않는다. 이건 노력을 해도 실력이 안느는 영역인거같아... 그래도 우린 개발자니까 포기하지 말고 해보자.

입력 및 초기화

문제에서 주어준 대로 무게추(weights)의 무게를 입력받아서 1차원 int형 배열에 저장한다.

int N = Integer.parseInt(br.readLine());
int[] weights = new int[N];

st = new StringTokenizer(br.readLine());
for(int i = 0; i < N; i++) {
    int weight = Integer.parseInt(st.nextToken());
    weights[i] = weight;
}

시간복잡도를 생각해보자. 가장 단순한 풀이 방법으로는 모든 무게추의 무게를 더하거나 빼면서 진행하는 것이다. 이 과정의 시간복잡도는 N개의 무게추에 대해 '무게추를 올리거나 내리거나', 두 가지 경우의 수를 가지므로 O(2 ^ N)이다. N의 최댓값이 1000이므로 최대 횟수로 따지면 컴퓨터는 이 연산을 영원히 처리할 수 없다. 다른 방식을 찾아보자.

정렬 후 그리디 구현

수학적으로 번뜩이는 아이디어가 필요한 문제이다. 일단 규칙 없이 산만하게 존재하는 데이터를 정렬하자. 입력 예시를 정렬하면 아래 주석과 같은 결과가 나온다.

Arrays.sort(weights);
// 1 1 2 3 6 7 30

이제부터 작은 수부터 차례대로 살펴보자.

Step 1.

1이 하나 있으니 1을 만들 수 있다.

Step 2.

그다음 수도 1이니 자기 자신인 1을 만들 수 있으며 기존에 있던 1과 함께 2를 만들 수 있다.

Step 3.

그 다음 수는 2이므로 자기 자신인 2를 만들 수 있으며 기존에 있던 1, 2와 함께 3, 4를 만들 수 있다.

여기까지 했으면 느낌이 와야 한다.

Step 4.

만약 0부터 i까지 모든 수를 만들 수 있다면, n을 가지고 n부터 (i + n)까지의 모든 무게가 만들어진다는 것을 알 수 있다. 따라서 아래와 같이 오름차순으로 정렬된 상태에서 만들어지는 것이 보장된 i와 다음 무게추인 n 사이에 간격이 존재한다면 해당 부분이 최솟값임을 알 수 있다.

이를 코드로 구현하자.

// 1 ~ max까지 전부 만들었으니까
// weights[i]만 있으면 weight ~ (weight + max) 사이 수 전부 만들 수 있음
// 만약 (max + 1) ~ weight가 중간에 비어있으면 빈 공간이 생김
int max = 0;
for(int i = 0; i < N; i++) {
    if(max + 1 < weights[i]) {
        break;
    }

    max += weights[i];
}
        
System.out.println(max + 1);

 전체 코드

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        
        int N = Integer.parseInt(br.readLine());
        int[] weights = new int[N];
        
        st = new StringTokenizer(br.readLine());
        for(int i = 0; i < N; i++) {
            int weight = Integer.parseInt(st.nextToken());
            
            weights[i] = weight;
        }
        
        Arrays.sort(weights);
        
        
        // 1 ~ max까지 전부 만들었으니까
        // weights[i]만 있으면 weight ~ (weight + max) 사이 수 전부 만들 수 있음
        // 만약 (max + 1) ~ weight가 중간에 비어있으면 빈 공간이 생김
        int max = 0;
        for(int i = 0; i < N; i++) {
            if(max + 1 < weights[i]) {
                break;
            }
            
            max += weights[i];
        }
        
        System.out.println(max + 1);
    }
}

시간 복잡도

기존에 브루트포스로 구상한 O(2 ^ N)이라는 시간복잡도에서 O(N)으로 말도 안 되게 단축하였다.