27-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

1039 교환

✔️ 소요된 시간

3일에 걸쳐 총 3시간...?

✨ 수도 코드

1. 문제

$1 \le N \le 1,000,000$이 주어진다.
주어진 수 N의 자릿수를 M이라 할 때, $1 \le i \lt j \le M$인 i, j를 선택해 i번째 숫자와 j번째 숫자를 교환한다. 이 때 바꾼 수가 0으로 시작하면 안된다.
숫자 교환을 $1 \le K \le 10$번 시행했을 때 만들 수 있는 가장 큰 수를 출력하라.

2. 시행착오

헷갈리기 쉬운데, 최대 K번 교환하는 것이 아닌 무조건 K번 교환해야 한다.
테스트 케이스로 주어지는 132 3의 경우, 반드시 3번 교환해야 하기 때문에 만들 수 있는 최대값은 321이 아닌 312임을 알 수 있다.

처음엔 "어 이거 재귀로 하면 코드 깔끔하게 나오겠는데?" 해서 코드를 싹싹 작성했고,

#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

string N; int K;

string dfs(string n, int k = 0) {
    if(k == K) {
        return n;
    } else if(k > K) {
        return "-1";
    } else {
        string max_num = "-1";
        for(int i = 0; i < N.size() - 1; ++i) {
            for(int j = i + 1; j < N.size(); ++j) {
                string tmp = n;
                swap(tmp[i], tmp[j]);
                if(tmp[0] == '0') {
                    continue;
                }
                
                max_num = max(max_num, dfs(tmp, k + 1));
            }
        }
        return max_num;
    }
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    
    cin >> N >> K;
    cout << dfs(N);
    return 0;
}

예제 테케는 전부 맞길래 "오 개꿀문제~" 이랬는데

귀신같이 시간초과가 떠버렸다.

그래서 음 dfs로 하면 경우의 수가 너무 많아지나? bfs로 바꿔봐? 해서 bfs로 작성해봤다.

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    string N; int K;
    cin >> N >> K;
    
    deque<pair<string, int>> Q;
    Q.emplace_back(N, 0);
    
    string MaxNum = "-1";
    while(!Q.empty())
    {
        const auto [Num, SwapCnt] = Q.front();
        Q.pop_front();
        
        if(SwapCnt == K)
        {
            MaxNum = max(MaxNum, Num);
            continue;
        }
        
        for(int i = 0; i < N.size() - 1; ++i)
        {
            for(int j = i + 1; j < N.size(); ++j)
            {
                string TmpNum = Num;
                swap(TmpNum[i], TmpNum[j]);
                
                if(TmpNum[0] == '0')
                {
                    continue;
                }
                
                Q.emplace_back(TmpNum, SwapCnt + 1);
            }
        }
    }
    
    cout << MaxNum;
    return 0;
}

이번에도 예제는 다 맞길래 슝 제출해봤는데

이번엔 메모리 초과가 뜬다(ㅎㅎ)

"아 확인했던 숫자들은 체킹해서 방문하지 않게 해버려?" 해서 Visited set을 선언해 이를 응용해봤지만...

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_set>

using namespace std;

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    string N; int K;
    cin >> N >> K;
    
    deque<pair<string, int>> Q;
    unordered_set<string> VisitedNum;
    
    Q.emplace_back(N, 0);

    string MaxNum = "-1";
    while(!Q.empty())
    {
        const auto [Num, SwapCnt] = Q.front();
        Q.pop_front();
        
        if(SwapCnt == K)
        {
            VisitedNum.emplace(Num);
            MaxNum = max(MaxNum, Num);
            continue;
        }
        
        for(int i = 0; i < N.size() - 1; ++i)
        {
            for(int j = i + 1; j < N.size(); ++j)
            {
                string TmpNum = Num;
                swap(TmpNum[i], TmpNum[j]);
                
                if(TmpNum[0] == '0' || VisitedNum.find(TmpNum) != VisitedNum.end())
                {
                    continue;
                }
                
                Q.emplace_back(TmpNum, SwapCnt + 1);
            }
        }
    }
    
    cout << MaxNum;
    return 0;
}

여전히 틀린다. 메모리 초과가 뜨던가 틀렸습니다가 뜬다.

이 때부터 정신이 멍해졌다. "이게 뭐지?"

