10-fnzksxl

[fnzksxl]

🔗 문제 링크

나무 재테크

✔️ 소요된 시간

2시간 30분

✨ 수도 코드

시간 초과 해결하는 데에 시간을 다 날려먹었습니다. 당했다고 볼 수 있죠.

이 문제는 봄, 여름, 가을, 겨울에 각각의 태스크를 k번 돌린 후의 결과를 예측해야 합니다.
단순 구현하는데에는 큰 문제가 없지만 신경 써서 코드를 구현하지 않으면 시간 초과의 늪에 빠지게 됩니다..

처음으로 구현했던 방법은 NxN 테이블의 각 칸에 deque 자료구조를 할당해서 나무를 빼오고,
봄과 여름, 가을과 겨울로 두 번의 이중반복문이 돌아가게 했습니다. 이렇게 하니까 계속 시간초과가 나오더라구요.

그래서 두 개를 한 번에 바꿨습니다.

• 자료구조를 딕셔너리로 바꾸기
• 이중반복문을 하나로 줄이기

주요 아이디어는 trees[i][j]에 있는 딕셔너리[k]에 나무의 개수를 저장하는 겁니다.
이렇게 하면 bat[i][j] 칸에서 나이가 K인 나무들을 성장시키는 데 필요한 비료의 양이
k * trees[i][j][k]가 되겠죠

정렬한 딕셔너리를 순회하면서 나무의 성장에 필요한 비료와 현재 땅의 비료를 비교해갑니다.

1. 성장이 가능할 때
   -> 비료 차감
   -> 나무 나이 + 1
   -> 나무 나이 + 1 이 5의 배수라면 주변 8개에 나이 1 나무 심기

2. 성장이 안될 때
   2-1. 모든 나무가 성장이 안될 때
   -> 나무 나이 // 2 * 나무를 땅의 비료에 추가
   2-2. 일부 나무만 성장이 안될 때
   -> 일부 나무만큼 비료 차감
   -> 일부 나무 + 1
   -> 일부 나무 나이 + 1이 5의 배수라면 주변 8개에 나이 1 나무 심기
   -> 나무 나이 // 2 * 죽은 나무를 땅의 비료에 추가

주변 땅에 나무를 추가해줄 때, deque로 구현했을 때는 큐에 하나씩 넣어줘야해서
나무 개수만큼 계속 추가를 해줬어야 했는데, 딕셔너리에 나무의 개수를 넣는 방식으로 구현하면
한 번에 추가가 가능합니다!

P.S 확실히 defaultdict가 느립니다! 같은 로직에 defaultdict로 제출하면 시간 초과가 떠요 ㅠㅠ

구현 문제라 코드가 좀 깁니다.
(그래서 주석 달아둘까 했는데 중간에 관뒀습니다)

import sys

dx = [-1, -1, 0, 1, 1, 1, 0, -1]
dy = [0, 1, 1, 1, 0, -1, -1, -1]

input = sys.stdin.readline


