2023. 4. 13. 19:47ใCoding Test/BOJ
๐๋ฌธ์ ๋ณด๋ฌ๊ฐ๊ธฐ
๋ฌธ์ ์ค๋ช
์ง๋ฏผ์ด๋ ์์ ์ ์ ํ์์ MN๊ฐ์ ๋จ์ ์ ์ฌ๊ฐํ์ผ๋ก ๋๋์ด์ ธ ์๋ M×N ํฌ๊ธฐ์ ๋ณด๋๋ฅผ ์ฐพ์๋ค. ์ด๋ค ์ ์ฌ๊ฐํ์ ๊ฒ์์์ผ๋ก ์น ํด์ ธ ์๊ณ , ๋๋จธ์ง๋ ํฐ์์ผ๋ก ์น ํด์ ธ ์๋ค. ์ง๋ฏผ์ด๋ ์ด ๋ณด๋๋ฅผ ์๋ผ์ 8×8 ํฌ๊ธฐ์ ์ฒด์คํ์ผ๋ก ๋ง๋ค๋ ค๊ณ ํ๋ค.
์ฒด์คํ์ ๊ฒ์์๊ณผ ํฐ์์ด ๋ฒ๊ฐ์์ ์น ํด์ ธ ์์ด์ผ ํ๋ค. ๊ตฌ์ฒด์ ์ผ๋ก, ๊ฐ ์นธ์ด ๊ฒ์์๊ณผ ํฐ์ ์ค ํ๋๋ก ์์น ๋์ด ์๊ณ , ๋ณ์ ๊ณต์ ํ๋ ๋ ๊ฐ์ ์ฌ๊ฐํ์ ๋ค๋ฅธ ์์ผ๋ก ์น ํด์ ธ ์์ด์ผ ํ๋ค. ๋ฐ๋ผ์ ์ด ์ ์๋ฅผ ๋ฐ๋ฅด๋ฉด ์ฒด์คํ์ ์์น ํ๋ ๊ฒฝ์ฐ๋ ๋ ๊ฐ์ง๋ฟ์ด๋ค. ํ๋๋ ๋งจ ์ผ์ชฝ ์ ์นธ์ด ํฐ์์ธ ๊ฒฝ์ฐ, ํ๋๋ ๊ฒ์์์ธ ๊ฒฝ์ฐ์ด๋ค.
๋ณด๋๊ฐ ์ฒด์คํ์ฒ๋ผ ์น ํด์ ธ ์๋ค๋ ๋ณด์ฅ์ด ์์ด์, ์ง๋ฏผ์ด๋ 8×8 ํฌ๊ธฐ์ ์ฒด์คํ์ผ๋ก ์๋ผ๋ธ ํ์ ๋ช ๊ฐ์ ์ ์ฌ๊ฐํ์ ๋ค์ ์น ํด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค. ๋น์ฐํ 8*8 ํฌ๊ธฐ๋ ์๋ฌด๋ฐ์๋ ๊ณจ๋ผ๋ ๋๋ค. ์ง๋ฏผ์ด๊ฐ ๋ค์ ์น ํด์ผ ํ๋ ์ ์ฌ๊ฐํ์ ์ต์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N๊ณผ M์ด ์ฃผ์ด์ง๋ค. N๊ณผ M์ 8๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 50๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ๋ณด๋์ ๊ฐ ํ์ ์ํ๊ฐ ์ฃผ์ด์ง๋ค. B๋ ๊ฒ์์์ด๋ฉฐ, W๋ ํฐ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ง๋ฏผ์ด๊ฐ ๋ค์ ์น ํด์ผ ํ๋ ์ ์ฌ๊ฐํ ๊ฐ์์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.
์์ ์ ์ถ๋ ฅ
ํ์ด ์ ๋ต
๋ธ๋ฃจํธ ํฌ์ค๋ก ํ ์ ์๋ ๋ฌธ์ ์ ๋๋ค. \(8 \times 8\) ์ฒด์คํ์ ๋ง๋ค๊ธฐ ์ํด, ์๊น์ ๋ฐ๊ฟ ์น ํด์ผ ํ๋ ์ต์์ ๊ฒฝ์ฐ๋ฅผ ๊ตฌํด์ผ ํ๋ ๋ฌธ์ ์ธ๋ฐ, ํ(๊ฐ๋ก)์์ ์ด์ ์๊น๊ณผ ๋ค์ ์๊น์ด ๊ฐ์ผ๋ฉด ์ ๋๊ณ , ์ด(์ธ๋ก)์์๋ ๊ฐ์ผ๋ฉด ์ ๋ฉ๋๋ค.
์ ๋ ๋ค์๊ณผ ๊ฐ์ ๊ท์น์ ์ธ์ ๋ฌธ์ ๋ฅผ ํ์์ต๋๋ค.
- ๊ฐ๋ก๋ก ํ ์นธ์ฉ ์ํํ๋ฉด์, ์ด์ ์๊น๊ณผ ํ์ฌ ๋ณด๊ณ ์๋ ์นธ์ ์๊น์ด ๊ฐ์ ๊ฒฝ์ฐ ์นด์ดํธ ์ฆ๊ฐ
- ๋ค์ ํ์ผ๋ก ๋์ด๊ฐ ๊ฒฝ์ฐ, ์ฒซ ๋ฒ์งธ ์์์ด ์ด์ ํ์ ์ฒซ ๋ฒ์งธ ์์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ ์นด์ดํธ ์ฆ๊ฐ
BWBWBWBW // ๋ง์ง๋ง์ผ๋ก ์ ์ฅ๋ ์ด์ ์๊น์ W
WBWBWBWB // 1๋ฒํ์ ์ฒซ ๋ฒ์งธ ์๊น(B)์ ๋ค๋ฅธ ์์ด์ด์ผ ํ๋ค. (์ฆ, ์ด์ ํ์ ๋ง์ง๋ง ์๊น์ ์๊ณผ ๊ฐ์์ผํจ)
........
- ์ฒด์ค์ ์์ ์์(์ ์ผ ์ผ์ชฝ ์)์ด ๋ค๋ฅธ ์์ผ ๊ฒฝ์ฐ์๋ ์๋ฎฌ๋ ์ด์ ์งํ
- ์ ๋ถ ์ํ ํ, ๊ฐ์ฅ ์ต์์ ๊ฒฝ์ฐ์ ์นด์ดํธ๋ง ์ ์ฅ ํ ์ถ๋ ฅ
์์ค ์ฝ๋ ๋ฐ ๊ฒฐ๊ณผ
#include <iostream>
#include <vector>
#include <map>
#include <string>
using namespace std;
void Search(const vector<string>& field, int startRowIdx, int startColumnIdx, const int chessboardSize, int& minCount)
{
const int MAX_ROW = field.size();
const int MAX_COLUMN = field[0].length();
if (startRowIdx + chessboardSize > MAX_ROW || startColumnIdx + chessboardSize > MAX_COLUMN)
return;
map<char, char> getOtherColor{ {'W', 'B'}, {'B', 'W'} };
for (int testCase = 0; testCase < 2; testCase++)
{
int replaceNums = (testCase == 0) ? 0 : 1;
char preColor = (testCase == 0) ? field[startRowIdx][startColumnIdx] : getOtherColor[field[startRowIdx][startColumnIdx]];
for (int row = startRowIdx; row < startRowIdx + chessboardSize; row++)
{
string compare = field[row];
int startIdx = (row == startRowIdx) ? startColumnIdx + 1 : startColumnIdx;
for (int column = startIdx; column < startColumnIdx + chessboardSize; column++)
{
if (preColor == compare[column])
{
replaceNums++;
preColor = getOtherColor[compare[column]];
continue;
}
preColor = compare[column];
}
preColor = getOtherColor[preColor];
}
if (replaceNums < minCount)
minCount = replaceNums;
}
}
int main()
{
cin.tie(NULL);
ios::sync_with_stdio(false);
const int chessboardSize = 8;
int rowNum, columnNum;
cin >> rowNum >> columnNum;
vector<string> field;
for (int i = 0; i < rowNum; i++)
{
string row;
cin >> row;
field.push_back(row);
}
int answer = 2147483647;
for (int i = 0; i < rowNum; i++)
for (int j = 0; j < columnNum; j++)
Search(field, i, j, chessboardSize, answer);
cout << answer;
return 0;
}
'Coding Test > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] 11726๋ฒ | 2xn ํ์ผ๋ง (C++) (0) | 2023.08.21 |
---|---|
[BOJ] 9663๋ฒ | N-Queen (C++) (0) | 2023.05.01 |
[BOJ] 10757๋ฒ | ํฐ ์ A+B (C++) (0) | 2023.04.08 |
[BOJ] 2869๋ฒ | ๋ฌํฝ์ด๋ ์ฌ๋ผ๊ฐ๊ณ ์ถ๋ค (C++) (0) | 2023.04.07 |
[BOJ] 11404๋ฒ | ํ๋ก์ด๋ (Python3) (0) | 2022.09.15 |