45-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

2240 자두나무

✔️ 소요된 시간

1시간 반?

✨ 수도 코드

1. 문제

자두 나무 두 그루가 1번 위치와 2번 위치에 있다. 1초부터 $T$($1 \le T \le 1,000$)초까지 매 초마다 두 나무 중 하나에서 자두가 떨어진다.
1번 위치에서 시작해서, 최대 $W$($1 \le W \le 30$)번 움직여 최대한 많이 자두를 얻고자 한다.
1번 위치와 2번 위치를 이동하는 데는 별도의 시간이 들지 않는다고 할 때, 얻을 수 있는 최대 자두 개수를 구해 출력하는 프로그램을 작성하라.

예를 들어 T = 7, W = 2 이고 자두가 떨어지는 나무 정보가 [2, 1, 1, 2, 2, 1, 1] 이렇게 주어졌을 때

• 1번 위치에서 시작한다.
• 1초에 2번 나무에서 자두가 떨어진다. 하지만 움직이지 않아 자두를 얻지 않는다. -> 0
• 2초에 1번 나무에서 자두가 떨어진다. 여전히 1번 위치이므로 자두를 하나 얻는다. -> 1
• 3초에 1번 나무에서 자두가 떨어진다. 여전히 1번 위치이므로 자두를 하나 얻는다. -> 2
• 4초에 2번 나무에서 자두가 떨어진다. 2번 위치로 이동해 자두를 하나 얻는다. -> 3
• 5초에 2번 나무에서 자두가 떨어진다. 여전히 2번 위치이므로 자두를 하나 얻는다. -> 4
• 6초에 1번 나무에서 자두가 떨어진다. 1번 위치로 이동해 자두를 하나 얻는다. -> 5
• 7초에 1번 나무에서 자두가 떨어진다. 여전히 1번 위치이므로 자두를 하나 얻는다. -> 6

이 경우가 W번 이내 움직이며 자두를 6개로 최대한으로 얻을 수 있다.

2. 잡담

디코에 추천 문제로 올라온 지는 꽤 됐으나, 계속 안 풀고 있다가 이번 프경대 3번 문제에서 철퇴를 당하고 참회의 의미로 풀게 되었다 흑흑
진짜 문제가 거의 비슷하네...

3. 풀이

단순히 생각하면

• 0번 움직일 때 얻을 수 있는 최대 자두 개수
• 1번 움직일 때 얻을 수 있는 최대 자두 개수
• ...

이런 식으로 모든 경우를 다 돌아보면 풀 수 있다.

문제는 1번 이상 움직일 수 있게 되면 "어디서 움직여야 최대인가"를 찾기 위해 무수히 많은 경우의 수를 파악해야 한다.

그런데 잘 생각해보면 꽤 많은 경우의 수가 "중복"된다. 예를 들어 "2초 시점에 1번 위치에서 2번 위치로 이동"한 결과가 모든 경우에서 단 한 번만 등장하지 않는다. 전역에 걸쳐 여러 번 확인하게 될 것이다.

그렇다면, "다이나믹 프로그래밍" 개념을 적용시켜 결과를 캐싱해놓으면 중복을 줄일 수 있다.

조금 더 생각해보자.

상황을 일반화해보면, T - 1초 시점에서 1번/2번 위치에서 이동을 하던가 안하던가 해서 T초 시점에 각각 최대로 많이 딴 자두 개수를 기록할 수 있다.
이 과정에서 만약 한 번도 안움직이는 경우라면 a -> c, b -> d만 허용될 것이고, 아니라면 두 경우 모두 고려하게 될 것이다. 즉 움직일 수 있는 횟수에 따라 경우의 수가 나뉜다.

즉 1. 시간 정보 2. 좌표 정보 3. 움직인 횟수 정보 3가지를 가지고 테이블을 만들면 일반화된 점화식을 이용해 bottom-up 방식의 dp를 구현할 수 있게 된다. 이제 코드로 확인해보자.

T, W = map(int, input().split())
poses = [int(input()) for _ in range(T)]
poses = [0] + [pos - 1 for pos in poses]

