문제 설명

추석 트래픽

이번 추석에도 시스템 장애가 없는 명절을 보내고 싶은 어피치는 서버를 증설해야 할지 고민이다. 장애 대비용 서버 증설 여부를 결정하기 위해 작년 추석 기간인 9월 15일 로그 데이터를 분석한 후 초당 최대 처리량을 계산해보기로 했다. 초당 최대 처리량은 요청의 응답 완료 여부에 관계없이 임의 시간부터 1초(=1,000밀리초)간 처리하는 요청의 최대 개수를 의미한다.

입력 형식

  • solution 함수에 전달되는 lines 배열은 N(1 ≦ N ≦ 2,000)개의 로그 문자열로 되어 있으며, 각 로그 문자열마다 요청에 대한 응답완료시간 S와 처리시간 T가 공백으로 구분되어 있다.
  • 응답완료시간 S는 작년 추석인 2016년 9월 15일만 포함하여 고정 길이 2016-09-15 hh:mm:ss.sss 형식으로 되어 있다.
  • 처리시간 T 0.1s, 0.312s, 2s 와 같이 최대 소수점 셋째 자리까지 기록하며 뒤에는 초 단위를 의미하는 s로 끝난다.
  • 예를 들어, 로그 문자열 2016-09-15 03:10:33.020 0.011s은 "2016년 9월 15일 오전 3시 10분 33.010초"부터 "2016년 9월 15일 오전 3시 10분 33.020초"까지 "0.011초" 동안 처리된 요청을 의미한다. (처리시간은 시작시간과 끝시간을 포함)
  • 서버에는 타임아웃이 3초로 적용되어 있기 때문에 처리시간은 0.001 ≦ T ≦ 3.000이다.
  • lines 배열은 응답완료시간 S를 기준으로 오름차순 정렬되어 있다.

출력 형식

  • solution 함수에서는 로그 데이터 lines 배열에 대해 초당 최대 처리량을 리턴한다.

입출력 예제

예제1

  • 입력: [
    "2016-09-15 01:00:04.001 2.0s",
    "2016-09-15 01:00:07.000 2s"
    ]
  • 출력: 1

예제2

  • 입력: [
    "2016-09-15 01:00:04.002 2.0s",
    "2016-09-15 01:00:07.000 2s"
    ]
  • 출력: 2
  • 설명: 처리시간은 시작시간과 끝시간을 포함하므로
    첫 번째 로그는 01:00:02.003 ~ 01:00:04.002에서 2초 동안 처리되었으며,
    두 번째 로그는 01:00:05.001 ~ 01:00:07.000에서 2초 동안 처리된다.
    따라서, 첫 번째 로그가 끝나는 시점과 두 번째 로그가 시작하는 시점의 구간인 01:00:04.002 ~ 01:00:05.001 1초 동안 최대 2개가 된다.

예제3

  • 입력: [
    "2016-09-15 20:59:57.421 0.351s",
    "2016-09-15 20:59:58.233 1.181s",
    "2016-09-15 20:59:58.299 0.8s",
    "2016-09-15 20:59:58.688 1.041s",
    "2016-09-15 20:59:59.591 1.412s",
    "2016-09-15 21:00:00.464 1.466s",
    "2016-09-15 21:00:00.741 1.581s",
    "2016-09-15 21:00:00.748 2.31s",
    "2016-09-15 21:00:00.966 0.381s",
    "2016-09-15 21:00:02.066 2.62s"
    ]
  • 출력: 7
  • 설명: 아래 타임라인 그림에서 빨간색으로 표시된 1초 각 구간의 처리량을 구해보면 (1)은 4개, (2)는 7개, (3)는 2개임을 알 수 있다. 따라서 초당 최대 처리량은 7이 되며, 동일한 최대 처리량을 갖는 1초 구간은 여러 개 존재할 수 있으므로 이 문제에서는 구간이 아닌 개수만 출력한다.

 

[풀이]

import datetime

def solution(lines):
    times = {}

    for time in lines:
        e_time = datetime.datetime.strptime(' '.join(time.split(' ')[:2]), '%Y-%m-%d %H:%M:%S.%f')
        dur = float(time.split(' ')[-1][:-1])
        s_time = e_time - datetime.timedelta(seconds = dur) + datetime.timedelta(seconds = 0.001)
        times[e_time] = 0 #끝난 시간
        times[s_time] = 1 #시작한 시간

    times = sorted(times.items())

    maxx, cur = 0, 0
    for s in range(len(times)):
        time, type = times[s][0], times[s][1]
        if type == 1:
            cur += 1

        d_time = time + datetime.timedelta(seconds=1) - datetime.timedelta(seconds = 0.001) #1초 범위
        e, d_cur = s, cur
        for e in range(s+1, len(times)): #1초 동안 추가로 시작한 부분 카운트
            e_time, e_type = times[e][0], times[e][1]
            if e_time > d_time: #1초가 지나면 break
                break
            if e_type == 1: #1초 동안 시작 된 부분만 카운트(끝난건 카운트x) -> d_cur
                d_cur += 1
        if type == 0:
            cur -= 1
        maxx = max(maxx, d_cur)

    return maxx

if __name__ == '__main__':
    solution(["2016-09-15 01:00:04.002 2.0s", "2016-09-15 01:00:07.000 2s"])
    solution(["2016-09-15 01:00:04.001 2.0s", "2016-09-15 01:00:07.000 2s"])

 

처음에는 1초 구간이 아니라 어느 한 시점의 최대 트래픽 양을 구하는 문제인 줄 알고 코드를 작성하였다. 각각의 트래픽이 시작하고, 끝나는 부분에서 트래픽 양이 바뀌므로 이 부분을 중심으로 코드를 작성하기로 하였다.

 

로그가 들어오면 시작시간과 끝나는 시간을 구해서 각각의 타입을 1과 0으로 정해 하나의 튜플에 저장해주고 계산을 해주었고 그제서야 1초 구간이 적용된다는 것을 확인하고 조금 수정해주었다.

 

times배열에 (시간, 타입(0: 끝난 시간, 1: 시작 시간))형태로  주어진 lines 배열을 계산해서 넣어준 뒤 시작과 끝나는 시간의 부분마다 그 시점부터 1초 뒤를 구간으로 잡은 뒤 그 구간동안 처리된 트래픽을 계산하는 방식으로 작성했다. 6개의 테스트는 통과했는데 정확성 테스트를 해보니까 정확도가 50%밖에 나오지 않았다ㅠㅠ

 

질문을 확인해보니까 datetime의 float으로 비교하는 것에서 문제가 생길 수도 있다는 것을 보고 datetime이 아니라 millisecond를 기준으로 int형태로 바꿔서 계산해주었다(여기서 문제에서 9월 15일 추석 당일이라고 명시했기 때문에 날짜 부분은 무시하고 시간부분만 다뤄줬다). 하지만 바뀌는건 없었고.. 본 코드 자체가 문제였다.

 

기존에는 시작시간-끝나는시간을 묶음으로 생각하지 않고 풀어서 그냥 카운트만 셌는데, 이를 묶음으로 생각해보기로 하였다. 

시작 시간을 기준으로 1초 기간을 계산할지, 끝나는 시간을 기준으로 할지 고민했었는데 시작 시간을 기준으로 하면 현재 시간 이전에 시작된 부분도 고려해줘야 하는 문제가 있었다. 끝나는 시간을 기준으로 하면 현재 시간 이전의 트래픽들은 모두 끝나있는 상태이기 때문에 이후의 트래픽만 고려해주면 된다(lines배열이 끝나는 시간 기준으로 정렬되어있기도 했다).

 

def solution(lines):

    s_time, e_time = [], []

    for time in lines:
        time = time.split(" ")
        hour, minute, second = time[1].split(":")
        second, millisecond = second.split(".")

        hour = int(hour) * 3600000
        minute = int(minute) * 60000
        second = int(second) * 1000
        millisecond = int(millisecond)

        e_time.append(hour+minute+second+millisecond) #끝난 시간
        duration = int(float(time[2][:-1]) * 1000)
        s_time.append(hour+minute+second+millisecond-duration+1) #시작 시간(처리 시간 포함 -> 1millisecond 추가)

    maxx = 0

    for i in range(len(lines)):

        d_time, cnt = e_time[i]+999, 1 #1초 구간 -> d_time

        for j in range(i+1, len(lines)): #1초 동안 시작한 트래픽의 수 카운트
        
            if  s_time[j] <= d_time: #1초가 지나면 break
                cnt += 1

        maxx = max(maxx, cnt)

    return maxx

 

확실히 시간 관련 문제가 많이 헷갈리고 어렵다ㅠㅠ 1초 범위가 뭐고.. 시작 끝 포함 범위가 뭔지.. 처음에는 이해도 안가서 계속 실행해가면서 millisecond 값을 바꿔서 작성했다ㅠㅠ

 

문제 설명

 

카카오TV에서 유명한 크리에이터로 활동 중인 죠르디는 환경 단체로부터 자신의 가장 인기있는 동영상에 지구온난화의 심각성을 알리기 위한 공익광고를 넣어 달라는 요청을 받았습니다. 평소에 환경 문제에 관심을 가지고 있던 "죠르디"는 요청을 받아들였고 광고효과를 높이기 위해 시청자들이 가장 많이 보는 구간에 공익광고를 넣으려고 합니다. "죠르디"는 시청자들이 해당 동영상의 어떤 구간을 재생했는 지 알 수 있는 재생구간 기록을 구했고, 해당 기록을 바탕으로 공익광고가 삽입될 최적의 위치를 고를 수 있었습니다.
참고로 광고는 재생 중인 동영상의 오른쪽 아래에서 원래 영상과 동시에 재생되는 PIP(Picture in Picture) 형태로 제공됩니다.

