[2961] 도영이가 만든 맛있는 음식

[Silver II] 도영이가 만든 맛있는 음식 - 2961

문제 링크

성능 요약

메모리: 16248 KB, 시간: 148 ms

분류

브루트포스 알고리즘, 비트마스킹, 백트래킹

문제 설명

도영이는 짜파구리 요리사로 명성을 날렸었다. 이번에는 이전에 없었던 새로운 요리에 도전을 해보려고 한다.

지금 도영이의 앞에는 재료가 N개 있다. 도영이는 각 재료의 신맛 S와 쓴맛 B를 알고 있다. 여러 재료를 이용해서 요리할 때, 그 음식의 신맛은 사용한 재료의 신맛의 곱이고, 쓴맛은 합이다.

시거나 쓴 음식을 좋아하는 사람은 많지 않다. 도영이는 재료를 적절히 섞어서 요리의 신맛과 쓴맛의 차이를 작게 만들려고 한다. 또, 물을 요리라고 할 수는 없기 때문에, 재료는 적어도 하나 사용해야 한다.

재료의 신맛과 쓴맛이 주어졌을 때, 신맛과 쓴맛의 차이가 가장 작은 요리를 만드는 프로그램을 작성하시오.

입력

첫째 줄에 재료의 개수 N(1 ≤ N ≤ 10)이 주어진다. 다음 N개 줄에는 그 재료의 신맛과 쓴맛이 공백으로 구분되어 주어진다. 모든 재료를 사용해서 요리를 만들었을 때, 그 요리의 신맛과 쓴맛은 모두 1,000,000,000보다 작은 양의 정수이다.

출력

첫째 줄에 신맛과 쓴맛의 차이가 가장 작은 요리의 차이를 출력한다.

아이디어

좀 더 효율적으로 풀 수 없을까 고민해보았지만, 결국 선택 가능한 모든 경우를 조합으로 뽑아, 각 경우마다 신맛과 쓴맛의 차이를 계산하여 차이의 최솟값을 구하는 방법밖에는 없는 것 같다.
조합 관련 문제가 실제로 출제된다면 java로 풀어내는 것은 좀 고역일 것 같긴하다..

답안코드

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

class Combination<T> {
    private int n;
    private int r;
    private int[] now; // 현재 조합
    private List<List<T>> result; // 모든 조합

    public List<List<T>> getResult() {
        return result;
    }

    public Combination(int n, int r) {
        this.n = n;
        this.r = r;
        this.now = new int[r];
        this.result = new ArrayList<>();
    }

    public void combination(List<T> list, int depth, int index, int target) {
        if (depth == r) {
            List<T> temp = new ArrayList<>();
            for (int i = 0; i < now.length; i++) {
                temp.add(list.get(now[i]));
            }
            result.add(temp);
            return;
        }
        if (target == n) return;
        now[index] = target;
        combination(list, depth + 1, index + 1, target + 1);
        combination(list, depth, index, target + 1);
    }
}

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());
        List<List<Integer>> ingredientList = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            List<Integer> ingredient = Arrays.stream(br.readLine().split(" "))
                    .map(Integer::valueOf)
                    .collect(Collectors.toList());
            ingredientList.add(ingredient);
        }

        List<Integer> diff = new ArrayList<>();

        for (int i = 1; i <= n; i++) {
            Combination comb = new Combination<>(n, i);
            comb.combination(ingredientList, 0, 0, 0);

            List<List<List<Integer>>> chosenIngredient = comb.getResult();

            for (List<List<Integer>> choice : chosenIngredient) {
                int sour = 1;
                int bitter = 0;

                for (List<Integer> ingredient : choice) {
                    sour *= ingredient.get(0);
                    bitter += ingredient.get(1);
                }
                diff.add(Math.abs(sour - bitter));
            }
        }

        int minimum = Collections.min(diff);
        System.out.println(minimum);
    }
}

BOJ 카테고리 내 다른 글 보러가기