주어진 입력을 저장한다. 인덱스 처리를 편리하게 하기 위해서 1번, 2번을 0번, 1번으로 바꿔서 저장한다.
또한 시작 위치가 1번이므로 좌표 리스트 맨 앞에 [0]을 덧붙인다.

dp[w][t][0] = max(dp[w][t - 1][0], dp[w - 1][t - 1][1]) + (poses[t] == 0)
dp[w][t][1] = max(dp[w - 1][t - 1][0], dp[w][t - 1][1]) + (poses[t] == 1)

위 그림을 토대로 일반화된 점화식을 세우면 위와 같다.
dp[w][t][0]는 w번 움직인 상황에서, t초 시점에 0번 위치에서 얻을 수 있는 최대 자두 개수를 의미한다. 이는

• t-1초 시점에 0번 위치에서 움직이지 않고(w) 가만히 있던 경우
• t-1초 시점에 1번 위치에서 움직여서(w-1) 0번 지점으로 온 경우

위 두 경우 중 큰 경우에, t초 시점에 자두가 떨어지는 나무 위치가 0이면(poses[t] == 0) + 1을 한 경우가 최대이다.
dp[w][t][1]도 동일한 논리이다.

여기서 예외로 처리해야 할 경우가 2가지 있는데

1. 움직일 수 있는 횟수가 0이라면 계속 0번 위치에 있던가 1번 위치에 있어야 한다.
   

if w == 0:
    dp[w][t][0] = dp[w][t - 1][0] + (poses[t] == 0)
    dp[w][t][1] = dp[w][t - 1][1] + (poses[t] == 1)
    continue

즉 t-1초 시점에 해당 위치에 가만히 있던 경우만 확인한다.

2. 시작 위치는 0번으로 고정돼있기 때문에, 1초 시점에서는 1번 위치에서 온 경우를 고려해서는 안된다.
   

dp[w][1][0] = dp[w][0][0] + (poses[1] == 0)
if w > 0:
    dp[w][1][1] = dp[w - 1][0][0] + (poses[1] == 1)

1초 시점에, 0번 위치는 0번 위치 그대로 가져오고, 1번 위치는 0번 위치에서 1번 움직인 경우만 확인한다.

이를 0번 움직일 수 있는 경우 ~ W번 움직일 수 있는 경우를 다 돌아보면서 매 초(1 ~ T) 값을 갱신해주면 된다.

마지막으로, T초 시점에서 0번, 1번, ..., W번 움직였을 때 0번/1번 위치에 기록된 최대 자두 개수를 출력하면 완성이다.

print(max(max(dp[w][T][0], dp[w][T][1]) for w in range(W + 1)))

전체 코드

input = open(0).readline

T, W = map(int, input().split())
poses = [int(input()) for _ in range(T)]
poses = [0] + [pos - 1 for pos in poses]

dp = [[[0] * 2 for _ in range(T + 1)] for _ in range(W + 1)]

for w in range(W + 1):
    dp[w][1][0] = dp[w][0][0] + (poses[1] == 0)
    if w > 0:
        dp[w][1][1] = dp[w - 1][0][0] + (poses[1] == 1)
    
    for t in range(2, T + 1):
        if w == 0:
            dp[w][t][0] = dp[w][t - 1][0] + (poses[t] == 0)
            dp[w][t][1] = dp[w][t - 1][1] + (poses[t] == 1)
            continue
        
        dp[w][t][0] = max(dp[w][t - 1][0], dp[w - 1][t - 1][1]) + (poses[t] == 0)
        dp[w][t][1] = max(dp[w - 1][t - 1][0], dp[w][t - 1][1]) + (poses[t] == 1)
        

print(max(max(dp[w][T][0], dp[w][T][1]) for w in range(W + 1)))