다음은 "죠르디"가 공익광고가 삽입될 최적의 위치를 고르는 과정을 그림으로 설명한 것입니다.

  • 그림의 파란색 선은 광고를 검토 중인 "죠르디" 동영상의 전체 재생 구간을 나타냅니다.
    • 위 그림에서, "죠르디" 동영상의 총 재생시간은 02시간 03분 55초 입니다.
  • 그림의 검은색 선들은 각 시청자들이 "죠르디"의 동영상을 재생한 구간의 위치를 표시하고 있습니다.
    • 검은색 선의 가운데 숫자는 각 재생 기록을 구분하는 ID를 나타냅니다.
    • 검은색 선에 표기된 왼쪽 끝 숫자와 오른쪽 끝 숫자는 시청자들이 재생한 동영상 구간의 시작 시각과 종료 시각을 나타냅니다.
    • 위 그림에서, 3번 재생 기록은 00시 25분 50초 부터 00시 48분 29초 까지 총 00시간 22분 39초 동안 죠르디의 동영상을 재생했습니다. 1
    • 위 그림에서, 1번 재생 기록은 01시 20분 15초 부터 01시 45분 14초 까지 총 00시간 24분 59초 동안 죠르디의 동영상을 재생했습니다.
  • 그림의 빨간색 선은 "죠르디"가 선택한 최적의 공익광고 위치를 나타냅니다.
    • 만약 공익광고의 재생시간이 00시간 14분 15초라면, 위의 그림처럼 01시 30분 59초 부터 01시 45분 14초 까지 공익광고를 삽입하는 것이 가장 좋습니다. 이 구간을 시청한 시청자들의 누적 재생시간이 가장 크기 때문입니다.
    • 01시 30분 59초 부터 01시 45분 14초 까지의 누적 재생시간은 다음과 같이 계산됩니다.
      • 01시 30분 59초 부터 01시 37분 44초 까지 : 4번, 1번 재생 기록이 두차례 있으므로 재생시간의 합은 00시간 06분 45초 X 2 = 00시간 13분 30초
      • 01시 37분 44초 부터 01시 45분 14초 까지 : 4번, 1번, 5번 재생 기록이 세차례 있으므로 재생시간의 합은 00시간 07분 30초 X 3 = 00시간 22분 30초
      • 따라서, 이 구간 시청자들의 누적 재생시간은 00시간 13분 30초 + 00시간 22분 30초 = 00시간 36분 00초입니다.

[문제]

"죠르디"의 동영상 재생시간 길이 play_time, 공익광고의 재생시간 길이 adv_time, 시청자들이 해당 동영상을 재생했던 구간 정보 logs가 매개변수로 주어질 때, 시청자들의 누적 재생시간이 가장 많이 나오는 곳에 공익광고를 삽입하려고 합니다. 이때, 공익광고가 들어갈 시작 시각을 구해서 return 하도록 solution 함수를 완성해주세요. 만약, 시청자들의 누적 재생시간이 가장 많은 곳이 여러 곳이라면, 그 중에서 가장 빠른 시작 시각을 return 하도록 합니다.

[제한사항]

  • play_time, adv_time은 길이 8로 고정된 문자열입니다.
    • play_time, adv_time은 HH:MM:SS 형식이며, 00:00:01 이상 99:59:59 이하입니다.
    • 즉, 동영상 재생시간과 공익광고 재생시간은 00시간 00분 01초 이상 99시간 59분 59초 이하입니다.
    • 공익광고 재생시간은 동영상 재생시간보다 짧거나 같게 주어집니다.
  • logs는 크기가 1 이상 300,000 이하인 문자열 배열입니다.
    • logs 배열의 각 원소는 시청자의 재생 구간을 나타냅니다.
    • logs 배열의 각 원소는 길이가 17로 고정된 문자열입니다.
    • logs 배열의 각 원소는 H1:M1:S1-H2:M2:S2 형식입니다.
      • H1:M1:S1은 동영상이 시작된 시각, H2:M2:S2는 동영상이 종료된 시각을 나타냅니다.
      • H1:M1:S1는 H2:M2:S2보다 1초 이상 이전 시각으로 주어집니다.
      • H1:M1:S1와 H2:M2:S2는 play_time 이내의 시각입니다.
  • 시간을 나타내는 HH, H1, H2의 범위는 00~99, 분을 나타내는 MM, M1, M2의 범위는 00~59, 초를 나타내는 SS, S1, S2의 범위는 00~59까지 사용됩니다. 잘못된 시각은 입력으로 주어지지 않습니다. (예: 04:60:24, 11:12:78, 123:12:45 등)
  • return 값의 형식
    • 공익광고를 삽입할 시각을 HH:MM:SS 형식의 8자리 문자열로 반환합니다.

[입출력 예]

play_time adv_time logs result
"02:03:55" "00:14:15" ["01:20:15-01:45:14", "00:40:31-01:00:00", "00:25:50-00:48:29", "01:30:59-01:53:29", "01:37:44-02:02:30"] "01:30:59"
"99:59:59" "25:00:00" ["69:59:59-89:59:59", "01:00:00-21:00:00", "79:59:59-99:59:59", "11:00:00-31:00:00"] "01:00:00"
"50:00:00" "50:00:00" ["15:36:51-38:21:49", "10:14:18-15:36:51", "38:21:49-42:51:45"] "00:00:00"

입출력 예에 대한 설명


입출력 예 #1
문제 예시와 같습니다.

입출력 예 #2

01:00:00에 공익광고를 삽입하면 26:00:00까지 재생되며, 이곳이 가장 좋은 위치입니다. 이 구간의 시청자 누적 재생시간은 다음과 같습니다.

  • 01:00:00-11:00:00 : 해당 구간이 1회(2번 기록) 재생되었으므로 누적 재생시간은 10시간 00분 00초 입니다.
  • 11:00:00-21:00:00 : 해당 구간이 2회(2번, 4번 기록) 재생되었으므로 누적 재생시간은 20시간 00분 00초 입니다.
  • 21:00:00-26:00:00 : 해당 구간이 1회(4번 기록) 재생되었으므로 누적 재생시간은 05시간 00분 00초 입니다.
  • 따라서, 이 구간의 시청자 누적 재생시간은 10시간 00분 00초 + 20시간 00분 00초 + 05시간 00분 00초 = 35시간 00분 00초 입니다.
  • 초록색으로 표시된 구간(69:59:59-94:59:59)에 광고를 삽입해도 동일한 결과를 얻을 수 있으나, 01:00:00이 69:59:59 보다 빠른 시각이므로, "01:00:00"을 return 합니다.

입출력 예 #3

동영상 재생시간과 공익광고 재생시간이 같으므로, 삽입할 수 있는 위치는 맨 처음(00:00:00)이 유일합니다.


  1. 동영상 재생시간 = 재생이 종료된 시각 - 재생이 시작된 시각(예를 들어, 00시 00분 01초부터 00시 00분 10초까지 동영상이 재생되었다면, 동영상 재생시간은 9초 입니다.) 

 

풀이

 

처음에 바로 생각했던 풀이는 간단했다.

1. HH:MM:SS 형태로 주어진 시간을 second단위로 바꾼다

2. 누적 시간 배열을 만들어서 시간당 보고 있는 시청자 수를 계산한다.

3. 광고 시간대로 잘라서 누적 시청자가 제일 많은 시작점을 찾는다.

 

