프로그래머스 땅따먹기

문제 설명

땅따먹기 게임을 하려고 합니다. 땅따먹기 게임의 땅(land)은 총 N행 4열로 이루어져 있고, 모든 칸에는 점수가 쓰여 있습니다. 1행부터 땅을 밟으며 한 행씩 내려올 때, 각 행의 4칸 중 한 칸만 밟으면서 내려와야 합니다. 단, 땅따먹기 게임에는 한 행씩 내려올 때, 같은 열을 연속해서 밟을 수 없는 특수 규칙이 있습니다.

예를 들면,
| 1 | 2 | 3 | 5 |
| 5 | 6 | 7 | 8 |
| 4 | 3 | 2 | 1 |
로 땅이 주어졌다면, 1행에서 네번째 칸 (5)를 밟았으면, 2행의 네번째 칸 (8)은 밟을 수 없습니다.

마지막 행까지 모두 내려왔을 때, 얻을 수 있는 점수의 최대값을 return하는 solution 함수를 완성해 주세요. 위 예의 경우, 1행의 네번째 칸 (5), 2행의 세번째 칸 (7), 3행의 첫번째 칸 (4) 땅을 밟아 16점이 최고점이 되므로 16을 return 하면 됩니다.

제한사항

• 행의 개수 N : 100,000 이하의 자연수
• 열의 개수는 4개이고, 땅(land)은 2차원 배열로 주어집니다.
• 점수 : 100 이하의 자연수

입출력 예

land	answer
[[1,2,3,5],[5,6,7,8],[4,3,2,1]]	16

입출력 예 설명

입출력 예 #1

문제의 예시와 같습니다.

풀이

• 동적계획법, 딕셔너리 안에 배열 넣기, 2중 for 문 같은 게 떠오른다.
• 그래 이거 전에 고득점 킷에서 해봤었던 거야!
• 대충 슥슥 짜서 보니까 아니네? "단, 같은 열을 연속해서 밞을 수 없는 특수 규칙이 있습니다" ㅋㅋㅋ
• 야! 이런건 미리 말하라고! ... 미리 말했구나...;;;

def solution(land):
    dp = {}
    dp[0] = list(set(land[0]))
    l_l = len(land)
    print(dp[0])
    for n in range(1, l_l):
        _tmp = []
        for _n2 in land[n]:
            for _n1 in dp[n-1]:
                _tmp.append(_n1 + _n2)
        dp[n] = list(set(_tmp))
        print(dp[n])
    return 1
    
테스트 1
입력값 〉	[[1, 2, 3, 5], [5, 6, 7, 8], [4, 3, 2, 1]]
기댓값 〉	16
실행 결과 〉	실행한 결괏값 1이 기댓값 16과 다릅니다.
출력 〉	[1, 2, 3, 5]
[6, 7, 8, 9, 10, 11, 12, 13]
[7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]

• 그럼 dp[n]을 n이 단계가 아니라 "제외된 열"로 설정하면 된다.
• 그러면 [0, 1, 2, 3] 4개의 딕셔너리에 값이 꾸역 꾸역 쌓이겠지...

dp[0]	dp[1]	dp[2]	dp[3]
1	2	3	5
7,8,9	7,9,10	8,9,10	10,11,12
(7,8,9)+(3,2,1)	(7,9,10)+(4,2,1)	(8,9,10)+(4,3,1)	(10,11,12)+(4,3,2)

• 이러면 너무 많이 쌓여서 시간 초과 아니냐?
• 문제가 이런거 아닐텐데...
• 아! 최대값이다. 최대값만 저장하면 된다!!!

dp[0]	dp[1]	dp[2]	dp[3]
1	2	3	5
9	10	10	12
9+3	10+4	10+4	12+4

• 이거다!
• 그리고 딕셔너리를 쓸 필요도 없고, 배열도 필요없다. ㅡ.ㅡ;

def solution(land):
    for i in range(1, len(land)):
        land[i][0] += max(land[i-1][1],land[i-1][2],land[i-1][3])
        land[i][1] += max(land[i-1][0],land[i-1][2],land[i-1][3])
        land[i][2] += max(land[i-1][0],land[i-1][1],land[i-1][3])
        land[i][3] += max(land[i-1][0],land[i-1][1],land[i-1][2])
    return max(land[len(land)-1])

정확성  테스트
테스트 1 〉	통과 (1.53ms, 10.4MB)
테스트 2 〉	통과 (1.55ms, 10.6MB)
테스트 3 〉	통과 (1.49ms, 10.4MB)
테스트 4 〉	통과 (1.50ms, 10.4MB)
테스트 5 〉	통과 (2.96ms, 10.3MB)
테스트 6 〉	통과 (1.49ms, 10.4MB)
테스트 7 〉	통과 (1.52ms, 10.3MB)
테스트 8 〉	통과 (2.93ms, 10.6MB)
테스트 9 〉	통과 (1.53ms, 10.3MB)
테스트 10 〉	통과 (2.96ms, 10.4MB)
테스트 11 〉	통과 (1.50ms, 10.5MB)
테스트 12 〉	통과 (2.62ms, 10.4MB)
테스트 13 〉	통과 (1.51ms, 10.4MB)
테스트 14 〉	통과 (2.41ms, 10.6MB)
테스트 15 〉	통과 (1.52ms, 10.4MB)
테스트 16 〉	통과 (1.51ms, 10.4MB)
테스트 17 〉	통과 (1.53ms, 10.2MB)
테스트 18 〉	통과 (1.53ms, 10.3MB)
효율성  테스트
테스트 1 〉	통과 (147.57ms, 32.5MB)
테스트 2 〉	통과 (163.01ms, 32.4MB)
테스트 3 〉	통과 (163.00ms, 32.3MB)
테스트 4 〉	통과 (159.60ms, 32.5MB)

