10-csecaujunseo

[caucsejunseo]

🔗 문제 링크

1로 만들기

✔️ 소요된 시간

1h

✨ 수도 코드

이전에 현석님이 하셨던 dp문제를 다시 풀어보았습니다. #22
그때보다 훨씬 간단한 문제입니다.

1. X가 3으로 나누어 떨어지면, 3으로 나눈다.
2. X가 2로 나누어 떨어지면, 2로 나눈다.
3. 1을 뺀다.
   이 세가지 연산만 사용하여 가장 적은 연산을 사용하는 방법을 찾는 문제입니다.

처음엔 단순히 그냥 3으로 많이 나누면 되는거 아닌가 생각했었는데 경우의 수가 훨씬 많더라구요.
그리고 가장 큰 수부터 아래로 내려가면서 문제를 해결하려고 하다보니 이것도 경우의 수가 훨씬 많아서 실패했었습니다...

그래서 dp 방식을 사용해서 풀게 되었습니다.
여기서 dp[i]는 i라는 숫자를 1로 만들기 위한 최소한의 연산 횟수를 말합니다. dp[10]이면 3인거죠.
dp는 이전에 공부했듯이 이전의 연산을 기억하며 푸는 방식입니다.

위 이미지처럼 앞선 dp[1]부터 dp[9]까지는 해결되었다고 생각하고 그 앞선 값들을 기억하고 푸는 방식입니다.

그래서 dp[10]을 구해야 한다고 가정한다면 dp[9]의 값을 기억하고 알고 있으므로 dp[10]은 dp[9]에서 연산 횟수인 +1을 한 dp[10]=dp[9]+1이라는 식이 성립할 수 있습니다. 또 다른 식은 dp[10]=dp[5]+1이 될 수 있습니다. 즉 5를 1로 만드는 연산 횟수에서 +1을 해주면 됩니다. 왜냐하면 10을 2로 나눌 수 있고 그러면 값이 5가 되기 때문!

이걸 점화식으로 작성하면

dp[i] = dp[i - 1] + 1         // 기본적으로 1을 뺀 경우

    if i % 2 == 0:                // 2로 나눠질 경우
        dp[i] = min(dp[i], dp[i / 2] + 1)

    if i % 3 == 0:                // 3으로 나눠질 경우
        dp[i] = min(dp[i], dp[i / 3] + 1)

이렇게 나타낼 수 있습니다. 그러니까 처음부터 10에서 3도 나눠보고 1도 빼보고 하는게 아니라 dp[1]부터 차례로 풀어나가는 방식입니당

수도 코드

'''입력: 정수 N

배열 dp[1..N]을 생성
dp[1] = 0 // 1은 연산 없이 1이므로 초기값

for i = 2 to N:

dp[i] = dp[i - 1] + 1         // 기본적으로 1을 뺀 경우

if i % 2 == 0:                // 2로 나눠질 경우
    dp[i] = min(dp[i], dp[i / 2] + 1)

if i % 3 == 0:                // 3으로 나눠질 경우
    dp[i] = min(dp[i], dp[i / 3] + 1)

출력: dp[N]
'''

📚 새롭게 알게된 내용

dp방식을 다시 한번 공부해보게 되었습니다!!

[dohyeondol1]

1로 만들기...
처음에 그리디로 접근했다가 낭패를 보고 처음 DP를 배우게 했던 문제인게 기억나네요..

저도 같은 방식으로 해결했습니다.
기본적으로 dp[i] = dp[i-1] + 1로 설정하고,
3 또는 2로 나누어진다면 dp[i/3]+1과 기존의 dp[i]를 비교(2도 같은 방식)하여 최솟값을 저장하는 풀이입니다.

C++

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
    int N;
    cin >> N;
    
    vector<int> dp(N+1);
    dp[1] = 0;
	for (int i = 2; i <= N; i++) {
		dp[i] = dp[i - 1] + 1;
		if(i%3 == 0) dp[i] = min(dp[i], dp[i / 3] + 1);
		if(i%2 == 0) dp[i] = min(dp[i], dp[i / 2] + 1);
	}
    
    cout << dp[N] << '\n';
    
    return 0;
}

추가로, 준서님의 코드를 제가 조금 더 간단하게 수정해보았습니다.

C99

#include <stdio.h>

int main(){
    int dp[1000001], n;
    scanf("%d", &n);
    
    dp[1] = 0;
    for(int i = 2; i <= n; i++){
        dp[i] = dp[i-1] + 1;
        if(i%2 == 0 && dp[i] > dp[i/2]+1) dp[i] = dp[i/2]+1;
        if(i%3 == 0 && dp[i] > dp[i/3]+1) dp[i] = dp[i/3]+1;
    }
    printf("%d", dp[n]);
}

스타일 차이인 부분도 있지만,
불필요한 메모리 할당 체크 코드랑 배열 메모리 동적 할당 코드를 지워봤어요.
아무래도 문제를 풀 때, 짧은 코드 작성은 시간을 단축시켜줘서 어느정도 이점이 있는 것 같습니다.
물론 자기가 제일 잘 쓰는 방법이 장땡입니다 ㅎㅎ

이 문제랑 비슷한 1, 2, 3 더하기 라는 문제도 한번 풀어보시는 걸 추천드립니다!
DP 문제는 점화식만 세울 수 있으면 쉽게 풀리는데 그 점화식이... 항상 문제인 것 같아요 ㅎㅎ;;