일반적인 bfs처럼 새로운 수를 확인할 때마다 Visited를 넣어버리고 싶지만,

    while(!Q.empty())
    {
        const auto [Num, SwapCnt] = Q.front();
        Q.pop_front();
        
        cout << Num << ", " << SwapCnt << "\n";
        
        if(SwapCnt == K)
        {
            MaxNum = max(MaxNum, Num);
            continue;
        }
        
        for(int i = 0; i < N.size() - 1; ++i)
        {
            for(int j = i + 1; j < N.size(); ++j)
            {
                string TmpNum = Num;
                swap(TmpNum[i], TmpNum[j]);
                
                if(TmpNum[0] == '0' || VisitedNum.find(TmpNum) != VisitedNum.end())
                {
                    continue;
                }
                
                VisitedNum.emplace(TmpNum);
                Q.emplace_back(TmpNum, SwapCnt + 1);
            }
        }
    }

이 경우 132 3와 같은 케이스에서 문제가 생긴다.

132, 0
312, 1
231, 1
123, 1
132, 2
213, 2
321, 2
-1

이런 식으로 312를 만들려면 앞전에 방문했던 수를 다시 방문해야 하는데, Visited 체크 단계에서 걸러지면서 K번 Swap 하기 전에 Queue에 원소가 하나도 존재하지 않게 되는 문제가 생긴다.

"뭐지 어떻게 해야하는 거지?" 하고 계속 코드를 비틀어가며 트라이했으나...

이 쯤에서 정신을 잃어버렸고... 며칠동안 이 문제를 묻어뒀었다....

3. 풀이

예전에 알고리즘 수업시간 때 풀었던 과제를 보다가 생각이 들었다.
이 과제는 직진 또는 우회전만 할 수 있는 자동차를 타고 특정 좌표까지 도달할 수 있는 지를 검사하는 함수를 작성하는 거였는데, 이 때 방문 체크를 단순히 [x][y] 좌표에 대해서 검사하지 않고 해당 칸에 진입할 때의 방향 정보도 함께 기록했다.
즉 3차원 Visited 배열 [d][x][y]를 사용한 것인데, 왜냐하면 같은 칸에 들어오더라도 어느 방향에서 들어왔는 지에 따라 다른 상황이기 때문에 그렇다.

이거를 보고 "어? 교환 문제도 몇 번째 교환했는 지에 따라 구분해서 Visit 체크를 구분해서 해줘야 하나?" 싶어서 한 번 코드를 작성해봤다.

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

using namespace std;

string N; int K;
vector<vector<bool>> Visited;

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    cin >> N >> K;
    Visited.assign(K + 1, vector<bool>(1000001, false));
    
    cout << DFS(N, 0);
    
    return 0;
}

이런 식으로 행은 숫자를 k번 바꿨을 때를 의미하고, 열은 0부터 1,000,000까지의 숫자를 의미한다. 예를 들어 Visited[2][132]는 '숫자를 2번 바꿨을 때 132를 만난 적이 있는가'를 의미한다.

int DFS(string Num, int Depth)
{
    if(Visited[Depth][stoi(Num)])
    {
        return -1;
    }
    else if(Depth == K)
    {
        return stoi(Num);
    }
    else
    {
        Visited[Depth][stoi(Num)] = true;
        
        int MaxNum = -1;
        for(int i = 0; i < N.size() - 1; ++i)
        {
            for(int j = i + 1; j < N.size(); ++j)
            {
                if(i == 0 && Num[j] == '0')
                {
                    continue;
                }
                
                string TmpNum = Num;
                swap(TmpNum[i], TmpNum[j]);
                
                MaxNum = max(MaxNum, DFS(TmpNum, Depth + 1));
            }
        }
        
        return MaxNum;
    }
}

하고 이 Visited 배열을 기반으로 DFS 함수를 수정한다. 해당 Depth에서 방문한 적이 있는 숫자라면 즉시 -1을 return하는 조건이 추가됐고, recursive case에서는 해당 Depth에서의 Num을 방문 처리해준다.

홀리몰리과카몰리... 드디어 맞췄다 흑흑

4. 전체 코드

• 100만이란 숫자가 너무 많아서 이를 set으로 변경했더니 메모리 사용량이 줄어들었다.

#include <iostream>
#include <string>
#include <algorithm>
#include <unordered_set>

using namespace std;

string N; int K;
unordered_set<int> Visited[11];

