29-alstjr7437

[alstjr7437]

🔗 문제 링크

나무자르기

미리보기 방지

✔️ 소요된 시간

30분

✨ 수도 코드

누가봐도 (1 ≤ N ≤ 1,000,000, 1 ≤ M ≤ 2,000,000,000)
라서 그냥 풀게 되면 시간초과가 날 것 같았지만
그냥도 한번 풀어봤습니다.

그냥 자르는 나무 길이를 0부터 시작해서
잘라서 얻은 길이 총 합이 원하는 나무 길이보다 작아지면 break
하여서 결과 값을 전해주는 방식으로 했습니다.

n, m = map(int, input().split())
tree = list(map(int, input().split()))
result = min(tree)

while True:
    temp = 0
    for i in tree:
        if i > result :
            temp += i - result
    if temp <= m :
        break
    result += 1

print(result)

네 누가봐도 시간 초과죠???

나무의 길이 M이 주어진다. (1 ≤ N ≤ 1,000,000, 1 ≤ M ≤ 2,000,000,000)인데 위의 방식을 사용하게 되면
예로 나무 길이가 0, 100, 2_000_000_000가 있으면 0부터 20억까지 계속해서 돌아야하는 경우도 생길 수 있습니다.(그럴일이 없지만)

그래서 생각한 부분이 나무의 총합 길이는 똑같이 구하지만

자르는 나무 길이의 선정을 이분탐색으로 하면 어떨까 였습니다!!(사실 처음에는 뭘 이분탐색해야할지 잘 감이 안잡혔습니다..)

그래서 알고리즘으로


start = 1
end = max(tree)
로 나무의 최대 값을 end로 잡고
mid를 자르는 나무 값으로 잡았습니다.

그리고 위 틀린 방식과 똑같이 mid - 각 나무의 값으로 temp에다가 자른 나무의 값을 넣어주고

자른 나무의 값을 비교하여

• 자른 나무의 값 >= 원하는 나무의 값 : start를 mid + 1
• 자른 나무의 값 < 원하는 나무의 값 : end를 mid - 1

으로 이분탐색을 진행하여서 end를 출력하면 결과값으로 되었습니다.

n, m = map(int, input().split())
tree = list(map(int, input().split()))

start = 1
end = max(tree)

while start <= end:
    mid = (start + end) // 2
    temp = 0
    for i in tree:
        if i > mid:
            temp += i - mid
    
    if temp >= m :
        start = mid + 1
    else :
        end = mid - 1

print(end)

📚 새롭게 알게된 내용

이분 탐색인 부분은 바로 알았지만 어떻게 이분탐색을 해야할지도 잘 생각해야 했습니다..
프로그래머스 입국심사 이 문제를 풀때도 똑같은 고민으로 이분탐색의 mid를 뭘 잡아야할지 몰라서 한참 해맸는데 부족한 부분이 많다고 아직 느꼈습니다.

[tgyuuAn]

저도 이분 탐색 left, right 조건을 어떻게 설정해야 하지?

mid 값은 어떻게 잡아야 하지? 에 대해 고민이 많았어서,

저기 나와있는 링크로 공부를 했씁니다.

이제 거의 모든 이분 탐색 문제에 아래와 같이 구현하니 다 술술 풀리더라고요.

import sys

def input(): return sys.stdin.readline().rsrtip()

N, M = map(int, input().split())
trees = list(map(int,input().split()))

def check(mid, trees, target):
    accumulate = 0
    for tree in trees:
        accumulate += max(0, tree-mid)
    
    if accumulate >= target: return True
    return False

left = 0
right= 1_000_000_001
answer = 0
while left+1 < right:
    mid = (left + right)//2

    if check(mid, trees, M):
        answer = mid
        right = mid

    else: left = mid

print(answer)

그 결과 원큐로 풀긴했습니다만 이거 python3으로는 안풀리나요?

좀 깎아야하나..

[9kyo-hwang]

그 결과 원큐로 풀긴했습니다만 이거 python3으로는 안풀리나요?

좀 깎아야하나..

python3로도 풀린답니당.

근데 애초에 문제 테케 자체가 많이 빡신듯. C++로도 156ms가 걸리네

[alstjr7437]

그 결과 원큐로 풀긴했습니다만 이거 python3으로는 안풀리나요?

좀 깎아야하나..

저도 python3으로 되더라구요 다시보니 아슬아슬하군요 ㄷㄷ..

[SeongHoonC]

파이썬으로 갈아타야하나..

일단 1년 반 전에 풀었던 문제긴한데 기억은 안났구용
이분 탐색은 바로 캐치했습니다만...
kotlin Int 면 숫자가 커서 오버플로가 나더라구요. (이게 오버플로면 에러가 아니라 그냥 틀렸다고 나오는게 문제...)
그래도 문제의 숫자 범위 보고 오버플로 나겠구나 알아차려서 Long 으로 변경해 풀었습니다.

재귀로 풀었어요.

import java.io.BufferedReader
import java.io.InputStreamReader

private lateinit var br: BufferedReader
private var max: Long = 0

fun main() {
    br = BufferedReader(InputStreamReader(System.`in`))
    val (n, m) = br.readLine().split(" ").map { it.toLong() }

    val trees = br.readLine().split(" ").map { it.toLong() }
    findMax(trees, 0, trees.max(), m)
    println(max)
}

fun findMax(trees: List<Long>, start: Long, end: Long, target: Long) {
    if (start > end) return
    val mid = (start + end) / 2
    val cuts: Long = trees.filter { it > mid }.sumOf { it - mid }
    if (cuts == target) {
        max = mid
        return
    }
    if (cuts > target) {
        max = mid
        return findMax(trees, mid + 1, end, target)
    }
    return findMax(trees, start, mid - 1, target)
}

그리고 민석님이 푸신 방법으로 한 번 더 풀어봤습니다.

import java.io.BufferedReader
import java.io.InputStreamReader

private lateinit var br: BufferedReader

fun main() {
    br = BufferedReader(InputStreamReader(System.`in`))
    val (n, m) = br.readLine().split(" ").map { it.toLong() }

    val trees = br.readLine().split(" ").map { it.toLong() }
    println(findMax(trees, m).toInt())
}

fun findMax(trees: List<Long>, target: Long): Long {
    var start = 0L
    var end: Long = trees.max()

    while (start <= end) {
        val mid = (start + end) / 2
        val cuts: Long = trees.filter { it > mid }.sumOf { it - mid }
        if (cuts >= target) {
            start = mid + 1
            continue
        }
        end = mid - 1
    }
    return end
}

결국 end 는 target 을 만족하는 것들 중에 mid - 1 로 점점 작아지기 때문에 최대값에 가까워진다는 것을 캐치한 풀이 방법이군요! 재밌는 문제였습니다. 감사합니다.