[dohyeondol1]

Suggested change

	|10차시| 2025.05.05 | 다이나믹 | [1로만들기](https://www.acmicpc.net/problem/1463)||
	|10차시| 2025.05.05 | DP | [1로만들기](https://www.acmicpc.net/problem/1463)|https://github.com/AlgoLeadMe/AlgoLeadMe-13/pull/38|

PR 링크가 빠져있네요! 또한 유형은 '다이나믹' 보다는 DP, 다이나믹 프로그래밍, 동적계획법 정도가 더 적절할 것 같습니다.

[dohyeondol1]

malloc은 동적 메모리 할당에 사용하는 함수인데, MAX 값을 상수로 정해놓고 이를 기반으로 할당하는 것은 사실상 정적 메모리 할당과 다를 바 없어 보이네요..! 정적 메모리 할당으로도 충분히 해결할 수 있는 문제라서 다음과 같이 수정하면 훨씬 간단한 코드가 될 것 같습니다.

Suggested change

	int* dp = (int*)malloc(sizeof(int) * MAX);
	int dp[1000001];

[9kyo-hwang]

첨언하자면, 함수 내에서 큰 사이즈의 배열을 선언하게 될 경우 Stack 메모리 초과가 발생할 수 있습니다. 고정된 큰 크기의 배열을 선언하고 싶으면 전역 변수로 두는 게 좋습니다 :)

[caucsejunseo]

확실히 그렇네요!
요즘 무조건적으로 정적 할당을 하고 있는 데, 좀 더 코드를 쓸 때 생각하고, 상황에 맞게 써봐야 할 거 같슴다!

[dohyeondol1]

이 코드는 동적 메모리 할당 실패에 대비하기 위해서 작성하신 것 같은데, 이 경우에는 할당 크기가 고정된 상수(MAX)이고 크기도 비교적 작아서 일반적인 환경에서는 할당 실패가 발생할 가능성이 거의 없다고 봐도 됩니다. 백준에서는 엥간해서 됩니덩. 지워도 무방할 것 같네요.

[9kyo-hwang]

이 문제는 DP로 풀 수 있지만, 그래프 문제로 해석해서도 풀 수 있습니다.
X 노드에서 출발해 1 노드에 도달하는 "최단 경로" 찾기 문제로 해석하면 딱 그래프 문제 같죠?

#include <iostream>
#include <queue>
#include <unordered_map>

using namespace std;

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int X; cin >> X;
    queue<int> Q; Q.emplace(X);
    unordered_map<int, int> Map; Map[X] = 0;  // Visited 배열이라 생각하면 됩니다.
    
    while(!Q.empty())
    {
        int Current = Q.front(); Q.pop();
        if(Current == 1)
        {
            break;
        }
        else if(Current < 1)
        {
            continue;
        }
        
        if(Current % 3 == 0 && Map.count(Current / 3) == 0)  // 인접 노드로 갈 수 있느냐
        {
            Map[Current / 3] = Map[Current] + 1;
            Q.emplace(Current / 3);
        }
        
        if(Current % 2 == 0 && Map.count(Current / 2) == 0)  // 방문한 적이 없는 지 함께 체크
        {
            Map[Current / 2] = Map[Current] + 1;
            Q.emplace(Current / 2);
        }
        
        if(Map.count(Current - 1) == 0)
        {
            Map[Current - 1] = Map[Current] + 1;
            Q.emplace(Current - 1);
        }
    }
    
    cout << Map[1];
    
    return 0;
}

[caucsejunseo]

이 문제는 DP로 풀 수 있지만, 그래프 문제로 해석해서도 풀 수 있습니다. X 노드에서 출발해 1 노드에 도달하는 "최단 경로" 찾기 문제로 해석하면 딱 그래프 문제 같죠?

이런 생각은 못했네요! 아직 다양한 문제를 못풀어 봐서 생각이 고정되는 거 같습니다...

다음엔 그래프 문제도 풀어보겠습니다!

[froglike6]

앞서 dp와 그래프를 이용한 방법을 잘 알려주셔서 정수론 쪽으로도 생각해봤는데, -1이라는 조건 때문에 불가능하네요..
그래서 dp를 이용해서 파이썬으로 풀어봤습니다.

import sys

def solve():
    N = int(sys.stdin.readline())

    if N == 1:
        print(0)
        return

    dp = [0] * (N + 1)

    for i in range(2, N + 1):
        dp[i] = dp[i-1] + 1

        if i % 2 == 0:
            dp[i] = min(dp[i], dp[i//2] + 1)
        
        if i % 3 == 0:
            dp[i] = min(dp[i], dp[i//3] + 1)
            
    print(dp[N])

if __name__ == '__main__':
    solve()

[hadongun]

이 문제.. 저번에 현석님이 재밌는 문제라며 던져주셨다가 실패한 문제네용
그냥 그리디 알고리즘으로 풀려고 했던 것 같은데, dp로 푸는 게 정석이었군요..!
공부 하고 코드 짜봤습니답

Details

n = int(input())
d = [0] * (n + 1) 

for i in range(2, n + 1):
    d[i] = d[i - 1] + 1  

    if i % 2 == 0:
        d[i] = min(d[i], d[i // 2] + 1)  
    if i % 3 == 0:
        d[i] = min(d[i], d[i // 3] + 1)  

print(d[n])