28-kokeunho

[kokeunho]

🔗 문제 링크

[BOJ] 스도쿠
https://www.acmicpc.net/problem/2580

✔️ 소요된 시간

1h30m

✨ 수도 코드

백트래킹으로 빈칸을 모두 채우면 그 결과를 출력하도록 하였습니다.

우선 map을 입력 받으면서 빈칸의 좌표를 리스트로 받습니다.

그리고 빈칸 좌표마다 들어갈 수 있는 숫자 리스트를 구합니다.
이때 해당 좌표의 행, 열 뿐만 아니라 좌표가 포함된 3 * 3 박스 내에서도 따져서
해당 좌표에 들어갈 수 있는 숫자 리스트를 뽑아야합니다.
(스도쿠를 잘 안해보고 문제도 제대로 안 읽어서 3*3 박스도 따져야하는지 모르고 있었습니다..)

재귀적으로 sudoku 함수를 호출하다
함수 호출 횟수가 빈칸의 갯수와 같아졌을 경우, 모든 빈칸을 채웠다는 것이므로
그 시점의 map을 출력합니다.

📚 새롭게 알게된 내용

[kangrae-jo]

백트래킹을 이해하고있으면 잘 풀수있는 문제였네요.

저는 제일 처음에 문제를 읽고 사람이 푸는것 마냥 확정된 0을 바꿔놓는 방법을 떠올리려고 했어요.
그 방법은 3분만에 접었습니다.
거의 ai모델 수준의 개발이 필요할 것 같더군요.
그리고 어차피 그런 0이 존재하지 않으면 쓸모없는 행동이 되버기때문이죠.

그 뒤에 생각난 방식이 백트래킹입니다.
bool 배열을 두고 가로 세로 네모를 검사해서 현재 좌표에 놓을 수 있는 녀석들을 넣으며 backtracking 하는 방식이죠

구조는 한 40분 정도에 완성을 했는데, 베이스케이스를 넣지 않았고 그걸 눈치채지 못해서 다른곳만 고치다 시간이 한 15분 흘렀네요.
고치기 전에는 1% 시간초과...엔딩이었습니다.

베이스케이스를 넣어주고 다시 제출해봤습니다.
이번엔 80% 쯤에서 시간초과가 뜨더라구요.

도저히 이유를 모르겠어서 gpt에 넣어봤습니다.
map은 RB Tree여서 삽입속도가 O(1)이 아니라는 것이 문제였네요...
9개 정도면 상관 없을 줄 알았는데...

그래서 map을 vector로 바꾸어주니 바로 성공이었습니다.

#include <iostream>
#include <vector>

using namespace std;

const int EMPTY = 0;
const int N = 9;

vector<vector<int>> board(N, vector<int>(N, EMPTY));

void checkRow(vector<bool>& cannot, int x) {
    for (int y = 0; y < N; y++) {
        cannot[board[y][x]] = true;
    }
}

void checkCol(vector<bool>& cannot, int y) {
    for (int x = 0; x < N; x++) {
        cannot[board[y][x]] = true;
    }
}

void checkSqr(vector<bool>& cannot, int y, int x) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cannot[board[(y / 3) * 3 + i][(x / 3) * 3 + j]] = true;
        }
    }
}

bool backtracking(int y_, int x_) {
    for (int y = y_; y < N; y++) {
        for (int x = 0; x < N; x++) {
            if (board[y][x] == EMPTY) {
                vector<bool> cannot(N + 1, false);  // (y, x)에 놓을 수 없는 수들은 true
                checkRow(cannot, x);
                checkCol(cannot, y);
                checkSqr(cannot, y, x);

                for (int candi = 1; candi <= N; candi++) {
                    if (!cannot[candi]) {
                        board[y][x] = candi;
                        if (backtracking(y, x)) return true;
                        board[y][x] = EMPTY;
                    }
                }
                return false;
            }
        }
    }
    return true;
}

