13-oesnuj

[oesnuj]

🔗 문제 링크

백준 | 부녀회장이 될테야

✔️ 소요된 시간

30분

✨ 수도 코드

solved.ac class2에 남은 마지막 문제인데 DP로 분류되어있길래 마무리 할겸 풀어봤습니다.

먼저 문제의 조건을 읽으니 친절하게 재귀를 쓰라는 말하는 것 같았습니다.
k층에 따른 1부터 n호까지의 사람수의 합이라...

1️⃣ 풀이 1 재귀만 이용

근데 c++이라 그런지는 모르겠지만 재귀만 썼는데도 풀렸습니다.
모든 재귀 문제가 그렇듯 문제의 정의 + 탈출조건을 제대로 만들면 됩니다.
문제에서 k층 n호의 사람수는 k-1층의 1호부터 n호까지의 사람 수의 합이라고 했습니다.

Note

문제의 정의 : k층 n호의 사람수 = k-1층의 1호부터 n호까지의 사람 수의 합
탈출 조건 : 0층일 경우 사람수(n) 리턴

위 두가지를 활용해 재귀함수를 만들어줍니다!!!

/*풀이1 재귀만 이용*/
#include <iostream>
using namespace std;

int calc(int k, int n) {
    if (k == 0) return n; //0층인 경우 n명 리턴
    //0층이 아닌 경우라면 한칸 아래층의 1호부터 n호까지의 사람수 합을 리턴
    int sum = 0;
    for (int i = n; i > 0; i--) {
        sum += calc(k - 1, i);
    }
    return sum;
}

int main() 
{
    int T, k, n;
    cin >> T;
    while (T--) {
        cin >> k >> n;
        cout << calc(k, n) << "\n";
    }
    return 0;
}

2️⃣ 풀이2 재귀 + DP

DP는 동일한 계산을 반복해야 할 때, 이전에 계산한 값을 메모리에 저장함으로써 동일한 계산의 반복 수행을 제거하여 프로그램 실행 속도를 빠르게 하는 기술이다.
이 문제에서는 k, n에 따른 함수호출 결과를 메모리에 저장해두어 재귀 호출에서 이미 호출된 적이 있는 k, n의 값에 대해서는 저장된 값을 반환합니다!

[추가된 부분]

• 탈출 조건에 호출된적 있는 경우 dp테이블의 값을 리턴
• 첫 호출인 경우, 결과를 dp테이블에 저장하고 반환
• 매 케이스마다 dp테이블 초기화

/*풀이2, 재귀 + DP*/
#include <iostream>
#include <vector>
using namespace std;

vector<vector<int>> dp;

int calc(int k, int n) {
    if (k == 0) return n;
    if (dp[k][n] != -1) return dp[k][n]; // 이미 계산된 값이면 반환

    int sum = 0;
    for (int i = n; i > 0; i--) {
        sum += calc(k - 1, i);
    }
    return dp[k][n] = sum; // 계산된 값을 저장하고 반환
}

int main()
{
    int T, k, n;
    cin >> T;
    while (T--) {
        cin >> k >> n;
        dp = vector<vector<int>>(k + 1, vector<int>(n + 1, -1)); //케이스별 DP 테이블 초기화
        cout << calc(k, n) << "\n";
    }
    return 0;
}

3️⃣ 속도 차이

위가 DP 풀이인데 시간을 보니 차이가 확실히나네요

단순 재귀: 시간복잡도 O(n^k)로 k와 n이 커질수록 계산량이 많이 증가합니다.

재귀 + DP: 시간 복잡도 O(k * n^2)로 중복계산을 피하므로 시간복잡도가 훨씬 줄어듭니다.

📚 새롭게 알게된 내용

DP테이블을 활용한 메모제이션 방식으로 더 효율적으로 재귀호출을 한다!

또 다른 풀이로 0층 1호 부터 시작해서 증가시켰을때의 규칙으로 점화식을 세워 푸는 방식도 있는 것 같은데 다들 풀어보셨다면 어떻게 풀었는지 궁금하네요.

[pu2rile]

처음 문제를 풀었을 때 단순하게 반복문을 사용해서 풀었는데 코드가 간결하긴 하지만 준서님처럼 dp를 사용하는 게 훨씬 효율적이겠더라구요

반복문 코드

T = int(input())  # 테스트 케이스 수 입력

for _ in range(T):
    k = int(input())  # 층 수 입력
    n = int(input())  # 호 수 입력

    # 0층의 각 호수에 있는 사람 수를 초기화
    people = [i for i in range(1, n+1)]

    # k층까지의 각 호수에 있는 사람 수를 계산
    for _ in range(k):
        for i in range(1, n):
            people[i] += people[i-1]
    print(people[-1])  # k층 n호에 있는 사람 수 출력

dp 코드

def calc(k, n, dp):
    if k == 0:
        return n
    if dp[k][n] != -1:
        return dp[k][n]  # 이미 계산된 값이면 반환

    sum_ = 0
    for i in range(1, n + 1):
        sum_ += calc(k - 1, i, dp)
    dp[k][n] = sum_  # 계산된 값을 저장
    return sum_

T = int(input())  # 테스트 케이스 수 입력

for _ in range(T):
    k = int(input())  # 층 수 입력
    n = int(input())  # 호 수 입력
    
    # DP 테이블 초기화
    dp = [[-1] * (n + 1) for _ in range(k + 1)]
    
    # 결과 계산 및 출력
    result = calc(k, n, dp)
    print(result)

저도 결국 준서님이랑 같은 로직으로 풀어서 다른 방식을 생각해내진 못했지만... dp 연습으로 좋은 문제였던 것 같아요!! pr 수고하셨습니다

[9kyo-hwang]

사실 요건 바텀업 방식이 딱 직관적이긴 합니다 :)

#include <stdio.h>
#include <memory.h>

int t, k, n;
int apartment[15][15];

int main()
{
    scanf(" %d", &t);
    while(t--)
    {
        scanf(" %d %d", &k, &n);
        memset(apartment, 0, sizeof(apartment));
        
        for(int number = 1; number <= n; ++number)
        {
            apartment[0][number] = number;
        }
        
        for(int floor = 1; floor <= k; ++floor)
        {
            for(int number = 1; number <= n; ++number)
            {
                apartment[floor][number] 
                    = apartment[floor - 1][number] + apartment[floor][number - 1];
            }
        }
        
        printf("%d\n", apartment[k][n]);
    }

    return 0;
}