8-H0ngJu

[H0ngJu]

🔗 문제 링크

쉬운 계단 수

✔️ 소요된 시간

1시간?

✨ 수도 코드

이 문제는 조금만 생각해보면 길이가 K+1인 계단 수는 K인 계단 수의 끝자리가 어떻게 되느냐에 따라서 경우의 수가 1인지 2인지로 구분되는 것을 알 수 있습니다.

"이전 길이의 계단 수의 끝자리만 알면 다음 계단 수를 구할 수 있다"는 것을 알았지만, 문제는 '계단 수의 끝자리를 어떻게 저장할 것인가?'였습니다.

그런데 조금만 더 생각해보면,

길이가 K+1인 계단 수를 구한다고 가정하였을 때, K번째 계단 수의 끝자리가 N이라고 하면,

N이 0이면 -> 올라가는 경우의 수 밖에 없으므로 길이가 K면서 N이 0인 경우의 수 유지
N이 9이면 -> 내려가는 경우의 수 밖에 없으므로 길이가 K면서 N이 9인 경우의 수 유지
N이 2~8이면 -> 내려가고 올라가는 경우의 수(2가지)가 존재하므로 길이가 K 이면서 N이 N-1,N+1경우의 합

이 됩니다.

따라서 2차원 DP를 생성하고, 다음과 같은 점화식을 세우면 쉽게 문제를 풀 수 있습니다.

1. k == 0이면 DP[i][1]
2. k == 9이면 DP[i][8]
3. k == 2~8이면 DP[i][k] = DP[i][k+1] + DP[i][k-1]

📚 새롭게 알게된 내용

[pknujsp]

1, 2 차원 dp테이블 둘 다 사용해서 풀어보았습니다

이전 자릿수에서의 값을 기반으로 계단 수 개수를 구하는 거다보니
1차원 리스트로도 풀이가 가능합니다

1차원 풀이

dp를 그대로 쓰면서 계산하면 이전 자릿수에서의 값이 바뀌기 때문에
new_dp로 리스트를 새로 생성해서 이전 값을 보존시킨 후 연산 합니다

dp[i] 를 dp[1],` dp[2] 순서대로 연산할 때 dp[2], dp[0], dp[3], dp[1] 의 값이 변경됩니다
이 과정에서 dp[3]의 값이 i가 3이 되기도 전에 바뀌어 버립니다

그래서 i가 3이 되었을 때 이전 자릿수에서의 값이 손실된 상태이므로 계단 수의 개수를 제대로 구할 수가 없습니다

N = int(input())
MOD = 1_000_000_000

dp = [1] * 10
dp[0] = 0

for _ in range(1, N):
    new_dp = [0] * 10
    
    for i, c in enumerate(dp):
        if i < 9:
            new_dp[i + 1] += c % MOD
        if i > 0:
            new_dp[i - 1] += c % MOD

    dp = new_dp

print(sum(dp) % MOD)

2차원 풀이

홍주님 코드랑 거의 똑같군요

dp = [[0] * 10 for _ in range(N)]

for i in range(1, 10):
    dp[0][i] = 1

for i in range(1, N):
    for j in range(10):
        if j < 9: 
            dp[i][j] += dp[i - 1][j + 1] % MOD
        if j > 0: 
            dp[i][j] += dp[i - 1][j - 1] % MOD

print(sum(dp[-1]) % MOD)

[tgyuuAn]

홍주님 PR을 보니 DP적 사고방식이 너무 정확합니다.

그렇게 DP를 접근해주시면 좋을 것 같아요.

"어떤 값을 기억해놔야 다음 값을 얻을 수 있지?"

"어떤 정보가 있어야지 똑같은 연산을 반복하지 않을 수 있을까?

N번째 값을 구하기 위해 N-1번째에서 어떤 정보가 필요하지? 등등 이요...!

아주 좋아요,

N = int(input())

dp_table = [[0 for _ in range(10)] for _ in range(N+1)]

for i in range(1,10):
    dp_table[1][i] = 1

for step in range(2,N+1):
    for num in range(10):
        if num != 0 and num != 9:
            dp_table[step][num] = dp_table[step-1][num-1] + dp_table[step-1][num+1]
          
        elif num == 0:
            dp_table[step][num] = dp_table[step-1][num+1]

        elif num == 9:
            dp_table[step][num] = dp_table[step-1][num-1]

print(sum(dp_table[-1])%1_000_000_000)

[Munbin-Lee]

#include <iostream>
#include <functional>
#include <unordered_map>

using namespace std;

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    unordered_map<int, unordered_map<int, int>> memo;

    for (int i = 0; i <= 9; i++) {
        memo[i][1] = 1;
    }

    int MOD = 1e9;

    function<int(int, int)> dp = [&](int head, int digit) {
        if (memo.contains(head) && memo[head].contains(digit)) {
            return memo[head][digit];
        }

        if (head == 0) {
            return memo[head][digit] = dp(1, digit - 1);
        }

        if (head == 9) {
            return memo[head][digit] = dp(8, digit - 1);
        }

        return memo[head][digit] = (dp(head - 1, digit - 1) + dp(head + 1, digit - 1)) % MOD;
    };

    int N;
    cin >> N;

    int answer = 0;

    for (int i = 1; i <= 9; i++) {
        answer += dp(i, N);
        answer %= MOD;
    }

    cout << answer;

    return 0;
}

계단 수의 서브시퀀스는 계단 수 -> DP를 떠올리고 탑다운으로 구현했습니다.

다른 분들 풀이 보니까 바텀업이 더 깔끔해보이네요

다음에는 바텀업으로 푸는 방법도 연습해오겠습니다.