int main() {
    ios_base::sync_with_stdio(0);
    cout.tie(0);
    cin.tie(0);

    for (int y = 0; y < N; y++) {
        for (int x = 0; x < N; x++) {
            cin >> board[y][x];
        }
    }

    backtracking(0, 0);

    cout << endl;
    for (int y = 0; y < N; y++) {
        for (int x = 0; x < N; x++) {
            cout << board[y][x] << " ";
        }
        cout << endl;
    }

    return 0;
}

[9kyo-hwang]

구조가 약간 N-Queen 문제랑 비슷한 것 같아요. 빈 칸에 대해 1부터 9까지 수를 대입해보고, 그게 가능한 지 검사해서 가능하면 true, 아니라면 false. 딱 Promising & Backtracking 구조가 되더라구요 ㅋㅋ

코드

#include <iostream>
#include <array>
#include <vector>

#define EMPTY 0

using namespace std;

vector<pair<int, int>> v;
array<array<int, 9>, 9> arr;

bool Promising(size_t count) {
  const auto &[empty_x, empty_y] = v[count];

  for (int col = 0; col < 9; col++) { // 행에 겹치는 숫자 있는 지 확인
    if ((col != empty_y) && (arr[empty_x][col] == arr[empty_x][empty_y]))
      return false;
  }

  for (int row = 0; row < 9; row++) { // 열에 겹치는 숫자 있는 지 확인
    if ((row != empty_x) && (arr[row][empty_y] == arr[empty_x][empty_y]))
      return false;
  }

  // 구역에 겹치는 숫자 있는 지 확인
  int area_x = empty_x / 3;
  int area_y = empty_y / 3;
  for (int row = area_x * 3; row < area_x * 3 + 3; row++) {
    for (int col = area_y * 3; col < area_y * 3 + 3; col++) {
      if ((row != empty_x) && (col != empty_y) && (arr[empty_x][empty_y] == arr[row][col]))
        return false;
    }
  }

  return true;
}

bool Sudoku(size_t count = 0) {
  if (count == v.size())
    return true;

  const auto &[x, y] = v[count];
  for (int i = 1; i <= 9; i++) {
    arr[x][y] = i;
    if (!Promising(count))
      continue;

    if (Sudoku(count + 1))
      return true;
  }
  arr[x][y] = 0;
  return false;
}

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

  for (int i = 0; i < 9; i++) {
    for (int j = 0; j < 9; j++) {
      cin >> arr[i][j];
      if (arr[i][j] == EMPTY)
        v.emplace_back(i, j);
    }
  }

  if (Sudoku()) {
    for(const auto &i : arr) {
      for(const auto &j : i) {
        cout << j << " ";
      }
      cout << "\n";
    }
  }
  return 0;
}

그런데 이러면 시간이 너무 오래 걸리는 단점이 있습니다. 매 번 9x9 보드에 대해 현재 스도쿠가 완성되었는지 다 훑어보기 때문이죠.

이를 각 행/열/3x3 박스 구간 별로 사용된 숫자를 캐싱하는 식으로 최적화할 수 있습니다.

개선된 코드

#include <bits/stdc++.h>

using namespace std;

constexpr int EMPTY = 0;
int board[9][9];
vector<pair<int, int>> empties;
bool rowUsed[9][10], colUsed[9][10], boxUsed[9][10];

bool dfs(int idx = 0) {
    if(idx == empties.size()) {
        return true;
    }
    
    const auto& [r, c] = empties[idx];
    int b = (r / 3) * 3 + c / 3;
    for(int num = 1; num <= 9; ++num) {
        if(rowUsed[r][num] || colUsed[c][num] || boxUsed[b][num]) {
            continue;
        }
        
        board[r][c] = num;
        rowUsed[r][num] = colUsed[c][num] = boxUsed[b][num] = true;
        
        if(dfs(idx + 1)) {
            return true;
        }
        
        rowUsed[r][num] = colUsed[c][num] = boxUsed[b][num] = false;
        board[r][c] = EMPTY;
    }
    
    return false;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    for(int i = 0; i < 9; ++i) {
        for(int j = 0; j < 9; ++j) {
            cin >> board[i][j];
            if(board[i][j] == 0) {
                empties.emplace_back(i, j);
            } else {
                int num = board[i][j];
                rowUsed[i][num] = true;
                colUsed[j][num] = true;
                boxUsed[(i / 3) * 3 + j / 3][num] = true;
            }
        }
    }
    
    dfs();
    
    for(int i = 0; i < 9; ++i) {
        for(int j = 0; j < 9; ++j) {
            cout << board[i][j] << " ";
        }
        cout << "\n";
    }

    return 0;
}