def solution(play_time, adv_time, logs):

    #99h 59m :59s -> 359999s
    cct = [0 for i in range(360000)]
    timestamp = [[] for i in range(len(logs))]

    #second 단위로 변환
    for i in range(len(logs)):
        for time in logs[i].split('-'):
            time = time.split(':')
            time = ((int(time[0]) * 60) + int(time[1]))*60 + int(time[2])
            timestamp[i].append(time)
    play_time = play_time.split(':')
    play_time = ((int(play_time[0]) * 60) + int(play_time[1]))*60 + int(play_time[2])
    adv_time = adv_time.split(':')
    adv_time = ((int(adv_time[0]) * 60) + int(adv_time[1]))*60 + int(adv_time[2])
    
    if play_time == adv_time: return "00:00:00"
    
    #누적 시간 계산
    for i in timestamp:
        for j in range(i[0], i[1]+1):
            cct[j] += 1
    
    #최대 누적 재생시간 구하기
    maxx, insert = 0, 0
    for i in range(play_time - adv_time + 1):
        if cct[i] == 0:
            continue
        tmp = 0
        for j in range(i, i+adv_time+1):  
            tmp += cct[j]
        if maxx < tmp: 
            maxx, insert = tmp, i    

    h, m, s = str(insert//3600).rjust(2,'0'), str((insert%3600)//60).rjust(2,'0'), str((insert%3600)%60).rjust(2,'0')

    return ':'.join([h,m,s])

 

하지만 마지막 누적 시청자를 찾는 부분에서 시간 초과 문제가 발생하였다.

 

확인해보니 최대 누적 시간을 계산하는 과정 중에 시간 소요가 발생했다.

그렇기 때문에 for 문을 통해 전체 시간 길이를 돌면서 하나씩 확인하는 방식이 아니라 누적 시간을 계산할 때, 시청자 누적 수 뿐만 아니라 이전에 발생한 시청자 수도 같이 합해서 끝나는 시간에서 시작하는 시간을 빼는 방식으로 시간을 계산하였다.

 

시간 0 1 2 3 4 5 6 7 8
1 O O O O O        
2     O O O O O    
3       O O O O O  
시청자 수 1 1 2 3 3 2 2 1 0
누적 시청자 수 1 2 4 7 10 12 14 15 15

 

이와 같이 누적 시청자 수를 구해서 만약 2초에서 4초 사이에 광고가 나간다면 4초의 누적 시청자수(10) - 1초의 누적 시청자 수 (2)를 해주면 2, 3, 4초 동안의 누적 시청자 수인 8이 나온다.

 

누적 시간 계산은 logs를 돌면서 시청 시작 부분은 +1을 끝까지 해주고 시청 종료 부분은 끝까지 -1을 먼저 해줘서 시청자 수를 구한 다음 다시 전체 시간을 돌면서 누적 시청자 수를 구하는 방식으로 하였다.

 

def time2second(time):
    time = time.split(':')
    return ((int(time[0]) * 60) + int(time[1]))*60 + int(time[2])

def solution(play_time, adv_time, logs):

    play_time = time2second(play_time)
    adv_time = time2second(adv_time)
    cct = [0 for i in range(play_time+1)]

    #second 단위로 변환
    for i in range(len(logs)):
        time = logs[i].split('-')
        s = time2second(time[0])
        e = time2second(time[1])
        cct[s] += 1
        cct[e] -= 1
    
    if play_time == adv_time: return "00:00:00"
    
    #누적 시간 계산
    for i in range(1, len(cct)):
        cct[i] += cct[i-1]
    for i in range(1, len(cct)):
        cct[i] += cct[i-1]

    #최대 누적 재생시간 구하기
    maxx, insert = cct[adv_time-1], 0
    for i in range(1, play_time - adv_time + 2):
        tmp = cct[i+adv_time-1] - cct[i-1]
        if maxx < tmp: 
            maxx, insert = tmp, i    

    h, m, s = str(insert//3600).rjust(2,'0'), str((insert%3600)//60).rjust(2,'0'), str((insert%3600)%60).rjust(2,'0')

    return ':'.join([h,m,s])
테스트 1 〉	통과 (1.65ms, 10.6MB)
테스트 2 〉	통과 (7.33ms, 10.5MB)
테스트 3 〉	통과 (15.13ms, 11.2MB)
테스트 4 〉	통과 (207.86ms, 27.9MB)
테스트 5 〉	통과 (290.96ms, 34.1MB)
테스트 6 〉	통과 (137.01ms, 21.4MB)
테스트 7 〉	통과 (456.72ms, 41.1MB)
테스트 8 〉	통과 (434.63ms, 45.9MB)
테스트 9 〉	통과 (590.75ms, 54.3MB)
테스트 10 〉	통과 (631.43ms, 54.6MB)
테스트 11 〉	통과 (622.49ms, 52MB)
테스트 12 〉	통과 (639.43ms, 49.7MB)
테스트 13 〉	통과 (639.43ms, 54.5MB)
테스트 14 〉	통과 (455.07ms, 41MB)
테스트 15 〉	통과 (47.93ms, 15.1MB)
테스트 16 〉	통과 (438.52ms, 40.8MB)
테스트 17 〉	통과 (629.12ms, 54.5MB)
테스트 18 〉	통과 (542.11ms, 42.2MB)
테스트 19 〉	통과 (1.75ms, 10.5MB)
테스트 20 〉	통과 (1.47ms, 10.4MB)
테스트 21 〉	통과 (139.29ms, 20.3MB)
테스트 22 〉	통과 (141.34ms, 20.3MB)
테스트 23 〉	통과 (593.26ms, 47.1MB)
테스트 24 〉	통과 (486.74ms, 40.9MB)
테스트 25 〉	통과 (104.82ms, 19.6MB)
테스트 26 〉	통과 (60.80ms, 14.9MB)
테스트 27 〉	통과 (65.75ms, 17.3MB)
테스트 28 〉	통과 (57.01ms, 16.9MB)
테스트 29 〉	통과 (56.14ms, 16.6MB)
테스트 30 〉	통과 (51.41ms, 14.1MB)
테스트 31 〉	통과 (53.68ms, 14.9MB)

문제 설명

 

[본 문제는 정확성과 효율성 테스트 각각 점수가 있는 문제입니다.]

밤늦게 귀가할 때 안전을 위해 항상 택시를 이용하던 무지는 최근 야근이 잦아져 택시를 더 많이 이용하게 되어 택시비를 아낄 수 있는 방법을 고민하고 있습니다. "무지"는 자신이 택시를 이용할 때 동료인 어피치 역시 자신과 비슷한 방향으로 가는 택시를 종종 이용하는 것을 알게 되었습니다. "무지"는 "어피치"와 귀가 방향이 비슷하여 택시 합승을 적절히 이용하면 택시요금을 얼마나 아낄 수 있을 지 계산해 보고 "어피치"에게 합승을 제안해 보려고 합니다.

위 예시 그림은 택시가 이동 가능한 반경에 있는 6개 지점 사이의 이동 가능한 택시노선과 예상요금을 보여주고 있습니다.
그림에서 A와 B 두 사람은 출발지점인 4번 지점에서 출발해서 택시를 타고 귀가하려고 합니다. A의 집은 6번 지점에 있으며 B의 집은 2번 지점에 있고 두 사람이 모두 귀가하는 데 소요되는 예상 최저 택시요금이 얼마인 지 계산하려고 합니다.

  • 그림의 원은 지점을 나타내며 원 안의 숫자는 지점 번호를 나타냅니다.
    • 지점이 n개일 때, 지점 번호는 1부터 n까지 사용됩니다.
  • 지점 간에 택시가 이동할 수 있는 경로를 간선이라 하며, 간선에 표시된 숫자는 두 지점 사이의 예상 택시요금을 나타냅니다.
    • 간선은 편의 상 직선으로 표시되어 있습니다.
    • 위 그림 예시에서, 4번 지점에서 1번 지점으로(4→1) 가거나, 1번 지점에서 4번 지점으로(1→4) 갈 때 예상 택시요금은 10원으로 동일하며 이동 방향에 따라 달라지지 않습니다.
  • 예상되는 최저 택시요금은 다음과 같이 계산됩니다.
    • 4→1→5 : A, B가 합승하여 택시를 이용합니다. 예상 택시요금은 10 + 24 = 34원 입니다.
    • 5→6 : A가 혼자 택시를 이용합니다. 예상 택시요금은 2원 입니다.
    • 5→3→2 : B가 혼자 택시를 이용합니다. 예상 택시요금은 24 + 22 = 46원 입니다.
    • A, B 모두 귀가 완료까지 예상되는 최저 택시요금은 34 + 2 + 46 = 82원 입니다.

[문제]

지점의 개수 n, 출발지점을 나타내는 s, A의 도착지점을 나타내는 a, B의 도착지점을 나타내는 b, 지점 사이의 예상 택시요금을 나타내는 fares가 매개변수로 주어집니다. 이때, A, B 두 사람이 s에서 출발해서 각각의 도착 지점까지 택시를 타고 간다고 가정할 때, 최저 예상 택시요금을 계산해서 return 하도록 solution 함수를 완성해 주세요.
만약, 아예 합승을 하지 않고 각자 이동하는 경우의 예상 택시요금이 더 낮다면, 합승을 하지 않아도 됩니다.

 

[제한사항]

  • 지점갯수 n은 3 이상 200 이하인 자연수입니다.
  • 지점 s, a, b는 1 이상 n 이하인 자연수이며, 각기 서로 다른 값입니다.
    • 즉, 출발지점, A의 도착지점, B의 도착지점은 서로 겹치지 않습니다.
  • fares는 2차원 정수 배열입니다.
  • fares 배열의 크기는 2 이상 n x (n-1) / 2 이하입니다.
    • 예를들어, n = 6이라면 fares 배열의 크기는 2 이상 15 이하입니다. (6 x 5 / 2 = 15)
    • fares 배열의 각 행은 [c, d, f] 형태입니다.
    • c지점과 d지점 사이의 예상 택시요금이 f원이라는 뜻입니다.
    • 지점 c, d는 1 이상 n 이하인 자연수이며, 각기 서로 다른 값입니다.
    • 요금 f는 1 이상 100,000 이하인 자연수입니다.
    • fares 배열에 두 지점 간 예상 택시요금은 1개만 주어집니다. 즉, [c, d, f]가 있다면 [d, c, f]는 주어지지 않습니다.
  • 출발지점 s에서 도착지점 a와 b로 가는 경로가 존재하는 경우만 입력으로 주어집니다.

[입출력 예]

n s a b fares result
6 4 6 2 [[4, 1, 10], [3, 5, 24], [5, 6, 2], [3, 1, 41], [5, 1, 24], [4, 6, 50], [2, 4, 66], [2, 3, 22], [1, 6, 25]] 82
7 3 4 1 [[5, 7, 9], [4, 6, 4], [3, 6, 1], [3, 2, 3], [2, 1, 6]] 14
6 4 5 6 [[2,6,6], [6,3,7], [4,6,7], [6,5,11], [2,5,12], [5,3,20], [2,4,8], [4,3,9]] 18

입출력 예에 대한 설명


입출력 예 #1
문제 예시와 같습니다.

입출력 예 #2

  • 합승을 하지 않고, B는 3→2→1, A는 3→6→4 경로로 각자 택시를 타고 가는 것이 최저 예상 택시요금입니다.
  • 따라서 최저 예상 택시요금은 (3 + 6) + (1 + 4) = 14원 입니다.

입출력 예 #3

  • A와 B가 4→6 구간을 합승하고 B가 6번 지점에서 내린 후, A가6→5` 구간을 혼자 타고 가는 것이 최저 예상 택시요금입니다.
  • 따라서 최저 예상 택시요금은 7 + 11 = 18원 입니다.

 

풀이

 

이번 문제는 생각보다 쉽게 풀 수 있었다.

 

간단하게 다익스트라 알고리즘을 두 번 써서 풀면 되는데 첫 번째는 합승한 상태로 각 노드에 도착할 수 있는 최소 요금을 구하고 두 번째로 각 출발지에서 A, B가 자신의 집으로 갈 때의 최소 요금을 구해주면 된다. 합승 상태에서의 요금 + 합승이 끝난 후 그 출발지에서 각자의 집으로 가는 요금을 리스트에 넣고 최솟값을 구하면 바로 풀 수 있다.

 

import heapq

def dijkstra(graph, s):
    distances = {node: float('inf') for node in graph}  # 최단 거리 리스트
    distances[s], queue = 0, []
    heapq.heappush(queue, [distances[s], s])  # 시작 노드 큐에 push

    # dijkstra
    while queue:
        c_dis, c_des = heapq.heappop(queue)
        if distances[c_des] < c_dis:
            continue
        for n_des, n_dis in graph[c_des].items():
            distance = c_dis + n_dis
            if distance < distances[n_des]:
                distances[n_des] = distance
                heapq.heappush(queue, [distance, n_des])

    return distances


def solution(n, s, a, b, fares):
    graph = {}
    for n1, n2, w in fares:
        graph.setdefault(n1, {})[n2] = w
        graph.setdefault(n2, {})[n1] = w

    # 합승했을 때 최소 요금
    to_distances = dijkstra(graph, s)
    cost_list = [to_distances[a] + to_distances[b]]

    # 합승이 끝난 후 각자의 최소 요금
    for key, value in to_distances.items():
        if key == s: continue
        al_distances = dijkstra(graph, key)
        cost_list.append(al_distances[a] + al_distances[b] + value)

    return min(cost_list)

 

정확성  테스트
테스트 1 〉	통과 (0.05ms, 10.2MB)
테스트 2 〉	통과 (0.04ms, 10.3MB)
테스트 3 〉	통과 (0.06ms, 10.3MB)
테스트 4 〉	통과 (0.19ms, 10.3MB)
테스트 5 〉	통과 (0.16ms, 10.3MB)
테스트 6 〉	통과 (0.24ms, 10.3MB)
테스트 7 〉	통과 (0.22ms, 10.3MB)
테스트 8 〉	통과 (0.34ms, 10.3MB)
테스트 9 〉	통과 (0.39ms, 10.3MB)
테스트 10 〉	통과 (0.75ms, 10.3MB)
효율성  테스트
테스트 1 〉	통과 (22.58ms, 10.3MB)
테스트 2 〉	통과 (107.66ms, 10.6MB)
테스트 3 〉	통과 (44.70ms, 10.3MB)
테스트 4 〉	통과 (49.47ms, 10.3MB)
테스트 5 〉	통과 (47.89ms, 10.4MB)
테스트 6 〉	통과 (47.73ms, 10.2MB)
테스트 7 〉	통과 (798.42ms, 14.8MB)
테스트 8 〉	통과 (864.80ms, 14.8MB)
테스트 9 〉	통과 (747.26ms, 14.5MB)
테스트 10 〉	통과 (730.82ms, 14.5MB)
테스트 11 〉	통과 (686.27ms, 14.5MB)
테스트 12 〉	통과 (455.18ms, 12.4MB)
테스트 13 〉	통과 (437.16ms, 12.4MB)
테스트 14 〉	통과 (477.74ms, 12.5MB)
테스트 15 〉	통과 (485.12ms, 12.4MB)
테스트 16 〉	통과 (43.76ms, 10.2MB)
테스트 17 〉	통과 (42.48ms, 10.3MB)
테스트 18 〉	통과 (38.63ms, 10.3MB)
테스트 19 〉	통과 (97.01ms, 10.4MB)
테스트 20 〉	통과 (148.99ms, 10.6MB)
테스트 21 〉	통과 (149.60ms, 10.6MB)
테스트 22 〉	통과 (459.54ms, 12.4MB)
테스트 23 〉	통과 (436.14ms, 12.5MB)
테스트 24 〉	통과 (439.91ms, 12.5MB)
테스트 25 〉	통과 (30.09ms, 10.3MB)
테스트 26 〉	통과 (26.19ms, 10.3MB)
테스트 27 〉	통과 (130.67ms, 10.5MB)
테스트 28 〉	통과 (125.04ms, 10.5MB)
테스트 29 〉	통과 (14.85ms, 10.4MB)
테스트 30 〉	통과 (15.27ms, 10.3MB)

문제 설명

 

[본 문제는 정확성과 효율성 테스트 각각 점수가 있는 문제입니다.]

카카오는 하반기 경력 개발자 공개채용을 진행 중에 있으며 현재 지원서 접수와 코딩테스트가 종료되었습니다. 이번 채용에서 지원자는 지원서 작성 시 아래와 같이 4가지 항목을 반드시 선택하도록 하였습니다.

  • 코딩테스트 참여 개발언어 항목에 cpp, java, python 중 하나를 선택해야 합니다.
  • 지원 직군 항목에 backend와 frontend 중 하나를 선택해야 합니다.
  • 지원 경력구분 항목에 junior와 senior 중 하나를 선택해야 합니다.
  • 선호하는 소울푸드로 chicken과 pizza 중 하나를 선택해야 합니다.

인재영입팀에 근무하고 있는 니니즈는 코딩테스트 결과를 분석하여 채용에 참여한 개발팀들에 제공하기 위해 지원자들의 지원 조건을 선택하면 해당 조건에 맞는 지원자가 몇 명인 지 쉽게 알 수 있는 도구를 만들고 있습니다.
예를 들어, 개발팀에서 궁금해하는 문의사항은 다음과 같은 형태가 될 수 있습니다.
코딩테스트에 java로 참여했으며, backend 직군을 선택했고, junior 경력이면서, 소울푸드로 pizza를 선택한 사람 중 코딩테스트 점수를 50점 이상 받은 지원자는 몇 명인가?

물론 이 외에도 각 개발팀의 상황에 따라 아래와 같이 다양한 형태의 문의가 있을 수 있습니다.

  • 코딩테스트에 python으로 참여했으며, frontend 직군을 선택했고, senior 경력이면서, 소울푸드로 chicken을 선택한 사람 중 코딩테스트 점수를 100점 이상 받은 사람은 모두 몇 명인가?
  • 코딩테스트에 cpp로 참여했으며, senior 경력이면서, 소울푸드로 pizza를 선택한 사람 중 코딩테스트 점수를 100점 이상 받은 사람은 모두 몇 명인가?
  • backend 직군을 선택했고, senior 경력이면서 코딩테스트 점수를 200점 이상 받은 사람은 모두 몇 명인가?
  • 소울푸드로 chicken을 선택한 사람 중 코딩테스트 점수를 250점 이상 받은 사람은 모두 몇 명인가?
  • 코딩테스트 점수를 150점 이상 받은 사람은 모두 몇 명인가?

즉, 개발팀에서 궁금해하는 내용은 다음과 같은 형태를 갖습니다.

* [조건]을 만족하는 사람 중 코딩테스트 점수를 X점 이상 받은 사람은 모두 몇 명인가?


[문제]

지원자가 지원서에 입력한 4가지의 정보와 획득한 코딩테스트 점수를 하나의 문자열로 구성한 값의 배열 info, 개발팀이 궁금해하는 문의조건이 문자열 형태로 담긴 배열 query가 매개변수로 주어질 때,
각 문의조건에 해당하는 사람들의 숫자를 순서대로 배열에 담아 return 하도록 solution 함수를 완성해 주세요.

[제한사항]

  • info 배열의 크기는 1 이상 50,000 이하입니다.
  • info 배열 각 원소의 값은 지원자가 지원서에 입력한 4가지 값과 코딩테스트 점수를 합친 "개발언어 직군 경력 소울푸드 점수" 형식입니다.
    • 개발언어는 cpp, java, python 중 하나입니다.
    • 직군은 backend, frontend 중 하나입니다.
    • 경력은 junior, senior 중 하나입니다.
    • 소울푸드는 chicken, pizza 중 하나입니다.
    • 점수는 코딩테스트 점수를 의미하며, 1 이상 100,000 이하인 자연수입니다.
    • 각 단어는 공백문자(스페이스 바) 하나로 구분되어 있습니다.
  • query 배열의 크기는 1 이상 100,000 이하입니다.
  • query의 각 문자열은 "[조건] X" 형식입니다.
    • [조건]은 "개발언어 and 직군 and 경력 and 소울푸드" 형식의 문자열입니다.
    • 언어는 cpp, java, python, - 중 하나입니다.
    • 직군은 backend, frontend, - 중 하나입니다.
    • 경력은 junior, senior, - 중 하나입니다.
    • 소울푸드는 chicken, pizza, - 중 하나입니다.
    • '-' 표시는 해당 조건을 고려하지 않겠다는 의미입니다.
    • X는 코딩테스트 점수를 의미하며 조건을 만족하는 사람 중 X점 이상 받은 사람은 모두 몇 명인 지를 의미합니다.
    • 각 단어는 공백문자(스페이스 바) 하나로 구분되어 있습니다.
    • 예를 들면, "cpp and - and senior and pizza 500"은 "cpp로 코딩테스트를 봤으며, 경력은 senior 이면서 소울푸드로 pizza를 선택한 지원자 중 코딩테스트 점수를 500점 이상 받은 사람은 모두 몇 명인가?"를 의미합니다.

[입출력 예]

infoqueryresult

info query result
["java backend junior pizza 150","python frontend senior chicken 210","python frontend senior chicken 150","cpp backend senior pizza 260","java backend junior chicken 80","python backend senior chicken 50"] ["java and backend and junior and pizza 100","python and frontend and senior and chicken 200","cpp and - and senior and pizza 250","- and backend and senior and - 150","- and - and - and chicken 100","- and - and - and - 150"] [1,1,1,1,2,4]

입출력 예에 대한 설명

지원자 정보를 표로 나타내면 다음과 같습니다.

언어직군경력소울 푸드점수

언어 직군 경력 소울 푸드 점수
java backend junior pizza 150
python frontend senior chicken 210
python frontend senior chicken 150
cpp backend senior pizza 260
java backend junior chicken 80
python backend senior chicken 50
  • "java and backend and junior and pizza 100" : java로 코딩테스트를 봤으며, backend 직군을 선택했고 junior 경력이면서 소울푸드로 pizza를 선택한 지원자 중 코딩테스트 점수를 100점 이상 받은 지원자는 1명 입니다.
  • "python and frontend and senior and chicken 200" : python으로 코딩테스트를 봤으며, frontend 직군을 선택했고, senior 경력이면서 소울 푸드로 chicken을 선택한 지원자 중 코딩테스트 점수를 200점 이상 받은 지원자는 1명 입니다.
  • "cpp and - and senior and pizza 250" : cpp로 코딩테스트를 봤으며, senior 경력이면서 소울푸드로 pizza를 선택한 지원자 중 코딩테스트 점수를 250점 이상 받은 지원자는 1명 입니다.
  • "- and backend and senior and - 150" : backend 직군을 선택했고, senior 경력인 지원자 중 코딩테스트 점수를 150점 이상 받은 지원자는 1명 입니다.
  • "- and - and - and chicken 100" : 소울푸드로 chicken을 선택한 지원자 중 코딩테스트 점수를 100점 이상을 받은 지원자는 2명 입니다.
  • "- and - and - and - 150" : 코딩테스트 점수를 150점 이상 받은 지원자는 4명 입니다.

 

풀이

 

처음에는 직관적으로 for문을 이용해서 코드를 짰더니 정확성 테스트는 통과했지만 효율성 테스트를 통과하지 못했다. 입력받은 info와 query를 and와 -를 제외해서 공백을 기준으로 나눈 뒤 issubset함수를 이용해서 condition조건이 다 포함되는지 확인하는 방식으로 구현했다.

def solution(info, query):
    answer = []
    applicant = [[] for i in range(len(info))]
    condition = [[] for i in range(len(query))]
    for i in range(len(info)):
        applicant[i].extend(info[i].split(' '))
    for i in range(len(query)):
        for j in query[i].split(' '):
            if j != "and" and j != "-":
                condition[i].append(j)
    
    for i in range(len(condition)):
        count = 0
        for j in range(len(applicant)):
            if set(condition[i][:-1]).issubset(set(applicant[j][:-1])) and int(condition[i][-1]) <= int(applicant[j][-1]):
                count += 1
        answer.append(count)           

    return answer

 

테스트 1 〉	통과 (0.34ms, 10.4MB)
테스트 2 〉	통과 (0.17ms, 10.4MB)
테스트 3 〉	통과 (1.45ms, 10.4MB)
테스트 4 〉	통과 (14.41ms, 10.5MB)
테스트 5 〉	통과 (65.44ms, 10.6MB)
테스트 6 〉	통과 (154.84ms, 10.8MB)
테스트 7 〉	통과 (74.16ms, 11.1MB)
테스트 8 〉	통과 (343.10ms, 12.5MB)
테스트 9 〉	통과 (363.39ms, 12.6MB)
테스트 10 〉	통과 (361.65ms, 12.7MB)
테스트 11 〉	통과 (61.57ms, 10.6MB)
테스트 12 〉	통과 (155.00ms, 10.7MB)
테스트 13 〉	통과 (73.67ms, 11.2MB)
테스트 14 〉	통과 (321.55ms, 11.5MB)
테스트 15 〉	통과 (371.14ms, 11.4MB)
테스트 16 〉	통과 (64.87ms, 10.7MB)
테스트 17 〉	통과 (160.35ms, 10.7MB)
테스트 18 〉	통과 (356.55ms, 11.4MB)

 

info배열은 50000까지, query배열은 100000까지 존재하므로 단순하게 for문을 이용해서 코드를 짜면 O(50000 * 100000)의 시간복잡도가 나오므로 효율성 테스트를 통과하기 위해 applicant를 코딩테스트 점수를 기준으로 정렬한 뒤 lower bound를 이용하여 개발팀이 원하는 코딩테스트 점수 이상의 지원자에 한해서만 남은 요소를 비교하도록 바꿔줬다. 위의 방법에 비해 1/2넘게 시간이 줄었지만 효율성 테스트는 통과하지 못했다.

 

def solution(info, query):
    answer = []
    applicant = [[] for i in range(len(info))]
    condition = [[] for i in range(len(query))]

    for i in range(len(info)):
        applicant[i].extend(info[i].split(' '))

    for i in range(len(query)):
        for j in query[i].split(' '):
            if j != "and" and j != "-":
                condition[i].append(j)
    
    applicant.sort(key=lambda x:int(x[-1]))
    
    for i in range(len(condition)):
        left, right, target = 0, len(applicant)-1, int(condition[i][-1])
        while(left < right):
            mid = (left+right)//2
            if target <= int(applicant[mid][-1]):
                right = mid
            else:
                left = mid+1
        
        count = 0
        for j in range(right, len(applicant)):
            if set(condition[i][:-1]).issubset(set(applicant[j][:-1])):
                count += 1
        answer.append(count)           

    return answer
테스트 1 〉	통과 (0.14ms, 10.3MB)
테스트 2 〉	통과 (0.13ms, 10.5MB)
테스트 3 〉	통과 (0.99ms, 10.4MB)
테스트 4 〉	통과 (10.21ms, 10.5MB)
테스트 5 〉	통과 (40.19ms, 10.7MB)
테스트 6 〉	통과 (76.25ms, 10.6MB)
테스트 7 〉	통과 (37.37ms, 11.1MB)
테스트 8 〉	통과 (190.00ms, 12.6MB)
테스트 9 〉	통과 (171.76ms, 13MB)
테스트 10 〉	통과 (190.56ms, 13MB)
테스트 11 〉	통과 (36.94ms, 10.5MB)
테스트 12 〉	통과 (77.33ms, 10.7MB)
테스트 13 〉	통과 (36.34ms, 11MB)
테스트 14 〉	통과 (156.70ms, 11.6MB)
테스트 15 〉	통과 (150.55ms, 11.6MB)
테스트 16 〉	통과 (35.04ms, 10.6MB)
테스트 17 〉	통과 (74.16ms, 10.5MB)
테스트 18 〉	통과 (145.73ms, 11.5MB)

 

여러 방법을 써도 자꾸 유효성 검사 통과가 안돼서 결국 문제 해설을 확인하고 힌트를 얻었다.

https://tech.kakao.com/2021/01/25/2021-kakao-recruitment-round-1/

 

2021 카카오 신입공채 1차 온라인 코딩 테스트 for Tech developers 문제해설

지난 2020년 9월 12일 토요일 오후 2시부터 7시까지 5시간 동안 2021 카카오 신입 개발자 공채 1차 코딩 테스트가 진행되었습니다. 테스트에는 총 7개의 문제가 출제되었으며, 개발 언어는 C++, Java, Jav

tech.kakao.com

아래와 같이 info가 들어오면 query에서 true값이 나오는 모든 경우의 수를 group형태로 만들어서 key로 저장하고 점수를 value로 저장해둔 뒤 query가 들어오면 해당 값을 key로 value에 저장되어 있는 점수 리스트 중 조건에 알맞는 개수를 세서 return해주면 된다. 이 때, lower bound를 써서 개수를 세면 속도가 더 빨라진다.

 

언어 직군 경력 소울 푸드 점수
java backend junior pizza 150
backend junior pizza 150
java junior pizza 150
java backend pizza 150
java backend junior 150
junior pizza 150
backend pizza 150
… (생략)        
java 150
150

 

from collections import defaultdict

def solution(info, query):
    answer = []
    group = defaultdict(list)

    #점수를 제외한 값을 key, 점수 리스트를 value로 group생성
    for i in range(len(info)):
        tmp = info[i].split(' ')
        group[tmp[0]+tmp[1]+tmp[2]+tmp[3]].append(int(tmp[4]))
        group['-'+tmp[1]+tmp[2]+tmp[3]].append(int(tmp[4]))
        group['-'+'-'+tmp[2]+tmp[3]].append(int(tmp[4]))
        group['-'+tmp[1]+'-'+tmp[3]].append(int(tmp[4]))
        group['-'+tmp[1]+tmp[2]+'-'].append(int(tmp[4]))
        group['-'+'-'+'-'+tmp[3]].append(int(tmp[4]))
        group['-'+'-'+tmp[2]+'-'].append(int(tmp[4]))
        group['-'+tmp[1]+'-'+'-'].append(int(tmp[4]))
        group['-'+'-'+'-'+'-'].append(int(tmp[4]))
        group[tmp[0]+'-'+tmp[2]+tmp[3]].append(int(tmp[4]))
        group[tmp[0]+'-'+'-'+tmp[3]].append(int(tmp[4]))
        group[tmp[0]+'-'+'-'+'-'].append(int(tmp[4]))
        group[tmp[0]+'-'+tmp[2]+'-'].append(int(tmp[4]))
        group[tmp[0]+tmp[1]+'-'+tmp[3]].append(int(tmp[4]))
        group[tmp[0]+tmp[1]+'-'+'-'].append(int(tmp[4]))
        group[tmp[0]+tmp[1]+tmp[2]+'-'].append(int(tmp[4]))

    for value in group.values():
        value.sort()
    #group의 key에서 해당 query가 있는지 확인 후 이진 탐색으로 인원수세기
    for i in range(len(query)):
        query[i] = [i for i in query[i].split() if i != 'and']
        q_key = query[i][0]+query[i][1]+query[i][2]+query[i][3]
        q_score = int(query[i][4])
        if q_key in group:
            i_score = group[q_key]
            left, right, target = 0, len(i_score)-1, q_score
            if i_score[-1] >= q_score:
                while(left < right):
                    mid = (left+right)//2
                    if target <= i_score[mid]:
                       right = mid
                    else:
                      left = mid+1
                answer.append(len(group[q_key]) - right)
            else:   
                answer.append(0)
        else:
            answer.append(0)
    return answer
테스트 1 〉	통과 (0.19ms, 10.3MB)
테스트 2 〉	통과 (0.20ms, 10.6MB)
테스트 3 〉	통과 (0.55ms, 10.4MB)
테스트 4 〉	통과 (2.05ms, 10.6MB)
테스트 5 〉	통과 (3.51ms, 10.7MB)
테스트 6 〉	통과 (7.16ms, 10.5MB)
테스트 7 〉	통과 (5.21ms, 11.2MB)
테스트 8 〉	통과 (37.81ms, 11.5MB)
테스트 9 〉	통과 (41.16ms, 13.1MB)
테스트 10 〉	통과 (41.99ms, 13.8MB)
테스트 11 〉	통과 (3.85ms, 10.8MB)
테스트 12 〉	통과 (7.05ms, 10.9MB)
테스트 13 〉	통과 (5.28ms, 11.2MB)
테스트 14 〉	통과 (23.97ms, 12.1MB)
테스트 15 〉	통과 (25.10ms, 12.2MB)
테스트 16 〉	통과 (3.50ms, 10.6MB)
테스트 17 〉	통과 (7.64ms, 10.7MB)
테스트 18 〉	통과 (24.36ms, 12.2MB)

 

테스트 1 〉	통과 (880.49ms, 88.8MB)
테스트 2 〉	통과 (1039.00ms, 89.1MB)
테스트 3 〉	통과 (1003.83ms, 75.8MB)
테스트 4 〉	통과 (977.12ms, 77.1MB)​

 

배열의 인덱스에 접근하는데도 생각보다 많은 시간이 드는 듯 하다. 계속 효율성 테스트를 통과 못해서 이진탐색하는 부분의 배열 접근을 줄였더니 통과할 수 있었다. group을 생성하는 부분은 시간을 조금이라도 줄이기 위해 모든 경우의 수를 직접 적어주었다.

i_score 배열에 조건을 만족하는 score가 없을 시에 answer에 0을 넣어야 하는데 이 부분을 생각하지 못해서.. 헤매기도 했다..ㅎ

문제 설명

 

레스토랑을 운영하던 스카피는 코로나19로 인한 불경기를 극복하고자 메뉴를 새로 구성하려고 고민하고 있습니다.
기존에는 단품으로만 제공하던 메뉴를 조합해서 코스요리 형태로 재구성해서 새로운 메뉴를 제공하기로 결정했습니다. 어떤 단품메뉴들을 조합해서 코스요리 메뉴로 구성하면 좋을 지 고민하던 "스카피"는 이전에 각 손님들이 주문할 때 가장 많이 함께 주문한 단품메뉴들을 코스요리 메뉴로 구성하기로 했습니다.
단, 코스요리 메뉴는 최소 2가지 이상의 단품메뉴로 구성하려고 합니다. 또한, 최소 2명 이상의 손님으로부터 주문된 단품메뉴 조합에 대해서만 코스요리 메뉴 후보에 포함하기로 했습니다.

예를 들어, 손님 6명이 주문한 단품메뉴들의 조합이 다음과 같다면,
(각 손님은 단품메뉴를 2개 이상 주문해야 하며, 각 단품메뉴는 A ~ Z의 알파벳 대문자로 표기합니다.)

손님 번호 주문한 단품메뉴 조합
1번 손님 A, B, C, F, G
2번 손님 A, C
3번 손님 C, D, E
4번 손님 A, C, D, E
5번 손님 B, C, F, G
6번 손님 A, C, D, E, H

가장 많이 함께 주문된 단품메뉴 조합에 따라 "스카피"가 만들게 될 코스요리 메뉴 구성 후보는 다음과 같습니다.

코스 종류 메뉴 구성설명
요리 2개 코스 A, C 1번, 2번, 4번, 6번 손님으로부터 총 4번 주문됐습니다.
요리 3개 코스 C, D, E 3번, 4번, 6번 손님으로부터 총 3번 주문됐습니다.
요리 4개 코스 B, C, F, G 1번, 5번 손님으로부터 총 2번 주문됐습니다.
요리 4개 코스 A, C, D, E 4번, 6번 손님으로부터 총 2번 주문됐습니다.

[문제]

각 손님들이 주문한 단품메뉴들이 문자열 형식으로 담긴 배열 orders, "스카피"가 추가하고 싶어하는 코스요리를 구성하는 단품메뉴들의 갯수가 담긴 배열 course가 매개변수로 주어질 때, "스카피"가 새로 추가하게 될 코스요리의 메뉴 구성을 문자열 형태로 배열에 담아 return 하도록 solution 함수를 완성해 주세요.

[제한사항]

  • orders 배열의 크기는 2 이상 20 이하입니다.
  • orders 배열의 각 원소는 크기가 2 이상 10 이하인 문자열입니다.
    • 각 문자열은 알파벳 대문자로만 이루어져 있습니다.
    • 각 문자열에는 같은 알파벳이 중복해서 들어있지 않습니다.
  • course 배열의 크기는 1 이상 10 이하입니다.
    • course 배열의 각 원소는 2 이상 10 이하인 자연수가 오름차순으로 정렬되어 있습니다.
    • course 배열에는 같은 값이 중복해서 들어있지 않습니다.
  • 정답은 각 코스요리 메뉴의 구성을 문자열 형식으로 배열에 담아 사전 순으로 오름차순 정렬해서 return 해주세요.
    • 배열의 각 원소에 저장된 문자열 또한 알파벳 오름차순으로 정렬되어야 합니다.
    • 만약 가장 많이 함께 주문된 메뉴 구성이 여러 개라면, 모두 배열에 담아 return 하면 됩니다.
    • orders와 course 매개변수는 return 하는 배열의 길이가 1 이상이 되도록 주어집니다.

[입출력 예]

orders course result
["ABCFG", "AC", "CDE", "ACDE", "BCFG", "ACDEH"] [2,3,4] ["AC", "ACDE", "BCFG", "CDE"]
["ABCDE", "AB", "CD", "ADE", "XYZ", "XYZ", "ACD"] [2,3,5] ["ACD", "AD", "ADE", "CD", "XYZ"]
["XYZ", "XWY", "WXA"] [2,3,4] ["WX", "XY"]

입출력 예에 대한 설명


입출력 예 #1
문제의 예시와 같습니다.

입출력 예 #2
AD가 세 번, CD가 세 번, ACD가 두 번, ADE가 두 번, XYZ 가 두 번 주문됐습니다.
요리 5개를 주문한 손님이 1명 있지만, 최소 2명 이상의 손님에게서 주문된 구성만 코스요리 후보에 들어가므로, 요리 5개로 구성된 코스요리는 새로 추가하지 않습니다.

입출력 예 #3
WX가 두 번, XY가 두 번 주문됐습니다.
3명의 손님 모두 단품메뉴를 3개씩 주문했지만, 최소 2명 이상의 손님에게서 주문된 구성만 코스요리 후보에 들어가므로, 요리 3개로 구성된 코스요리는 새로 추가하지 않습니다.
또, 단품메뉴를 4개 이상 주문한 손님은 없으므로, 요리 4개로 구성된 코스요리 또한 새로 추가하지 않습니다.

 

풀이

 

이번 문제도 매우 간단하게 풀 수 있다.

1. 손님이 주문하는 메뉴 목록인 orders가 알파벳순대로 들어오지 않기 때문에 먼저 정렬해준다.

2. 새로 만드려는 course의 메뉴 수만큼 조합을 만든다. 이 때, itertools를 사용하면 쉽게 조합을 만들 수 있다. combinations외에도 순열, 중복순열 등 여러 함수가 존재한다.

3. 각 손님의 메뉴에 대해서 조합이 만들어졌으면 개수를 세서 딕셔너리 형태로 저장한다.

4. 2 이상의 가장 큰 value를 answer에 추가한 뒤 모든 course를 만들었으면 정렬해서 return한다.

 

from itertools import combinations

def solution(orders, course):
    answer = []
    #orders 정렬
    for i in range(len(orders)):    orders[i] = sorted(orders[i])

    for i in course:
        com_orders, count = [], {}
        #course의 메뉴 수대로 조합 만들기
        for j in range(len(orders)):
            com_orders.extend([''.join(k) for k in combinations(list(orders[j]), i)])
        #메뉴의 개수를 세서 count 딕셔너리 만들기
        for j in com_orders:
            try: count[j]+=1
            except: count[j]=1
        #count의 value 중 2가 넘는 가장 큰 값의 key 구하기
        if count:
            m = max(count.values())
            for key, value in count.items():
                if value == m and value>=2:
                    answer.append(key)
    answer.sort()

    return answer

 

테스트 1 〉	통과 (0.09ms, 10.1MB)
테스트 2 〉	통과 (0.05ms, 10.1MB)
테스트 3 〉	통과 (0.08ms, 10.2MB)
테스트 4 〉	통과 (0.08ms, 10.3MB)
테스트 5 〉	통과 (0.09ms, 10.2MB)
테스트 6 〉	통과 (0.20ms, 10.2MB)
테스트 7 〉	통과 (0.21ms, 10.1MB)
테스트 8 〉	통과 (1.65ms, 10MB)
테스트 9 〉	통과 (1.08ms, 10.3MB)
테스트 10 〉	통과 (1.67ms, 10.4MB)
테스트 11 〉	통과 (0.88ms, 10.2MB)
테스트 12 〉	통과 (1.12ms, 10.2MB)
테스트 13 〉	통과 (1.61ms, 10.2MB)
테스트 14 〉	통과 (1.08ms, 10.2MB)
테스트 15 〉	통과 (1.62ms, 10.3MB)
테스트 16 〉	통과 (0.39ms, 10.2MB)
테스트 17 〉	통과 (0.22ms, 10.1MB)
테스트 18 〉	통과 (0.11ms, 10.2MB)
테스트 19 〉	통과 (0.05ms, 10.2MB)
테스트 20 〉	통과 (0.26ms, 10.2MB)

문제 설명

 

n명이 입국심사를 위해 줄을 서서 기다리고 있습니다. 각 입국심사대에 있는 심사관마다 심사하는데 걸리는 시간은 다릅니다.

처음에 모든 심사대는 비어있습니다. 한 심사대에서는 동시에 한 명만 심사를 할 수 있습니다. 가장 앞에 서 있는 사람은 비어 있는 심사대로 가서 심사를 받을 수 있습니다. 하지만 더 빨리 끝나는 심사대가 있으면 기다렸다가 그곳으로 가서 심사를 받을 수도 있습니다.

모든 사람이 심사를 받는데 걸리는 시간을 최소로 하고 싶습니다.

입국심사를 기다리는 사람 수 n, 각 심사관이 한 명을 심사하는데 걸리는 시간이 담긴 배열 times가 매개변수로 주어질 때, 모든 사람이 심사를 받는데 걸리는 시간의 최솟값을 return 하도록 solution 함수를 작성해주세요.

제한사항

  • 입국심사를 기다리는 사람은 1명 이상 1,000,000,000명 이하입니다.
  • 각 심사관이 한 명을 심사하는데 걸리는 시간은 1분 이상 1,000,000,000분 이하입니다.
  • 심사관은 1명 이상 100,000명 이하입니다.

입출력 예

n time return
6 [7, 10] 28

입출력 예 설명

가장 첫 두 사람은 바로 심사를 받으러 갑니다.

7분이 되었을 때, 첫 번째 심사대가 비고 3번째 사람이 심사를 받습니다.

10분이 되었을 때, 두 번째 심사대가 비고 4번째 사람이 심사를 받습니다.

14분이 되었을 때, 첫 번째 심사대가 비고 5번째 사람이 심사를 받습니다.

20분이 되었을 때, 두 번째 심사대가 비지만 6번째 사람이 그곳에서 심사를 받지 않고 1분을 더 기다린 후에 첫 번째 심사대에서 심사를 받으면 28분에 모든 사람의 심사가 끝납니다.

출처

※ 공지 - 2019년 9월 4일 문제에 새로운 테스트 케이스를 추가하였습니다. 도움을 주신 weaver9651 님께 감사드립니다.

 

풀이

import numpy as np

def solution(n, times):
    
    times.sort()
    immi = [[] for i in range(len(times))]

    for i in range(len(times)):
        immi[i] = [times[i], 0, 0]

    #가능한 최대 시간
    max = times[-1] * n
    for i in range(max):
        chk = 0
        for j in range(len(times)):
            #시간을 다 채운 후 심사대 비우기, 시간 증가
            if (immi[j][0]-1) == immi[j][1]:
                immi[j][1], immi[j][2] = 0, 0
            elif immi[j][2] == 1:
                immi[j][1] += 1
            #심사할 사람이 남아 있고 심사대가 비어있을 때
            if n!=0 and immi[j][1]==0:
                n -= 1
                immi[j][2] = 1
            chk += immi[j][2]

        if n==0 and chk==0:
            return i
            
    return max

처음에는 이런식으로 반복문을 통해 1분씩 증가해가면서 심사 시간, 지금 심사하고 있는 시간, 현재 심사대에 사람이 있는지 여부를 배열에 넣고 하나씩 계산해보려고 했는데 이러면 마지막에 가장 적은 시간이 나오는 심사대를 고르는 과정이 복잡해져서 다른 아이디어를 생각했다.

 

예를 들어서 times배열이 [4, 5, 10, 13]이고 11명의 사람이 심사받는다고 가정해보자.

이런식으로 총 20분이 걸린다. 이 때, 4번은 4명, 5번은 4명, 10번은 2명, 13번은 1명의 사람을 심사할 수 있다. 이 값을 가지고 시간을 계산해주면 된다.

 

20분 동안 심사한다고 했을 때, 4번은 5명, 5번은 4명, 10번은 2명, 13번은 1명의 사람을 심사할 수 있으므로 총 12명의 사람을 심사할 수 있다. 19분 동안 심사한다고 가정해보자. 4번은 4명, 5번은 3명, 10번은 1명, 13번은 1명으로 총 9명의 사람을 심사할 수 있게 된다. 이때는 11명보다 적기 때문에 틀린 값이 된다. 즉, 11명 이상 검사할 수 있는 시간 중 가장 작은 값을 찾으면 된다.

 

import numpy as np

def solution(n, times):
    times.sort()
    times = np.array(times)
    left, right = 0, times[-1]*n

    while(left < right):
        mid = (left+right)//2
        if sum(mid//times) <= n:
            left = mid+1
        else:
            right = mid-1

    return mid

 

이런식으로 numpy를 써서 푸니까 "TypeError: Object of thpe int64 is not JSON serialliszble" 이런 에러가 발생한다. times배열에 1,000,000,000까지 들어올 수 있으니까 int64형이 numpy 배열에 들어오고 계산되는 과정에서 오류가 발생한 것 같아서 그냥 리스트 그대로 계산해주었다.

추가로 left와 right가 똑같을 때, 조건을 만족한다면 그대로 mid를 return하지만 조건을 만족하지 않으면 mid+1을 return해주는 조건까지 추가해주면 풀린다.

 

def solution(n, times):
    times.sort()
    left, right = 0, times[-1]*n

    while(left <= right):
        mid, sum = (left+right)//2, 0

        for i in times:
            sum += mid//i

        if sum >= n:
            right = mid-1
        else:
            if left==right:
                return mid+1
            left = mid+1

    return mid
테스트 1 〉	통과 (0.02ms, 10.2MB)
테스트 2 〉	통과 (1.16ms, 10.2MB)
테스트 3 〉	통과 (4.41ms, 10.3MB)
테스트 4 〉	통과 (413.86ms, 14.4MB)
테스트 5 〉	통과 (716.05ms, 14.4MB)
테스트 6 〉	통과 (676.49ms, 14.4MB)
테스트 7 〉	통과 (1081.79ms, 14.4MB)
테스트 8 〉	통과 (1625.40ms, 14.4MB)
테스트 9 〉	통과 (0.06ms, 10.1MB)

문제 설명

n개의 노드가 있는 그래프가 있습니다. 각 노드는 1부터 n까지 번호가 적혀있습니다. 1번 노드에서 가장 멀리 떨어진 노드의 갯수를 구하려고 합니다. 가장 멀리 떨어진 노드란 최단경로로 이동했을 때 간선의 개수가 가장 많은 노드들을 의미합니다.

노드의 개수 n, 간선에 대한 정보가 담긴 2차원 배열 vertex가 매개변수로 주어질 때, 1번 노드로부터 가장 멀리 떨어진 노드가 몇 개인지를 return 하도록 solution 함수를 작성해주세요.

 

제한사항

  • 노드의 개수 n은 2 이상 20,000 이하입니다.
  • 간선은 양방향이며 총 1개 이상 50,000개 이하의 간선이 있습니다.
  • vertex 배열 각 행 [a, b]는 a번 노드와 b번 노드 사이에 간선이 있다는 의미입니다.

입출력 예

n vertex return
6 [[3, 6], [4, 3], [3, 2], [1, 3], [1, 2], [2, 4], [5, 2]] 3

 

입출력 예 설명

예제의 그래프를 표현하면 아래 그림과 같고, 1번 노드에서 가장 멀리 떨어진 노드는 4,5,6번 노드입니다.

 

풀이

 

다익스트라 알고리즘을 사용해서 풀면 된다.

 

1. 최단거리 테이블을 생성한 뒤 시작점을 0, 다른 노드는 inf(무한)로 설정한다.

2. 방문하지 않은 노드 중에 가장 거리가 짧은 노드를 선택한다.

3. 방문한 노드를 거쳐 다른 노드로 가는 모든 비용을 계산해 테이블을 갱신한다.

4. 2-3과정을 반복한다.

5. 가장 멀리 떨어져 있는 노드의 개수를 return한다.

 

이 때, 2번 과정을 수행하기 위해 우선순위 큐를 사용한다. 이번 문제같은 경우는 간선에 따로 가중치가 존재하지 않지만 각자 다른 가중치가 적용될 때 우선순위 큐를 사용하면 쉽게 거리가 가장 짧은 노드를 선택할 수 있다.

 

import heapq

def solution(n, edge):
    #최단거리 테이블(1번부터 사용)
    distance = [float("inf")]*(n+1)
    distance[0] = 0
    #인접행렬 생성
    graph = [[] for i in range(n+1)]
    for i in edge:
        graph[i[0]].append(i[1])
        graph[i[1]].append(i[0])

    dijkstra(distance, graph)

    return distance.count(max(distance))


def dijkstra(distance, graph):
    q = []
    #시작 노드 -> 1번 / 큐: (거리, 노드)
    heapq.heappush(q, (0, 1))
    distance[1] = 0

    while q:
        #최단거리 가장 짧은 노드
        dist, now = heapq.heappop(q)
        #방문 여부 확인
        if distance[now] < dist:
            continue
        #인접 노드 방문
        for i in graph[now]:
            cost = dist + 1
            #해당 경로가 더 빠른 경우
            if cost < distance[i]:
                distance[i] = cost
                heapq.heappush(q, (cost, i))

 

테스트 1 〉	통과 (0.03ms, 10.2MB)
테스트 2 〉	통과 (0.02ms, 10.3MB)
테스트 3 〉	통과 (0.07ms, 10.3MB)
테스트 4 〉	통과 (0.46ms, 10.3MB)
테스트 5 〉	통과 (1.58ms, 10.5MB)
테스트 6 〉	통과 (2.68ms, 10.9MB)
테스트 7 〉	통과 (51.25ms, 17.2MB)
테스트 8 〉	통과 (48.65ms, 20.6MB)
테스트 9 〉	통과 (51.84ms, 20.7MB)

문제 설명

 

아래와 같이 5와 사칙연산만으로 12를 표현할 수 있습니다.

12 = 5 + 5 + (5 / 5) + (5 / 5)
12 = 55 / 5 + 5 / 5
12 = (55 + 5) / 5

5를 사용한 횟수는 각각 6,5,4 입니다. 그리고 이중 가장 작은 경우는 4입니다.
이처럼 숫자 N과 number가 주어질 때, N과 사칙연산만 사용해서 표현 할 수 있는 방법 중 N 사용횟수의 최솟값을 return 하도록 solution 함수를 작성하세요.

 

제한사항

  • N은 1 이상 9 이하입니다.
  • number는 1 이상 32,000 이하입니다.
  • 수식에는 괄호와 사칙연산만 가능하며 나누기 연산에서 나머지는 무시합니다.
  • 최솟값이 8보다 크면 -1을 return 합니다.

입출력 예

N number return
5 12 4
2 11 3

 

입출력 예 설명

 

예제 #1

문제에 나온 예와 같습니다.

 

예제 #2
11 = 22 / 2와 같이 2를 3번만 사용하여 표현할 수 있습니다.

 

출처

※ 공지 - 2020년 9월 3일 테스트케이스가 추가되었습니다.

 

풀이

 

import numpy as np

def solution(N, number):
    for i in range(7):
        if np.where(func(N, number, i) == number)[0].size != 0:
          return i+1
    return -1



def calc(a, b, op):
    if op == '+':
        return a + b
    if op == '-':
        return a - b
    if op == '//':
        return a // b
    if op == '*':
        return a * b


def func(N, number, cnt):
    if cnt == 0:
        return np.array([N])

    op = ['+', '-', '//', '*']
    arr = np.array([], dtype = int)
    before = func(N, number, cnt-1)
    
    arr = np.append(arr, np.core.defchararray.add(str(N), before[before>=0].astype(str)))
    arr = np.append(arr, np.core.defchararray.add(before.astype(str), str(N)))

    arr = arr.astype(int)

    for i in op:
      arr = np.append(arr, calc(N, before, i))
      arr = np.append(arr, calc(before, N, i))
    
    arr = np.unique(arr)

    return arr

 

진짜 바보같은 생각을 하고 열심히 코드를 짰다. 숫자 5개를 조합하는 방법으로 1개+4개 / 4개+1개 이런 경우만 생각했는데 당연히 2개+3개 / 3개+2개 / 1개+2개+2개 등 이런 경우도 있는걸 놓치고 있었다. 문제 5, 6, 7, 8번을 다 틀려서 생각하다가 잘못된걸 찾았다.

그리고 NN 형태로 생긴 숫자는 말 그대로 원래 숫자끼리만 붙일 수 있고 (연산)숫자 / 숫자(연산)이런 형태로는 붙일 수 없는데 이것까지 생각해서 코드 짜느라 시간도 조금 더 걸렸다ㅠ

 

1. N을 이어붙여서만 만들 수 있는 숫자를 빈 배열에 추가한다.

2. 각 단계의 숫자를 조합해서 각 단계별로 사칙연산을 수행한다(5단계 -> 1/4, 2/3, 3/2, 4/1)

3. 한 단계가 끝날때마다 입력받은 number가 배열 안에 있는지 확인한다.

 

이런식으로 접근하면 아주 간단하게 풀 수 있었다. 마지막에 숫자를 1개부터 8개까지 써야되는데 7개까지만 써서 잠깐 도 막혔었다..ㅎ 중간에 리스트에 중복 제거를 해주면 속도도 크게 빨라진다.

def solution(N, number):
    
    arr = [[] for i in range(10)]
    nn = ''
    for i in range(8):
        nn += str(N)
        arr[i].append(int(nn))
        for j in range(i):
            for k in arr[j]:
                for l in arr[i-j-1]:
                    arr[i].append(k + l)
                    arr[i].append(k - l)
                    arr[i].append(k * l)
                    if l != 0:
                        arr[i].append(k // l)
        arr[i] = list(set(arr[i]))
        if number in arr[i]:
            return i+1
    
    return -1

 

테스트 1 〉	통과 (0.99ms, 10.6MB)
테스트 2 〉	통과 (0.03ms, 10.4MB)
테스트 3 〉	통과 (0.05ms, 10.4MB)
테스트 4 〉	통과 (18.64ms, 14.4MB)
테스트 5 〉	통과 (14.78ms, 13.2MB)
테스트 6 〉	통과 (0.21ms, 10.4MB)
테스트 7 〉	통과 (0.20ms, 10.4MB)
테스트 8 〉	통과 (17.92ms, 14.5MB)
테스트 9 〉	통과 (0.03ms, 10.4MB)

 

 

문제 설명

ANIMAL_INS 테이블은 동물 보호소에 들어온 동물의 정보를 담은 테이블입니다. ANIMAL_INS 테이블 구조는 다음과 같으며, ANIMAL_ID, ANIMAL_TYPE, DATETIME, INTAKE_CONDITION, NAME, SEX_UPON_INTAKE는 각각 동물의 아이디, 생물 종, 보호 시작일, 보호 시작 시 상태, 이름, 성별 및 중성화 여부를 나타냅니다.

NAME TYPE NULLABLE
ANIMAL_ID VARCHAR(N) FALSE
ANIMAL_TYPE VARCHAR(N) FALSE
DATETIME DATETIME FALSE
INTAKE_CONDITION VARCHAR(N) FALSE
NAME VARCHAR(N) TRUE
SEX_UPON_INTAKE VARCHAR(N) FALSE

ANIMAL_OUTS 테이블은 동물 보호소에서 입양 보낸 동물의 정보를 담은 테이블입니다. ANIMAL_OUTS 테이블 구조는 다음과 같으며, ANIMAL_ID, ANIMAL_TYPE, DATETIME, NAME, SEX_UPON_OUTCOME는 각각 동물의 아이디, 생물 종, 입양일, 이름, 성별 및 중성화 여부를 나타냅니다. ANIMAL_OUTS 테이블의 ANIMAL_ID는 ANIMAL_INS의 ANIMAL_ID의 외래 키입니다.

NAME TYPE NULLABLE
ANIMAL_ID VARCHAR(N) FALSE
ANIMAL_TYPE VARCHAR(N) FALSE
DATETIME DATETIME FALSE
NAME VARCHAR(N) TRUE
SEX_UPON_OUTCOME VARCHAR(N) FALSE

관리자의 실수로 일부 동물의 입양일이 잘못 입력되었습니다. 보호 시작일보다 입양일이 더 빠른 동물의 아이디와 이름을 조회하는 SQL문을 작성해주세요. 이때 결과는 보호 시작일이 빠른 순으로 조회해야합니다.

 

예시

예를 들어, ANIMAL_INS 테이블과 ANIMAL_OUTS 테이블이 다음과 같다면

ANIMAL_INS

ANIMAL_ID ANIMAL_TYPE DATETIME INTAKE_CONDITION NAME SEX_UPON_INTAKE
A350276 Cat 2017-08-13 13:50:00 Normal Jewel Spayed Female
A381217 Dog 2017-07-08 09:41:00 Sick Cherokee Neutered Male

ANIMAL_OUTS

ANIMAL_ID ANIMAL_TYPE DATETIME NAME SEX_UPON_OUTCOME
A350276 Cat 2018-01-28 17:51:00 Jewel Spayed Female
A381217 Dog 2017-06-09 18:51:00 Cherokee Neutered Male

SQL문을 실행하면 다음과 같이 나와야 합니다.

ANIMAL_ID NAME
A381217 Cherokee

본 문제는 Kaggle의 "Austin Animal Center Shelter Intakes and Outcomes"에서 제공하는 데이터를 사용하였으며 ODbL의 적용을 받습니다.

 

풀이

 

SELECT INS.ANIMAL_ID, INS.NAME 
FROM ANIMAL_INS INS 
JOIN ANIMAL_OUTS OUTS 
ON INS.ANIMAL_ID = OUTS.ANIMAL_ID 
WHERE INS.DATETIME > OUTS.DATETIME 
ORDER BY INS.DATETIME

 

ANIMAL_INS 테이블과 ANIMAL_OUTS 테이블을 JOIN으로 합친 뒤 ANIMAL_INS의 DATETIME이 빠른 레이블을 찾아 정렬해주면 된다.

문제 설명

리틀 프렌즈 사천성

언제나 맛있는 음식들이 가득한 평화로운 푸드 타운. 푸드 타운에서 행복하게 사는 리틀 프렌즈들은 마을에 있는 매직 스푼을 보물처럼 보관하고 있다. 매직 스푼은 재료만 준비해서 냄비에 넣고 휘젓기만 하면 순식간에 최고의 요리로 만들어주는 신비의 아이템. 어느 날 매직 스푼을 호시탐탐 노리는 악당들이 보물을 훔쳐간다. 매직 스푼을 되찾고 다시 마을에 평화를 가져오기 위해 프렌즈의 대모험이 시작되는데...

리틀 프렌즈 사천성은 프렌즈 사천성과 유사한 게임이다. 게임은 2차원 배열에서 진행되는데, 여러 가지 무늬로 구성된 타일이 배치되어 있으며 같은 모양의 타일은 두 개씩 배치되어 있다. 게임의 목적은 배치된 모든 타일을 제거하는 것으로, 같은 모양의 타일을 규칙에 따라 제거하면 된다. 타일을 제거할 수 있는 경우는 다음과 같다.

다음 조건을 만족하는 경로가 있을 때 두 타일을 제거할 수 있다.

  • 경로의 양 끝은 제거하려는 두 타일이다.
  • 경로는 두 개 이하의 수평/수직 선분으로 구성되어 있고, 이들은 모두 연결되어 있다. (즉, 경로를 한 번 이하로 꺾을 수 있다)
    • 참고: 프렌즈 사천성은 경로가 세 개 이하의 선분으로 구성되어야 한다는 점이 다르다. (즉, 경로를 두 번 이하로 꺾을 수 있다)
  • 경로 상에는 다른 타일 또는 장애물이 없어야 한다.

위의 배열에서 어피치 타일은 직선의 경로로 이을 수 있으므로 제거 가능하다. 라이언 타일 역시 한 번 꺾인 경로로 연결되므로 제거 가능하다. 무지 타일의 경우 다른 타일을 지나지 않는 경로는 두 번 꺾여야 하므로 제거할 수 없는 타일이며, 튜브 타일 역시 직선의 경로 사이에 장애물이 있으므로 제거 가능하지 않다.

타일 배열이 주어졌을 때, 규칙에 따라 타일을 모두 제거할 수 있는지, 그 경우 어떤 순서로 타일을 제거하면 되는지 구하는 프로그램을 작성해보자.

입력 형식

입력은 게임판의 크기를 나타내는 m과 n, 그리고 배치된 타일의 정보를 담은 문자열 배열 board로 주어진다. 이 배열의 크기는 m이며, 각각의 원소는 n글자의 문자열로 구성되어 있다. 입력되는 값의 제한조건은 다음과 같다.

  • 1 <= m, n <= 100
  • board의 원소는 아래 나열된 문자로 구성된 문자열이다. 각 문자의 의미는 다음과 같다.
    • .: 빈칸을 나타낸다.
    • *: 막힌 칸을 나타낸다.
    • 알파벳 대문자(A-Z): 타일을 나타낸다. 이 문제에서, 같은 글자로 이루어진 타일은 한 테스트 케이스에 항상 두 개씩만 존재한다.
    • board에는 알파벳 대문자가 항상 존재한다. 즉, 타일이 없는 입력은 주어지지 않는다.

출력 형식

해가 존재하는 경우 타일을 제거하는 순서대로 한 글자씩 이루어진 문자열을, 그렇지 않은 경우 IMPOSSIBLE을 리턴한다. 해가 여러 가지인 경우, 알파벳 순으로 가장 먼저인 문자열을 리턴한다.

예제 입출력

m n board answer
3 3 ["DBA", "C*A", "CDB"] "ABCD"
2 4 ["NRYN", "ARYA"] "RYAN"
4 4 [".ZI.", "M.**", "MZU.", ".IU."] "MUZI"
2 2 ["AB", "BA"] "IMPOSSIBLE"

예제에 대한 설명

첫 번째 테스트 케이스에서 처음으로 제거 가능한 타일은 A와 C이다. 그리고 모든 가능한 경우를 나열하면 ABCD, ACBD, ACDB, CABD, CADB, CDAB이다. 이 중 알파벳 순으로 가장 먼저인 ABCD가 정답이다.

네 번째 테스트 케이스는 초기 상태에서 제거할 수 있는 타일이 없으므로 타일을 모두 제거하는 것이 불가능하다. 따라서 정답은 IMPOSSIBLE이다.

풀이

 

문자, x좌표, y좌표를 변수로 가지는 position 구조체를 만든 후, 문자열로 입력된 board를 set을 이용하여 알파벳을 오름차순으로 정리한다. set은 균형이진트리로 nsert 함수를 이용해 삽입된 원소들은 자동으로 정렬되기 때문에 삭제할 타일의 순서대로 바로 정렬할 수 있다. 이 때 set 내에서 사용하는 operator<이 새로 만든 position 구조체에 대해 연산을 수행할 수 없으므로 새로 정의해주어야 한다.

 

struct position { char c; int x, y; };

bool operator<(const position& a, const position& b) {
	return a.c < b.c;
}

string solution(int m, int n, vector<string> board) {
	string answer = "";
	int i, j, chk;
	set<position> tileList;
	

	//제거할 알파벳 타일 오름차순으로 list에 정렬
	for (i = 0; i < m; i++) {
		for (j = 0; j < n; j++) {
			if (board[i][j] >= 'A' && board[i][j] <= 'Z')
				tileList.insert(position{board[i][j], j, i});
		}
	}

 

BFS를 이용하여 가능한 타일을 탐색한다. 기존 BFS 코드에 두번 이상 꺾을 수 없는 제한을 걸어주면 된다. 큐에 x, y좌표 외에 direction(상/하/좌/우)값을 넣어서 확인한다.

 

#include <string>
#include <vector>
#include <set>
#include <queue>
#include <iostream>
#include <cstring>

using namespace std;

struct position { char c; int y, x; };
struct q { int y, x, direction; };

bool operator<(const position& a, const position& b) {
	return a.c < b.c;
}

string search(set<position> list, int m, int n, vector<string> board) {
	queue<q> queue;
	string answer = "";
	int visit[100][100][4], dy[] = { 0,1,0,-1 }, dx[] = { 1,0,-1,0 }, tx, ty, after, before;
	bool chk, bend, possible;

	do {
		before = (int)list.size();
		for (auto it = list.begin(); it != list.end(); it++) {
			while (!queue.empty()) queue.pop();	//큐 초기화
			memset(visit, 0x7f, sizeof(visit));	//큰 값으로 visit 배열 초기화

			//첫 번째 노드 (모든 방향을 큐에 삽입, 0:우/1:하/2:좌/3:상)
			for (int i = 0; i < 4; i++) {
				visit[it->y][it->x][i] = 0;	//방향 회전 횟수: 0
				queue.push(q{ it->y, it->x, i });
			}

			chk = 0;	//같은 타일을 만났는지 확인하는 변수

			//큐에 값이 남아있고(방문하지 않은 노드 존재) 같은 타일을 만나지 않았을 때까지 반복
			while (!queue.empty() && !chk) {
				q now = queue.front();
				queue.pop();
				for (int i = 0; i < 4; i++) {
					tx = now.x + dx[i];
					ty = now.y + dy[i];
					bend = (i != now.direction);	//1: 방향이 꺾임/0: 꺾이지 않음

					//보드에서 벗어났는지 확인
					if (0 <= ty && ty < m && 0 <= tx && tx < n) {
						possible = board[ty][tx] != '*' && (board[ty][tx] == '.' || board[ty][tx] == it->c);	//막히지 않고, 빈칸이거나 같은 타일일 경우

						//보드 안에서 접근이 가능하고 두번 이상 꺾이지 않았고 방문하지 않은 노드(방문했을 시 visit direction이 작은 수로 바뀜)
						if (possible && (visit[now.y][now.x][now.direction] + bend < 2) && visit[ty][tx][i] > visit[now.y][now.x][now.direction] + bend) {
							visit[ty][tx][i] = visit[now.y][now.x][now.direction] + bend;	//방향 꺾은 횟수
							queue.push(q{ ty, tx, i });	//방문하지 않았다면 큐에 추가
							//같은 모양의 타일에 접근이 가능할 경우 각 타일을 빈칸으로 바꿈
							if (board[ty][tx] == it->c) {
								chk = 1;
								board[it->y][it->x] = '.';
								board[ty][tx] = '.';
							}
						}
					}
				}
			}
			//같은 타일을 찾은 경우 리스트에서 제거하고 다음 알파벳으로 이동
			if (chk) {
				answer += it->c;
				list.erase(it);
				break;
			}
		}

		after = list.size();

	} while (before != after);	//리스트가 줄어들지 않는 경우(불가능한 경우 + 전부 제거한 경우)

		//리스트가 비어있지 않다면 불가능한 경우
		if (!list.empty()) answer = "IMPOSSIBLE";
		return answer;
}

string solution(int m, int n, vector<string> board) {
	int i, j;
	set<position> tileList;


	//제거할 알파벳 타일 오름차순으로 list에 정렬
	for (i = 0; i < m; i++) {
		for (j = 0; j < n; j++) {
			if (board[i][j] >= 'A' && board[i][j] <= 'Z')
				tileList.insert(position{ board[i][j], i, j });
		}
	}

	return search(tileList, m, n, board);
}

 

모든 경우를 생각해서 코드를 짜다가 너무 길고 더러워져서 BFS 를 이용한 다른분의 코드를 참고해서 공부했다ㅠㅠ 공부 더 열심히 해야지..ㅠㅠ

 

테스트 1 〉	통과 (305.16ms, 4.33MB)

 

코드 출처

https://coloredrabbit.tistory.com/58

+ Recent posts