• c++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int T, W; cin >> T >> W;
    vector<int> Poses(T + 1, 0);
    for(int t = 1; t <= T; ++t)
    {
        cin >> Poses[t];
        Poses[t] -= 1;
    }
    
    vector<vector<vector<int>>> DP(W + 1, vector(T + 1, vector(2, 0)));
    
    for(int Walk = 0; Walk <= W; ++Walk)
    {
        DP[Walk][1][0] = DP[Walk][0][0] + (Poses[1] == 0);
        if(Walk > 0)
        {
            DP[Walk][1][1] = DP[Walk - 1][0][0] + (Poses[1] == 1);
        }
        
        for(int Time = 2; Time <= T; ++Time)
        {
            if(Walk == 0)
            {
                DP[Walk][Time][0] = DP[Walk][Time - 1][0] + (Poses[Time] == 0);
                DP[Walk][Time][1] = DP[Walk][Time - 1][1] + (Poses[Time] == 1);
                continue;
            }
            
            DP[Walk][Time][0] = max(DP[Walk][Time - 1][0], DP[Walk - 1][Time - 1][1]) + (Poses[Time] == 0);
            DP[Walk][Time][1] = max(DP[Walk - 1][Time - 1][0], DP[Walk][Time - 1][1]) + (Poses[Time] == 1);
        }
    }
    
    int Ans = 0;
    for(int Walk = 0; Walk <= W; ++Walk)
    {
        Ans = max({Ans, DP[Walk][T][0], DP[Walk][T][1]});
    }
    cout << Ans;
    
    return 0;
}

📚 새롭게 알게된 내용

에잉 이상한 삽질한다고 시간 너무 많이 날렸다.

에휴 진작에 풀어볼걸...

[xxubin04]

dp[w][t][0] = max(dp[w][t - 1][0], dp[w - 1][t - 1][1]) + (poses[t] == 0)
dp[w][t][1] = max(dp[w - 1][t - 1][0], dp[w][t - 1][1]) + (poses[t] == 1)

이렇게 poses[t] == 0, 1로 구현한게 엄청 참신한걸요?!
DP는 아직 어려워서 PR 보면서 쉽게 이해할 수 있었습니다!
블로그도 참고해서 보니 몇 번째 나무인지(T)로 시작하여 몇 번 바꿨는지(W)로 진행하는 방법도 있더라구요.
참고해도 좋을 것 같아 사진으로만 남겨봅니다..😊

블로그 참고

[gjsk132]

2차원 DP로 풀었습니다!

dp[시간][자리를 바꾼 횟수]로 알면 될 것 같습니다.

2차원으로 줄일 수 있었던 이유는 자리를 바꿨을 때, 얻을 수 있는 자두나무의 번호는 정해져 있다는 것을 사용했습니다.

예를 들어
자리를 1번 바꾸면, 2번 자두나무 / 자리를 2번 바꾸면, 1번 자두나무
홀수만큼 바꾸면 2번을 먹을 수 있고, 짝수만큼 바꾸면 1번을 먹을 수 있습니다.

결국 어떤 시간에 자두를 먹을 수 있냐 없냐를 알 수 있습니다.

이제부턴 DP유형에서 많이 해본 느낌이라서 더 간단합니다.
이전의 시간에서 자리를 바꿀 때와 그대로 왔을 때 중에서 더 큰 값을 더해주면 됩니다.

위 과정을 이용해서 결과를 내면 아래 이미지와 같은 결과가 나옵니다.

그럼 제일 마지막 시간에서 max 값을 찾아서 출력하면 됩니다.

input = open("input.txt").readline

time, can_change = map(int,input().split())

dp = [[0]*(can_change+1) for _ in range(time)]

for t in range(time):
    for set in range(int(input())-1, can_change+1, 2):
        dp[t][set] += 1

for t in range(1, time):
    for idx in range(min(t, can_change)+1):
        if idx == 0:
           dp[t][idx] += dp[t-1][idx]
           continue

        dp[t][idx] += max(dp[t-1][idx-1], dp[t-1][idx])

print(max(dp[-1]))

바로 이전의 값만 기억하면 되기 때문에, time마다 기억하지 않아도 되는 점을 이용하면 메모리를 더 줄일 수 있을 것 같습니다.🤔

[gjsk132]

1. 시간 정보 2. 좌표 정보 3. 움직인 횟수 정보 3가지

간단하게 말하면, 2번 정보를 생략한 방법인 것 같습니다!