---

GPT가 되게 독특한 방법을 소개해줬는데 뭔가 많이 독특한 기법이라 궁금하신 분은 읽어보셔도...?

비트마스킹 + MRV

#include <bits/stdc++.h>
using namespace std;

// 9×9 스도쿠
int board[9][9];
// 행, 열, 블록별로 사용된 숫자를 비트마스크로 관리
// 마스크의 비트 k(1≤k≤9)가 1이면 숫자 k가 이미 사용된 상태
int rowMask[9], colMask[9], boxMask[9];
// 빈 칸 좌표 목록
vector<pair<int,int>> empties;

// 재귀 탐색: filled개를 채운 상태에서 나머지를 채우는 함수
bool solve(int filled = 0) {
    if (filled == (int)empties.size())
        return true;  // 모두 채웠으면 성공

    // MRV: 남은 후보가 가장 적은 칸을 찾아서 앞으로 가져온다
    int best = -1, minCount = 10;
    for (int i = filled; i < (int)empties.size(); ++i) {
        auto [r, c] = empties[i];
        int b = (r/3)*3 + c/3;
        int avail = ~(rowMask[r] | colMask[c] | boxMask[b]) & 0x3FE;
        int cnt = __builtin_popcount(avail);
        if (cnt < minCount) {
            minCount = cnt;
            best = i;
            if (cnt == 0) break;  // 후보가 없으면 바로 실패
        }
    }
    if (minCount == 0) return false;

    // 후보 적은 칸을 filled 위치로 스왑
    swap(empties[filled], empties[best]);
    auto [r, c] = empties[filled];
    int b = (r/3)*3 + c/3;
    int avail = ~(rowMask[r] | colMask[c] | boxMask[b]) & 0x3FE;

    // 가능한 숫자 하나씩 시도
    while (avail) {
        int bit = avail & -avail;             // 가장 낮은 비트
        int d   = __builtin_ctz(bit);         // 그 비트의 인덱스 = 숫자
        avail ^= bit;

        // 숫자 d를 놓는다
        board[r][c] = d;
        rowMask[r] |= bit;
        colMask[c] |= bit;
        boxMask[b] |= bit;

        if (solve(filled+1))
            return true;

        // backtrack
        rowMask[r] ^= bit;
        colMask[c] ^= bit;
        boxMask[b] ^= bit;
        board[r][c] = 0;
    }

    // 원위치 복구
    swap(empties[filled], empties[best]);
    return false;
}

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

    // 입력과 초기 마스크 설정
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            cin >> board[i][j];
            if (board[i][j]) {
                int bit = 1 << board[i][j];
                rowMask[i] |= bit;
                colMask[j] |= bit;
                boxMask[(i/3)*3 + j/3] |= bit;
            } else {
                empties.emplace_back(i, j);
            }
        }
    }

    solve();

    // 결과 출력
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            cout << board[i][j] << ' ';
        }
        cout << "\n";
    }
    return 0;
}

---

심지어 크누스 X 라는 알고리즘을 사용하면 극한으로 빠르게 해결할 수 있다고 하는데 읽다보니 어지러워서 전 포기했습니다 ㅋㅋ...

[wnsmir]

근호님 문제를 보면 백트래킹 혹은 완전탐색문제가 많은것 같습니다.
제가 재귀부분이 약한데 덕분에 도움이 많이 됩니다 ㅠㅜ

처음에는 빈칸마다 1부터 9까지 다 넣어보는식으로 했다가 메모리초과나서
남은 후보가 적은 칸부터 넣어보도록 집합을 이용해서 분기를 최소화했습니다.

import sys
input = sys.stdin.readline

