35-Munbin-Lee

[Munbin-Lee]

🔗 문제 링크

https://www.acmicpc.net/problem/24891

✔️ 소요된 시간

2시간

✨ 수도 코드

먼저 브루트포스 풀이를 생각해보자.

모든 경우의 단어 순열을 구하려면 $_N\mathrm{P}_L$ 의 시간이 필요하다.

각 단어 순열에 대하여, 단어 마방진인지 확인하려면 $L^2$ 의 시간이 필요하다.

따라서, 브루트포스 알고리즘의 시간 복잡도는 $O(_N\mathrm{P}_L L^2)$ = 20 * 19 * 18 * 17 * 16 * 5 * 5 = 46512000 이므로 시간 내에 통과할 수 있다.

파이썬의 itertools.permutaions로 날먹해보자.

from itertools import permutations

stdin = open(0)

L, N = map(int, stdin.readline().split())
words = stdin.read().splitlines()

# 단어 순열 x가 단어 마방진인지 확인하는 함수
def isValid(x):
    for i in range(L):
        for j in range(L):
            if x[i][j] != x[j][i]: return False
    
    return True

answer = ('a',)

for perm in permutations(words, L):
    if not isValid(perm): continue
    
    answer = min(answer, perm)

if len(answer) == 1:
    print('NONE')
    exit()

print(*answer, sep='\n')

무지성 브루트포스로도 충분히 통과할 수 있다.

---

사실 난 처음에는 백트래킹으로 먼저 풀려고 했다.

단어들을 사전 순으로 정렬하고, BFS로 제일 먼저 탐색에 성공한 단어 마방진이 답일 것이라고 생각했다.

하지만 틀렸다.

그래서 BFS로 그냥 모든 단어 마방진을 백트래킹 탐색하였다.

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

using namespace std;

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

    int L, N;
    cin >> L >> N;

    vector<string> words(N);

    for (auto &word: words) {
        cin >> word;
    }

    queue<tuple<int, int, vector<vector<char>>>> q;
    vector<vector<char>> init(L, vector<char>(L));
    q.emplace(0, 0, init);

    vector<vector<char>> answer = {{'Z' + 1}};

    while (!q.empty()) {
        auto [index, mask, cur] = q.front();
        q.pop();

        auto isValid = [&](int i) {
            for (int j = 0; j < L; j++) {
                if (!cur[index][j]) continue;
                if (cur[index][j] != words[i][j]) return false;
            }

            return true;
        };

        for (int i = 0; i < N; i++) {
            if (mask & (1 << i)) continue;
            if (!isValid(i)) continue;

            auto next = cur;

            for (int j = 0; j < L; j++) {
                next[index][j] = words[i][j];
                next[j][index] = words[i][j];
            }

            if (index + 1 == L) {
                answer = min(answer, next);
                continue;
            }

            q.emplace(index + 1, mask | (1 << i), next);
        }
    }

    if (answer.size() == 1) {
        cout << "NONE";
        return 0;
    }

    for (auto &word: answer) {
        for (char ch: word) {
            cout << ch;
        }
        cout << '\n';
    }

    return 0;
}

C++인 것을 감안했을 때, 브루트포스(pypy3)와 백트래킹(C++)의 시간 차이가 얼마 나지 않는다.

---

그럼 어떻게 효율적으로 풀 수 있을까?

단어를 정렬하고, bfs 대신 dfs를 돌려서 처음에 나오는 단어 마방진을 출력하였더니 맞았다.

stdin = open(0)

L, N = map(int, stdin.readline().split())
words = sorted(stdin.read().splitlines())

def isValid(x):
    for i in range(L):
        for j in range(L):
            if x[i][j] != x[j][i]: return False
    
    return True

def dfs(index, mask, cur):
    if index == L:
        if not isValid(cur): return
        
        print(*cur, sep='\n')
        exit()
    
    for i in range(N):
        if mask & (1 << i): continue
        dfs(index + 1, mask | (1 << i), cur + [words[i]])

dfs(0, 0, [])

print('NONE')

시간이 절반 가량으로 줄어들었다.

index가 마지막일 때만 체크하지 말고, 중간 중간에 단어마방진인지 체크하여 브루트포스->백트래킹으로 바꾸면 훨씬 더 빨라질 것이다.

왜 BFS가 아니라 DFS를 돌려야할까?

모르겠다.

---

그런데, itertools.permutations의 탐색 순서를 생각해보니 dfs의 탐색 순서와 같다.