int DFS(string Num = N, int Depth = 0)
{
    if(Visited[Depth].find(stoi(Num)) != Visited[Depth].end())
    {
        return -1;
    }
    else if(Depth == K)
    {
        return stoi(Num);
    }
    else
    {
        Visited[Depth].emplace(stoi(Num));
        
        int MaxNum = -1;
        for(int i = 0; i < N.size() - 1; ++i)
        {
            for(int j = i + 1; j < N.size(); ++j)
            {
                if(i == 0 && Num[j] == '0')
                {
                    continue;
                }
                
                string TmpNum = Num;
                swap(TmpNum[i], TmpNum[j]);
                
                MaxNum = max(MaxNum, DFS(TmpNum, Depth + 1));
            }
        }
        
        return MaxNum;
    }
}

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    cin >> N >> K;

    cout << DFS();
    
    return 0;
}

📚 새롭게 알게된 내용

다른 사람들은 보니까 거의 다 BFS 코드이길래, 나도 BFS로 수정해보자 싶어서 수정했는데 계속 틀린다... 뭐지?

[xxubin04]

3일동안 정말 수고 많으셨습니다..😮👍
문제 읽어봤을 때, 방향정보를 고려해야 한다고 전혀 생각지도 못했는데 정말 신기합니다🥲
알고리즘 과제에서 익혔던 기억을 바탕으로 문제를 푸시는 것도 멋지십니다!
저는 공부해도 잘 까먹고 응용하지 못하는 것 같은데 본받을 수 있도록 노력해야겠습니다!😁

[Dolchae]

정말 매번 느끼는 거지만, 감도 안 잡히는 이런 문제들을 어떻게 풀어내시는건지.. 것도 오랜시간동안 포기하지 않고요..!😲 하나의 숫자라도 교환횟수에 따라 다르게 처리해야 한다는 점으로 방문 처리 방식 저렇게 바꾸신 것도 진짜 대단하세요,, 정말 고생많이하셨습니다!!👍😊

[gjsk132]

이 문제 잠시 구경만 하고, PR 바로 보려고 했는데 뭔가 문제가 풀 수 있을 것 같아서 잠시만 보류해뒀다가 풀어보고 싶어요...

[LJEDD2]

소문의 그 구"교환"문제군요
다음에 꼭 한번 풀어보겠습니다

[gjsk132]

이 문제 지금 어제부터 간간히 계속 보고 있는데... 이전의 제가 뭔가 풀 수 있을 것 같다는 저를 매우 치고 싶네요.

그래도 한 3시간 투자해서 맞췄습니당! 😄

사실 저도 어떻게 풀었는지 잘 모르겠어요.

메모리 꾸역꾸역 줄이고... 시간 꾸역꾸역 줄이고...

모든 경우를 다 기억하니까 메모리 초과나서 배열 2개로 스위칭해버리고

같은 숫자 겹치는 경우 고려 안하니까 시간 초과나서 set으로 변경해주니까 어찌저찌... 해결됐습니다.

백트래킹 코드

input = open(0).readline

num, cnt = map(int,input().split())

memo = [set(), set()]

memo[0].add(num)

for i in range(cnt):
    while memo[i%2]:
        
        n = list(str(memo[i%2].pop()))

        for p1 in range(len(n)):
            for p2 in range(p1):
                n[p1], n[p2] = n[p2], n[p1]
                memo[(i+1)%2].add(int("".join(n)))
                n[p1], n[p2] = n[p2], n[p1]

if memo[cnt%2]:
    answer = max(memo[cnt%2])
    print(answer if len(str(answer)) == len(str(num)) else -1)
else:
    print(-1)

다음엔 코멘트에 기다려달라하지 말고 merge 해달라고 해야겠다...

리뷰 기다려주셔서 감사해여 👍👍👍👍

[tgyuuAn]

이 문제 지금 어제부터 간간히 계속 보고 있는데... 이전의 제가 뭔가 풀 수 있을 것 같다는 저를 매우 치고 싶네요.

그래도 한 3시간 투자해서 맞췄습니당! 😄

사실 저도 어떻게 풀었는지 잘 모르겠어요.

메모리 꾸역꾸역 줄이고... 시간 꾸역꾸역 줄이고...

모든 경우를 다 기억하니까 메모리 초과나서 배열 2개로 스위칭해버리고

같은 숫자 겹치는 경우 고려 안하니까 시간 초과나서 set으로 변경해주니까 어찌저찌... 해결됐습니다.

백트래킹 코드
다음엔 코멘트에 기다려달라하지 말고 merge 해달라고 해야겠다...

리뷰 기다려주셔서 감사해여 👍👍👍👍

"이전의 제가 뭔가 풀 수 있을 것 같다는 저를 매우 치고 싶네요."

...

😁😁😁