# 1) 입력 받으면서 board, rows, cols, boxes, empties 구성
board = [list(map(int, input().split())) for _ in range(9)]
rows = [set(range(1,10)) for _ in range(9)]
cols = [set(range(1,10)) for _ in range(9)]
boxes= [set(range(1,10)) for _ in range(9)]
empties = []

for r in range(9):
    for c in range(9):
        v = board[r][c]
        if v:
            rows[r].remove(v)
            cols[c].remove(v)
            boxes[(r//3)*3 + (c//3)].remove(v)
        else:
            empties.append((r,c))

# 2) DFS 함수: 빈 칸이 없으면 True 반환
def dfs():
    if not empties:
        return True

    # 남은 빈 칸 중 후보 수가 가장 적은 칸을 선택
    best = min(
        empties,
        key=lambda x: len(rows[x[0]] & cols[x[1]] & boxes[(x[0]//3)*3 + (x[1]//3)])
    )
    r, c = best
    b = (r//3)*3 + (c//3)
    candidates = rows[r] & cols[c] & boxes[b]  # 후보 숫자 집합

    if not candidates:
        return False

    empties.remove(best)
    for v in candidates:
        # 배치
        board[r][c] = v
        rows[r].remove(v)
        cols[c].remove(v)
        boxes[b].remove(v)

        if dfs():
            return True

        # 되돌리기
        board[r][c] = 0
        rows[r].add(v)
        cols[c].add(v)
        boxes[b].add(v)

    empties.append(best)
    return False

# 3) 실행 및 출력
dfs()
out = []
for row in board:
    out.append(" ".join(map(str, row)))
sys.stdout.write("\n".join(out))

[g0rnn]

문제를 잘 안풀다보니 백트레킹이 좀 어려워졌네요.. 예전엔 머리 속에 백트레킹만 떠오르던 시절이 있었는데.. 허허

근데 문제가 재밌었습니다. 백트레킹을 좀 재밌게 사용하는 느낌이네요.

근호님과 다른분들은 캐싱을 사용하여 속도를 높인거 같은데, 전 모든 칸을 확인했습니다. 만약 0이 아니라면 다음 칸으로 넘어가고, 그렇게 모든 칸을 순회한다면 종료하도록 하였습니다. 모든 칸을 순회하고 x와 y가 범위 밖으로 넘어갔을 땐 스도쿠를 올바르게 채웠다는 의미이므로 true를 반환합니다.

package beakjoon;

import java.io.*;
import java.util.*;

public class Sol2580 {

    static int[][] board = new int[9][9];

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        for (int i = 0; i < 9; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < 9; j++) {
                board[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        backtracking(0, 0);

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                sb.append(board[i][j]).append(" ");
            }
            sb.append("\n");
        }
        System.out.print(sb.toString());
    }

    private static boolean backtracking(int x, int y) {
        if (x == 9) {  // 한 줄 끝나면 다음 줄로
            x = 0;
            y++;
            if (y == 9) return true;  // 모든 칸을 다 채운 경우
        }

        if (board[y][x] != 0) {
            return backtracking(x + 1, y);  // 이미 채워진 칸이면 다음 칸으로
        }

        for (int num = 1; num <= 9; num++) {
            if (isValid(y, x, num)) {
                board[y][x] = num;
                if (backtracking(x + 1, y)) return true;
                board[y][x] = 0;
            }
        }

        return false;
    }

    // 현재 위치에 num을 넣을 수 있는지 검사
    private static boolean isValid(int y, int x, int num) {
        // 같은 행
        for (int i = 0; i < 9; i++) {
            if (board[y][i] == num) return false;
        }

        // 같은 열
        for (int i = 0; i < 9; i++) {
            if (board[i][x] == num) return false;
        }

        // 같은 3x3 박스
        int startY = (y / 3) * 3;
        int startX = (x / 3) * 3;
        for (int i = startY; i < startY + 3; i++) {
            for (int j = startX; j < startX + 3; j++) {
                if (board[i][j] == num) return false;
            }
        }

        return true;
    }
}