• 고수의 풀이.
• 위 코드를 더 짧게 쓸 수가 있긴 하구나. 근데 속도가 느리다.

def solution(land):
    for i in range(1, len(land)):
        for j in range(len(land[0])):
            land[i][j] = max(land[i -1][: j] + land[i - 1][j + 1:]) + land[i][j]
    return max(land[-1])

정확성  테스트
테스트 1 〉	통과 (2.07ms, 10.3MB)
테스트 2 〉	통과 (2.40ms, 10.4MB)
테스트 3 〉	통과 (3.89ms, 10.4MB)
테스트 4 〉	통과 (2.08ms, 10.3MB)
테스트 5 〉	통과 (2.09ms, 10.4MB)
테스트 6 〉	통과 (2.04ms, 10.5MB)
테스트 7 〉	통과 (2.07ms, 10.4MB)
테스트 8 〉	통과 (2.06ms, 10.5MB)
테스트 9 〉	통과 (2.17ms, 10.4MB)
테스트 10 〉	통과 (2.06ms, 10.5MB)
테스트 11 〉	통과 (2.18ms, 10.3MB)
테스트 12 〉	통과 (2.19ms, 10.4MB)
테스트 13 〉	통과 (2.33ms, 10.3MB)
테스트 14 〉	통과 (2.25ms, 10.4MB)
테스트 15 〉	통과 (2.11ms, 10.3MB)
테스트 16 〉	통과 (3.77ms, 10.4MB)
테스트 17 〉	통과 (3.98ms, 10.3MB)
테스트 18 〉	통과 (4.03ms, 10.4MB)
효율성  테스트
테스트 1 〉	통과 (218.05ms, 32.3MB)
테스트 2 〉	통과 (218.14ms, 32.3MB)
테스트 3 〉	통과 (215.91ms, 32.4MB)
테스트 4 〉	통과 (215.56ms, 32.4MB)

• 리스트[:] 연산으로 2개로 잘랐다가 다시 합치는 코스트가 있는 것 같다.

정확성  테스트
테스트 1 〉	통과 (3.97ms, 10.4MB)
테스트 2 〉	통과 (2.03ms, 10.2MB)
테스트 3 〉	통과 (2.11ms, 10.3MB)
테스트 4 〉	통과 (2.00ms, 10.6MB)
테스트 5 〉	통과 (3.99ms, 10.4MB)
테스트 6 〉	통과 (3.97ms, 10.3MB)
테스트 7 〉	통과 (2.81ms, 10.3MB)
테스트 8 〉	통과 (2.67ms, 10.5MB)
테스트 9 〉	통과 (3.52ms, 10.4MB)
테스트 10 〉	통과 (3.35ms, 10.4MB)
테스트 11 〉	통과 (3.20ms, 10.4MB)
테스트 12 〉	통과 (2.23ms, 10.3MB)
테스트 13 〉	통과 (3.50ms, 10.3MB)
테스트 14 〉	통과 (2.15ms, 10.2MB)
테스트 15 〉	통과 (2.06ms, 10.4MB)
테스트 16 〉	통과 (2.18ms, 10.2MB)
테스트 17 〉	통과 (3.66ms, 10.2MB)
테스트 18 〉	통과 (3.70ms, 10.2MB)
효율성  테스트
테스트 1 〉	통과 (195.48ms, 32.4MB)
테스트 2 〉	통과 (212.10ms, 32.3MB)
테스트 3 〉	통과 (210.48ms, 32.4MB)
테스트 4 〉	통과 (192.92ms, 32.3MB)

• 값을 잠깐 바꿨다가 원래대로 돌리면?
• 응 더 느려 ㅋㅋㅋ

def solution(land):
    for i in range(1, len(land)):
        for j in range(4):
            _tmp, land[i-1][j] = land[i-1][j], 0
            land[i][j] += max(land[i-1])
            land[i-1][j] = _tmp
    return max(land[-1])
    
정확성  테스트
테스트 1 〉	통과 (3.97ms, 10.6MB)
테스트 2 〉	통과 (2.04ms, 10.3MB)
테스트 3 〉	통과 (4.02ms, 10.5MB)
테스트 4 〉	통과 (2.21ms, 10.5MB)
테스트 5 〉	통과 (3.79ms, 10.4MB)
테스트 6 〉	통과 (2.03ms, 10.5MB)
테스트 7 〉	통과 (3.96ms, 10.4MB)
테스트 8 〉	통과 (3.98ms, 10.5MB)
테스트 9 〉	통과 (2.70ms, 10.4MB)
테스트 10 〉	통과 (2.05ms, 10.4MB)
테스트 11 〉	통과 (2.07ms, 10.4MB)
테스트 12 〉	통과 (2.10ms, 10.4MB)
테스트 13 〉	통과 (3.99ms, 10.1MB)
테스트 14 〉	통과 (2.22ms, 10.5MB)
테스트 15 〉	통과 (2.07ms, 10.3MB)
테스트 16 〉	통과 (2.32ms, 10.2MB)
테스트 17 〉	통과 (3.98ms, 10.2MB)
테스트 18 〉	통과 (2.03ms, 10.3MB)
효율성  테스트
테스트 1 〉	통과 (205.14ms, 32.3MB)
테스트 2 〉	통과 (221.57ms, 32.4MB)
테스트 3 〉	통과 (221.31ms, 32.4MB)
테스트 4 〉	통과 (218.34ms, 32.4MB)