def whole_year():
    def push_trees(tree):
        if not (age + 1) % 5:
            for d in range(8):
                nx = i + dx[d]
                ny = j + dy[d]
                if nx >= 0 and nx < N and ny >= 0 and ny < N:
                    new_tree.append((nx, ny, tree))

    new_tree = []
    for i in range(N):
        for j in range(N):
            if trees[i][j]:  # 빈 딕셔너리면 그냥 통과
                dead_trees = 0
                alive = {}
                OKAY = True  # 토양이 나무들을 성장시킬 수 있는지 없는지 확인하기 위한 플래그
                for age in sorted(trees[i][j]):  # 어린 나무부터 확인하기 위해 딕셔너리 정렬
                    if OKAY:
                        if age * trees[i][j][age] > bat[i][j]:
                            survive = bat[i][j] // age
                            if survive:
                                bat[i][j] -= survive * age
                                alive[age+1] = survive
                                push_trees(survive)
                            dead_trees += (trees[i][j][age] - survive) * (age // 2)
                            OKAY = False
                        else:
                            bat[i][j] -= age * trees[i][j][age]
                            alive[age+1] = trees[i][j][age]
                            push_trees(trees[i][j][age])
                    else:
                        dead_trees += trees[i][j][age] * (age // 2)

                bat[i][j] += dead_trees
                trees[i][j] = alive

            bat[i][j] += yang[i][j]

    for x, y, tree in new_tree:
        if 1 in trees[x][y].keys():
            trees[x][y][1] += tree
        else:
            trees[x][y][1] = tree


N, M, K = map(int, input().split())

answer = 0
yang = [list(map(int, input().split())) for _ in range(N)]
bat = [[5]*N for _ in range(N)]
trees = [[{} for _ in range(N)] for _ in range(N)]

for _ in range(M):
    x, y, z = map(int, input().split())
    trees[x-1][y-1][z] = 1


for _ in range(K):
    whole_year()

for i in range(N):
    for j in range(N):
        answer += sum(trees[i][j].values())

print(answer)

📚 새롭게 알게된 내용

시간 초과가 난다면 자료형을 빠르게 바꿔보자..

[SeongHoonC]

1. 시간초과는 deque 사용으로 해결
2. 죽은 나무를 한번에 더해고 /2 해서 오차가 달라진 문제 해결

후..골3 구현 복잡하네요

val dX = listOf(0, 0, 1, -1, 1, -1, -1, 1)
val dY = listOf(1, -1, 0, 0, 1, -1, 1, -1)
fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val (n, m, k) = br.readLine().split(" ").map { it.toInt() }
    val trees = Array(n + 1) { Array(n + 1) { ArrayDeque<Int>() } }
    val nutrients = Array(n + 1) { Array(n + 1) { 5 } }
    val s2d2 = Array(n + 1) { Array(n + 1) { 0 } }

    for (i in 1..n) {
        val line = br.readLine().split(" ").map { it.toInt() }
        for (j in 1..n) {
            s2d2[i][j] = line[j - 1]
        }
    }

    for (i in 1..m) {
        val (r, c, age) = br.readLine().split(" ").map { it.toInt() }
        trees[r][c].add(age)
        trees[r][c].sort()
    }

    for (i in 0 until k) {
        // 봄 여름 겨울은 한번에 가능
        springSummerWinter(trees, nutrients, s2d2, n)
        fall(trees, n)
    }
    println(trees.sumOf { x -> x.sumOf { y -> y.count() } })
}

private fun springSummerWinter(
    trees: Array<Array<ArrayDeque<Int>>>,
    nutrients: Array<Array<Int>>,
    s2d2: Array<Array<Int>>,
    n: Int,
) {
    for (i in 1..n) {
        for (j in 1..n) {
            for (k in trees[i][j].indices) {
                // 비료가 있으면 나무 성장! - 봄
                if (trees[i][j][k] <= nutrients[i][j]) {
                    nutrients[i][j] -= trees[i][j][k]
                    trees[i][j][k] += 1
                    continue
                }
                var sum = 0
                // 비료 죽어서 추가 - 여름
                for (l in k until trees[i][j].size) {
                    sum += trees[i][j][l] / 2
                }
                // 죽은 나무 치우기 - 여름
                nutrients[i][j] += sum
                val next = ArrayDeque<Int>()
                next.addAll(trees[i][j].subList(0, k))
                trees[i][j] = next
                break
            }
            // 겨울에 비료 추가
            nutrients[i][j] += s2d2[i][j]
        }
    }
}

private fun fall(trees: Array<Array<ArrayDeque<Int>>>, n: Int) {
    for (i in 1..n) {
        for (j in 1..n) {
            // 8방에 나무 1 추가
            val extraTree = trees[i][j].count { it % 5 == 0 && it != 0 }
            for (k in 0..7) {
                val nextX = i + dX[k]
                val nextY = j + dY[k]
                if (nextX > n || nextY > n || nextY < 1 || nextX < 1) {
                    continue
                }
                repeat(extraTree) {
                    trees[nextX][nextY].addFirst(1)
                }
            }
        }
    }
}

[wkdghdwns199]

3일 걸리다 결국 보고 푼 문제.. 3차원으로 처리할 생각은 꿈에도 못했네요..!

import sys
from collections import deque
input = sys.stdin.readline

dx = [-1,-1,-1,0,0,1,1,1]
dy = [-1,0,1,-1,1,-1,0,1]

N,M,K = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(N)]
trees = [[deque() for _ in range(N)] for _ in range(N)]

for _ in range(M) :
    x,y,z = map(int, input().split())
    trees[x-1][y-1].append(z)

ground = [[5] * N for _ in range(N)]
for _ in range(K) :
    
    for i in range(N) :
        for j in range(N):
            trees_length = len(trees[i][j])
            for k in range(trees_length) :
                if ground[i][j] >= trees[i][j][k] :
                    ground[i][j] -= trees[i][j][k]
                    trees[i][j][k] += 1
                else :
                    for _ in range(k,trees_length):
                        ground[i][j] += trees[i][j].pop() // 2
                    break

    for i in range(N):
        for j in range(N) :
            for z in trees[i][j] :
                if z % 5 == 0:
                    for idx in range(8):
                        move_x = i + dx[idx]
                        move_y = j + dy[idx]
                        if 0 <= move_x < N and 0 <= move_y < N :
                            trees[move_x][move_y].appendleft(1)
            ground[i][j] += A[i][j]

answer = 0
for i in range(N) :
    for j in range(N):
        answer += len(trees[i][j])
print(answer)

[fnzksxl]

@wkdghdwns199 deque로.. 시간 초과가 안걸리던가요?!

[fnzksxl]

@SeongHoonC 이런 구현 문제가 실제 코테에서 나오면 상당히 귀찮을 것 같습니다 ㅜ

[wkdghdwns199]

@fnzksxl 안 터지더라구요..! 신기하게 푸는 사람 많네요 ㅋㅋ