[백준 No.18310] 안테나 (정렬, 수학)

문제

일직선 상의 마을에 여러 채의 집이 위치해 있다. 이중에서 특정 위치의 집에 특별히 한 개의 안테나를 설치하기로 결정했다. 효율성을 위해 안테나로부터 모든 집까지의 거리의 총 합이 최소가 되도록 설치하려고 한다. 이 때 안테나는 집이 위치한 곳에만 설치할 수 있고, 논리적으로 동일한 위치에 여러 개의 집이 존재하는 것이 가능하다.

집들의 위치 값이 주어질 때, 안테나를 설치할 위치를 선택하는 프로그램을 작성하시오.

예를 들어 N=4이고, 각 위치가 1, 5, 7, 9일 때를 가정하자.

이 경우 5의 위치에 설치했을 때, 안테나로부터 모든 집까지의 거리의 총 합이 (4+0+2+4)=10으로, 최소가 된다.

입력

첫째 줄에 집의 수 N이 자연수로 주어진다. (1≤N≤200,000) 둘째 줄에 N채의 집에 위치가 공백을 기준으로 구분되어 1이상 100,000이하의 자연수로 주어진다.

출력

첫째 줄에 안테나를 설치할 위치의 값을 출력한다. 단, 안테나를 설치할 수 있는 위치 값으로 여러 개의 값이 도출될 경우 가장 작은 값을 출력한다.

예제 입력 1

4 5 1 7 9

예제 출력 1

5

 

문제 Tip.

1. 빠른 정렬을 사용해서 정렬하세요 (퀵, 병합, 힙... 이외에 종류는 많습니다.)
2. 안테나간의 거리를 다 잴 필요가 없습니다. 
   맨 앞집에서 시작하는게 거리가 적을지
   중간 집에서 시작하는게 거리가 적을지
   마지막 집에서 시작하는게 거리가 적을지 
   딱 3가지 고민만 해보시면됩니다.

 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        MergeSort sort = new MergeSort();
        int num = Integer.parseInt(br.readLine());

        String splitHomes = br.readLine();
        String[] splitArr = splitHomes.split(" ");
        int[] homes = new int[num];

        for (int i = 0; i < homes.length; i++) {
            homes[i] = Integer.parseInt(splitArr[i]);
        }

        homes = sort.sort(homes);
        int mid = homes.length % 2 == 0 ? homes.length / 2 - 1 : homes.length / 2;

        System.out.println(homes[mid]);
    }

    static class MergeSort {
        public int[] sort(int[] arr) {
            if (arr.length == 0 || arr.length == 1) { //0~1개의 리스트는 이미 정렬된것으로 봅니다.
                return arr;
            }
            int[] leftArr = Arrays.copyOfRange(arr, 0, arr.length / 2);
            int[] rightArr = Arrays.copyOfRange(arr, arr.length / 2, arr.length);

            return divAndComArr(leftArr, rightArr);
        }

        private int[] divAndComArr(int[] leftArr, int[] rightArr) {
            int[] lArr;
            int[] rArr;

            if (leftArr.length > 1) {
                lArr = divAndComArr(Arrays.copyOfRange(leftArr, 0, leftArr.length / 2),
                        Arrays.copyOfRange(leftArr, leftArr.length / 2, leftArr.length));
            } else {
                lArr = leftArr;
            }

            if (rightArr.length > 1) {
                rArr = divAndComArr(Arrays.copyOfRange(rightArr, 0, rightArr.length / 2),
                        Arrays.copyOfRange(rightArr, rightArr.length / 2, rightArr.length));
            } else {
                rArr = rightArr;
            }

            int[] combineArr = new int[lArr.length + rArr.length];
            int lIdx = 0;
            int rIdx = 0;

            for (int i = 0; i < combineArr.length; i++) {
                if (lIdx == lArr.length) {
                    combineArr[i] = rArr[rIdx];
                    rIdx++;
                    continue;
                } else if (rIdx == rArr.length) {
                    combineArr[i] = lArr[lIdx];
                    lIdx++;
                    continue;
                }

                if (lArr[lIdx] <= rArr[rIdx]) {
                    combineArr[i] = lArr[lIdx];
                    lIdx++;
                } else {
                    combineArr[i] = rArr[rIdx];
                    rIdx++;
                }
            }
            return combineArr;
        }
    }
}