2023. 5. 1. 16:28ใCoding Test/BOJ
๐๋ฌธ์ ๋ณด๋ฌ๊ฐ๊ธฐ
๋ฌธ์ ์ค๋ช
N-Queen ๋ฌธ์ ๋ ํฌ๊ธฐ๊ฐ N × N์ธ ์ฒด์คํ ์์ ํธ N๊ฐ๋ฅผ ์๋ก ๊ณต๊ฒฉํ ์ ์๊ฒ ๋๋ ๋ฌธ์ ์ด๋ค.
N์ด ์ฃผ์ด์ก์ ๋, ํธ์ ๋๋ ๋ฐฉ๋ฒ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค. (1 ≤ N < 15)
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ํธ N๊ฐ๋ฅผ ์๋ก ๊ณต๊ฒฉํ ์ ์๊ฒ ๋๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์ ์ ์ถ๋ ฅ
ํ์ด ์ ๋ต
\( N \times N\) ์ฒด์คํ์์ ํธ์ด ์๋ก ๊ณต๊ฒฉ์ ํ์ง ๋ชปํ๊ฒ ๋๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์ ๋๋ค.
ํธ์ ์์ ์ด ๋์ธ ์์น๋ก๋ถํฐ ๊ฐ์ ์ผ์ ์ ์ ๋ฐ ๋๊ฐ์ ์๊น์ง ๊ณต๊ฒฉํ ์ ์๋ ์ฌ๊ธฐ ์ฒด์ค๋ง์ ๋๋ค. (๊ทธ์ ๋นํด ํน์...)
์ฆ, ํธ์ด ๋์ธ ์์น๊ฐ ๋ค์๊ณผ ๊ฐ๋ค๋ฉด, ๋นจ๊ฐ์์ผ๋ก ์น ํด์ง ์์น๋ ํผํด์ผ ํฉ๋๋ค.
๊ทธ๋ ๊ธฐ์, ํธ์ ๋์ ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ค๋ฉด ํ์ฌ ์ขํ์ ํธ์ ๋์์ ๋ ํธ ๊ณต๊ฒฉ๋ก ์์ ๋ ๋ค๋ฅธ ํธ์ด ์๋์ง ๊ฒ์ฌํ๋ ๊ฒ ํ์ํฉ๋๋ค. ์ฌ์ค์ ์ํ์ข์ฐ, ์ผ์ ๋๊ฐ, ์ผ์๋ ๋๊ฐ, ์ค๋ฅธ์ ๋๊ฐ, ์ค๋ฅธ์๋ ๋๊ฐ ์ด๋ ๊ฒ ์ด 8๊ฐ์ ๊ณต๊ฒฉ๋ก๊ฐ ์กด์ฌํ์ฃ .
์ฒ์์๋ ์ ๋ ๊ฒ 8๋ฐฉํฅ์ ๋ชจ๋ ๊ฒ์ฌํ๋ ์ฝ๋๋ฅผ ์งฐ์๋๋ฐ, ์ด๋ ๊ฒ ๋๋ฉด ์๊ฐ ์ด๊ณผ๊ฐ ๋ฐ์ํ๋๋ผ๊ตฌ์.
๊ทธ๋์ ์๊ฐ์ ์ค์ผ ์ ์๋ ๋ฐฉ์์ ๋ ์์๋ณด์์ต๋๋ค.
์๊ฐ ์์๋ฅผ ์ค์ด๊ธฐ ์ํ ๋ฐฉ์๋ค
์ ๋ (0, 0)์์ ์์ํ์ฌ ์ด(Column)์ ์ฐ์ ์ผ๋ก ํ์ํ๋ ๋ฐฉ์์ผ๋ก ์งํํ์ต๋๋ค.
์๋ฅผ ๋ค์ด, 4 X 4 ์ฒด์คํ์ด๋ผ๋ฉด, (0, 0) -> (0, 1) -> (0, 2) -> (0, 3) -> (2, 0) ... ์ด๋ฐ ์์ผ๋ก ์ด์ ๋จผ์ ๊ฒ์ฌํ๋ค๋ ์๋ฏธ์
๋๋ค.
๊ฒ์ฌํ๋ ๋ฐฉ์์ด ์ด๋ฌํ๋ค๋ฉด, ๋ค์ ์ฌํญ๋ค์ ๊ณ ๋ คํด๋ณผ ์ ์์ต๋๋ค.
- ํ ํ(Row)์ ์๋ ์ด(Column)๋ค ์ค ์ด๋ค ๊ณณ์ด๋ผ ํธ์ ํ๋ ๋ฐฐ์นํ๋ค๋ฉด, ๊ทธ ํ์๋ ๋ ์ด์ ํธ์ ๋ฐฐ์นํ ์ ์๋ค.
- ์ฆ, ํด๋น ํ์ ํธ์ ๋ฐฐ์นํ๋ค๋ฉด ๋ค์ ํ์ผ๋ก ๋์ด๊ฐ์ ํ์์ ์์ํ๋ค.
- ์ฒด์คํ ์์ชฝ๋ถํฐ ํธ ๋ฐฐ์น๋ฅผ ์์ํ๋ฏ๋ก, ์๋์ชฝ ๋ฐฉํฅ ํ์์ ํ ํ์๊ฐ ์๋ค.
- ์ฒด์คํ ์์ชฝ๋ถํฐ ํธ ๋ฐฐ์น๋ฅผ ํ๋ฏ๋ก, ์ฒด์คํ ์๋์ชฝ์๋ ๋น์ฐํ ํธ์ด ์์ผ๋ ํ์์ ํ ํ์๊ฐ ์๋ค.
- ์ฆ, ํ์ ๋ฐฉํฅ์ ์, ์ผ์ชฝ ์ ๋๊ฐ, ์ค๋ฅธ์ชฝ ์ ๋๊ฐ ์ด๋ ๊ฒ ์ธ ๊ตฐ๋ฐ๋ง ํ์ํ๋ฉด ๋๋ค.
์ด์ ๋ฐฑํธ๋ํน(Backtracking)์ ์งํํ๋ฉฐ, ์ ๊ณผ์ ๋ค์ ๋ฐ๋ณตํ๋ฉด ๋ฉ๋๋ค. ์๋ฎฌ๋ ์ด์ ๊ณผ์ ์ ํ ๋ฒ ์ฒจ๋ถํด๋ดค์ต๋๋ค.
์์ค ์ฝ๋ ๋ฐ ๊ฒฐ๊ณผ
#include <iostream>
#include <vector>
using namespace std;
bool CheckQueenExisting(vector<vector<bool>>& chessBoard, int row, int column) {
for (int i = 0; i < row; i++) {
if (chessBoard[i][column]) // ๋งจ ์ ํ๋ถํฐ ํ์ฌ ํ๊น์ง ๊ฐ์ ์ด์ ํธ ์๋์ง ๊ฒ์ฌ
return true;
int colDiff = row - i;
if (column - colDiff >= 0 && chessBoard[i][column - colDiff]) // ์ผ์ชฝ ์ ๋๊ฐ์ ๊ฒ์ฌ
return true;
if (column + colDiff < chessBoard.size() && chessBoard[i][column + colDiff]) // ์ค๋ฅธ์ชฝ ์ ๋๊ฐ์ ๊ฒ์ฌ
return true;
}
return false;
}
int NQueen(vector<vector<bool>>& chessBoard, int currentRow) {
if (currentRow == chessBoard.size())
return 1;
int answer = 0;
for (int column = 0; column < chessBoard.size(); column++) {
if (!CheckQueenExisting(chessBoard, currentRow, column)) {
chessBoard[currentRow][column] = true;
answer += NQueen(chessBoard, currentRow + 1);
chessBoard[currentRow][column] = false;
}
}
return answer;
}
int main() {
cout.tie(NULL);
cin.tie(NULL);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<vector<bool>> chessBoard(N, vector<bool>(N, false));
cout << NQueen(chessBoard, 0);
return 0;
}
'Coding Test > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] 1003๋ฒ | ํผ๋ณด๋์น ํจ์ (C++) (0) | 2023.08.21 |
---|---|
[BOJ] 11726๋ฒ | 2xn ํ์ผ๋ง (C++) (0) | 2023.08.21 |
[BOJ] 1018๋ฒ | ์ฒด์คํ ๋ค์ ์น ํ๊ธฐ (C++) (0) | 2023.04.13 |
[BOJ] 10757๋ฒ | ํฐ ์ A+B (C++) (0) | 2023.04.08 |
[BOJ] 2869๋ฒ | ๋ฌํฝ์ด๋ ์ฌ๋ผ๊ฐ๊ณ ์ถ๋ค (C++) (0) | 2023.04.07 |