๋ฌธ์ ์ค๋ช
0๊ณผ 1๋ก ์ด๋ฃจ์ด์ง 2n x 2n ํฌ๊ธฐ์ 2์ฐจ์ ์ ์ ๋ฐฐ์ด arr์ด ์์ต๋๋ค. ๋น์ ์ ์ด arr์ ์ฟผ๋ ํธ๋ฆฌ์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์์ถํ๊ณ ์ ํฉ๋๋ค. ๊ตฌ์ฒด์ ์ธ ๋ฐฉ์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ๋น์ ์ด ์์ถํ๊ณ ์ ํ๋ ํน์ ์์ญ์ S๋ผ๊ณ ์ ์ํฉ๋๋ค.
- ๋ง์ฝ S ๋ด๋ถ์ ์๋ ๋ชจ๋ ์๊ฐ ๊ฐ์ ๊ฐ์ด๋ผ๋ฉด, S๋ฅผ ํด๋น ์ ํ๋๋ก ์์ถ์ํต๋๋ค.
- ๊ทธ๋ ์ง ์๋ค๋ฉด, S๋ฅผ ์ ํํ 4๊ฐ์ ๊ท ์ผํ ์ ์ฌ๊ฐํ ์์ญ(์ ์ถ๋ ฅ ์๋ฅผ ์ฐธ๊ณ ํด์ฃผ์๊ธฐ ๋ฐ๋๋๋ค.)์ผ๋ก ์ชผ๊ฐ ๋ค, ๊ฐ ์ ์ฌ๊ฐํ ์์ญ์ ๋ํด ๊ฐ์ ๋ฐฉ์์ ์์ถ์ ์๋ํฉ๋๋ค.
arr์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์์ ๊ฐ์ ๋ฐฉ์์ผ๋ก arr์ ์์ถํ์ ๋, ๋ฐฐ์ด์ ์ต์ข ์ ์ผ๋ก ๋จ๋ 0์ ๊ฐ์์ 1์ ๊ฐ์๋ฅผ ๋ฐฐ์ด์ ๋ด์์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- arr์ ํ์ ๊ฐ์๋ 1 ์ด์ 1024 ์ดํ์ด๋ฉฐ, 2์ ๊ฑฐ๋ญ ์ ๊ณฑ์ ํํ๋ฅผ ํ๊ณ ์์ต๋๋ค. ์ฆ, arr์ ํ์ ๊ฐ์๋ 1, 2, 4, 8, ..., 1024 ์ค ํ๋์
๋๋ค.
- arr์ ๊ฐ ํ์ ๊ธธ์ด๋ arr์ ํ์ ๊ฐ์์ ๊ฐ์ต๋๋ค. ์ฆ, arr์ ์ ์ฌ๊ฐํ ๋ฐฐ์ด์ ๋๋ค.
- arr์ ๊ฐ ํ์ ์๋ ๋ชจ๋ ๊ฐ์ 0 ๋๋ 1 ์ ๋๋ค.
์ ์ถ๋ ฅ ์
arr | result |
---|---|
[[1,1,0,0],[1,0,0,0],[1,0,0,1],[1,1,1,1]] |
[4,9] |
[[1,1,1,1,1,1,1,1],[0,1,1,1,1,1,1,1],[0,0,0,0,1,1,1,1],[0,1,0,0,1,1,1,1],[0,0,0,0,0,0,1,1],[0,0,0,0,0,0,0,1],[0,0,0,0,1,0,0,1],[0,0,0,0,1,1,1,1]] |
[10,15] |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ๋ค์ ๊ทธ๋ฆผ์ ์ฃผ์ด์ง arr์ ์์ถํ๋ ๊ณผ์ ์ ๋ํ๋ธ ๊ฒ์ ๋๋ค.
- ์ต์ข
์์ถ ๊ฒฐ๊ณผ์ 0์ด 4๊ฐ, 1์ด 9๊ฐ ์์ผ๋ฏ๋ก,
[4,9]
๋ฅผ return ํด์ผ ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ๋ค์ ๊ทธ๋ฆผ์ ์ฃผ์ด์ง arr์ ์์ถํ๋ ๊ณผ์ ์ ๋ํ๋ธ ๊ฒ์ ๋๋ค.
- ์ต์ข
์์ถ ๊ฒฐ๊ณผ์ 0์ด 10๊ฐ, 1์ด 15๊ฐ ์์ผ๋ฏ๋ก,
[10,15]
๋ฅผ return ํด์ผ ํฉ๋๋ค.
ํ์ด๋ฅผ ์ํ ์ฟผ๋ ํธ๋ฆฌ ๊ฐ๋ ์ ๋ฆฌ
๐ก ์ฟผ๋ ํธ๋ฆฌ(Quad Tree)๋?
- ๋ฐ์ดํฐ๋ฒ ์ด์ค ๊ฒ์์ ์ฌ์ฉ๋๋ ํธ๋ฆฌ๊ตฌ์กฐ์ด๋ค. ํญ์ ํ๋์ ๋ ธ๋์ 4๊ฐ์ ๊ฐ์ง๋ก ๊ตฌ์ฑ๋๋ ํธ๋ฆฌ ๊ตฌ์กฐ๋ก์ ๊ตฌํ๋ ๋ ์ฝ๋๊ฐ ๋ํ๋ ๋๊น์ง ๊ณ์ 4๊ฐ๋ก ๋ฑ๋ถํด์ ๊ฒ์์ด ํํด์ง๋ค.
- ํ๋ง๋๋ก ๋ฌธ์ ์์ ์์ ๊ทธ๋ฆผ์ฒ๋ผ 4๋ถํ ์ด ์ฌ๊ท์ ์ผ๋ก ์ด๋ค์ง๋ฉด์ ๊ฒ์์ด ํํด์ง๋ค.
๋ฌธ์ ํ์ด ์ ๋ต
class Solution {
static int[] answer;
public int[] solution(int[][] arr) {
answer = new int[2];
quadTree(arr,0,0,arr.length);
return answer;
}
public void quadTree(int[][] arr,int x, int y, int size) {
// ๊ฐ์ ์ซ์์ผ ๋ ์นด์ดํ
if (sameNumber(arr, x, y, size)) {
// arr[x][y] == 0 or 1
answer[arr[x][y]]++;
return;
}
// ์ซ์๊ฐ ๋ค๋ฅด๋ฉด ๋ค์ ๋ถํ ํ์ฌ ๊ฒ์
else {
int halfSize = size / 2;
quadTree(arr,x, y, halfSize); //์ผ์ชฝ ์
quadTree(arr,x, y + halfSize, halfSize);//์ค๋ฅธ์ชฝ ์
quadTree(arr,x + halfSize, y, halfSize);//์ผ์ชฝ ์๋
quadTree(arr,x + halfSize, y + halfSize, halfSize);//์ค๋ฅธ์ชฝ ์๋
}
}
// ๊ฐ์ ์ซ์์ธ์ง ํ๋ณ
public boolean sameNumber(int[][] arr,int x, int y, int size){
for (int i = x; i < x+size; i++){
for (int j = y; j< y+size; j++){
// ๊ฐ์ง ์์ ๋ ๋ฐ๋ก ๋ฐ๋ณต๋ฌธ์ ๋๊ฐ์ผ ์ธ๋ฐ์๋ ๋ฐ๋ณตํ์๋ฅผ ์ค์ธ๋ค
if (arr[x][y] != arr[i][j]){
return false;
}
}
}
return true;
}
}
์ฟผ๋์์ถ ํ ๊ฐ์ ์ธ๊ธฐ ์ฟผ๋์์ถ ํ ๊ฐ์ ์ธ๊ธฐ ์ฟผ๋์์ถ ํ ๊ฐ์ ์ธ๊ธฐ ์ฟผ๋์์ถ ํ ๊ฐ์ ์ธ๊ธฐ ์ฟผ๋์์ถ ํ ๊ฐ์ ์ธ๊ธฐ