그럼 그냥 dfs를 구현하지 말고 첫번째 perm을 출력하면 되는 것 아닌가?

from itertools import permutations

stdin = open(0)

L, N = map(int, stdin.readline().split())
words = sorted(stdin.read().splitlines())

# 단어 순열 x가 단어 마방진인지 확인하는 함수
def isValid(x):
    for i in range(L):
        for j in range(L):
            if x[i][j] != x[j][i]: return False
    
    return True

for perm in permutations(words, L):
    if not isValid(perm): continue
    
    print(*perm, sep='\n')
    exit()

print('NONE')

permutations 특성 상 최적화가 되어있어서 세 번째 풀이보다는 살짝 빠르다.

[9kyo-hwang]

ㄷㄷㄷㄷㄷㄷㄷㄷ

[tgyuuAn]

import sys

word_length, word_count = map(int,sys.stdin.readline().split())
answer = []
word_list = []
for _ in range(word_count):
    word_list.append(sys.stdin.readline())

def is_magic_square(idx_bundle):
    for col in range(len(idx_bundle)):
        for row in range(len(idx_bundle)):
            if word_list[idx_bundle[row]][col] != word_list[idx_bundle[col]][row]: return False
    return True

def dfs(idx_bundle, visited, word_count, word_length):
    global answer

    if len(idx_bundle) == word_length:
        if is_magic_square(idx_bundle):
            magic_square = ""
            for idx in idx_bundle:
                magic_square += word_list[idx]
            answer.append(magic_square)
        return

    for idx in range(word_count):
        if idx in visited: continue

        visited.add(idx)
        idx_bundle.append(idx)
        dfs(idx_bundle, visited,word_count, word_length)
        visited.discard(idx)
        idx_bundle.pop()
    return

dfs(list(), set(), word_count, word_length)
answer.sort()
if answer: print(answer[0])
else: print("NONE")

저는 완탐으로 풀었씁니다.

근데 시간이 너무 오래 걸려서 문빈님 코드 보니까 입이 쩍쩍 벌어지네요

문제 의도는 완탐인 것 같은데 파이썬 permutations 으로 접근하는 아이디어 무릎 탁 쳤고

정렬해서 맨 처음 꺼 제출하는 거에서 무릎을 탁탁 쳤네요 ㅎㄷㄷ;;

[tgyuuAn]

와 단어를 정렬한 뒤에

permutations으로 처음 나오는 거를 제출하면 완탐할 필요도 없이

처음 걸리는 거에서 바로 제출하면 되니까

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

지리는데요..

[Munbin-Lee]

근데 왜 처음 것이 답인지는 모름요.

[tgyuuAn]

근데 왜 처음 것이 답인지는 모름요.

원래는 모든 경우의 수를 구해서 구해진 정답 후보자들에서 정렬해서 첫 번째 꺼를 제출해야하는데 (사전 순으로)

근데 어차피 정렬 한 뒤에 가장 첫 번째 나오는 친구는 정렬된 상태에서 뽑았기 때문에 어차피 사전에 첫 번째 순서인 거죠...

개똑똑한데요?

[pknujsp]

이 문제 재밌네요
한 시간 넘게 걸리긴 했는데
중간에 정렬하고 순서대로 dfs진행하다가 조건맞으면 출력하고 종료하는 걸 생각나서
바로 풀렸네요

비슷한 문제 바로 풀어보러 갑니다

from sys import *
from collections import *

stdin = open('단어 마방진.txt')

L, N = map(int, stdin.readline().split())
words = [stdin.readline().strip() for _ in range(N)]
words.sort()

def check(arr):
    length = len(arr)
    if length == 2:
        if arr[0][1] == arr[1][0]:
            return True
        return False

    for x in range(length):
        for c in range(x + 1, length):
            if arr[x][c] != arr[c][x]:
                return False

    return True

def dfs(result, indices, words):
    if len(indices) == L:
        for r in range(L):
            for c in range(L):
                if result[r][c] != result[c][r]:
                    return
        for word in result:
            print(word)
        exit()

    for i in range(N):
        if i not in indices:
            indices.add(i)

            result.append(words[i])
            dfs(result, indices, words)

            result.pop()
            indices.remove(i)

t_result = deque()
dfs(t_result, set(), words)

print('NONE')

[yuna83]

for perm in permutations(words, L):
permutation에 대해서 까먹고 있었는데 다시 익혀가요..!!
풀이방법에 대해서 완전히 이해하고 있으니 다양한 풀이법을 시도해보는것 짱 멋지십니다!!