๐ฅ2022.05.30
https://programmers.co.kr/learn/courses/30/lessons/1829?language=java
์นด์นด์ค ํ๋ ์ฆ ์ปฌ๋ฌ๋ง๋ถ
์ถํ์ฌ์ ํธ์ง์์ธ ์ดํผ์น๋ ๋ค์ค์๊ฒ ์ปฌ๋ฌ๋ง๋ถ์ ๋ค์ด๊ฐ ์ํ๋ฅผ ๊ทธ๋ ค๋ฌ๋ผ๊ณ ๋ถํํ์ฌ ์ฌ๋ฌ ์ฅ์ ๊ทธ๋ฆผ์ ๋ฐ์๋ค. ์ฌ๋ฌ ์ฅ์ ๊ทธ๋ฆผ์ ๋์ด๋ ์์ผ๋ก ์ปฌ๋ฌ๋ง๋ถ์ ๋ฃ๊ณ ์ถ์๋ ์ดํผ์น๋ ์์ญ์ด ๋ง์ผ๋ฉด ์์น ํ๊ธฐ๊ฐ ๊น๋ค๋ก์ ์ด๋ ค์์ง๋ค๋ ์ฌ์ค์ ๋ฐ๊ฒฌํ๊ณ ๊ทธ๋ฆผ์ ๋์ด๋๋ฅผ ์์ญ์ ์๋ก ์ ์ํ์๋ค. (์์ญ์ด๋ ์ํ์ข์ฐ๋ก ์ฐ๊ฒฐ๋ ๊ฐ์ ์์์ ๊ณต๊ฐ์ ์๋ฏธํ๋ค.)
๊ทธ๋ฆผ์ ๋ช ๊ฐ์ ์์ญ์ด ์๋์ง์ ๊ฐ์ฅ ํฐ ์์ญ์ ๋์ด๋ ์ผ๋ง์ธ์ง ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์์ ๊ทธ๋ฆผ์ ์ด 12๊ฐ ์์ญ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ๊ฐ์ฅ ๋์ ์์ญ์ ์ดํผ์น์ ์ผ๊ตด๋ฉด์ผ๋ก ๋์ด๋ 120์ด๋ค.
์ ๋ ฅ ํ์
์ ๋ ฅ์ ๊ทธ๋ฆผ์ ํฌ๊ธฐ๋ฅผ ๋ํ๋ด๋ m๊ณผ n, ๊ทธ๋ฆฌ๊ณ ๊ทธ๋ฆผ์ ๋ํ๋ด๋ m × n ํฌ๊ธฐ์ 2์ฐจ์ ๋ฐฐ์ด picture๋ก ์ฃผ์ด์ง๋ค. ์ ํ์กฐ๊ฑด์ ์๋์ ๊ฐ๋ค.
- 1 <= m, n <= 100
- picture์ ์์๋ 0 ์ด์ 2^31 - 1 ์ดํ์ ์์์ ๊ฐ์ด๋ค.
- picture์ ์์ ์ค ๊ฐ์ด 0์ธ ๊ฒฝ์ฐ๋ ์์น ํ์ง ์๋ ์์ญ์ ๋ปํ๋ค.
์ถ๋ ฅ ํ์
๋ฆฌํด ํ์ ์ ์์๊ฐ ๋ ๊ฐ์ธ ์ ์ ๋ฐฐ์ด์ด๋ค. ๊ทธ๋ฆผ์ ๋ช ๊ฐ์ ์์ญ์ด ์๋์ง์ ๊ฐ์ฅ ํฐ ์์ญ์ ๋ช ์นธ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋์ง๋ฅผ ๋ฆฌํดํ๋ค.
์์ ์ ์ถ๋ ฅ
mnpictureanswer6 | 4 | [[1, 1, 1, 0], [1, 2, 2, 0], [1, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 3], [0, 0, 0, 3]] | [4, 5] |
์์ ์ ๋ํ ์ค๋ช
์์ ๋ก ์ฃผ์ด์ง ๊ทธ๋ฆผ์ ์ด 4๊ฐ์ ์์ญ์ผ๋ก ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ, ์ผ์ชฝ ์์ ์์ญ๊ณผ ์ค๋ฅธ์ชฝ์ ์์ญ์ ๋ชจ๋ 1๋ก ๊ตฌ์ฑ๋์ด ์์ง๋ง ์ํ์ข์ฐ๋ก ์ด์ด์ ธ์์ง ์์ผ๋ฏ๋ก ๋ค๋ฅธ ์์ญ์ด๋ค. ๊ฐ์ฅ ๋์ ์์ญ์ ์ผ์ชฝ ์ 1์ด ์ฐจ์งํ๋ ์์ญ์ผ๋ก ์ด 5์นธ์ด๋ค.
๐ฅ [๋ก์ง]
๋ด๊ฐ ๋ฌธ์ ๋ฅผ ์ ์ดํด๋ฅผ ๋ชปํ๋ ํ์ ์ธ๊ฑด์ง.. ์ฌ์ค ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ํด์ํ๋๋ฐ ์๊ฐ์ด ์ข ๊ฑธ๋ ธ๋ค.
์์ญ์ ๋ํ ํ์คํ ์ ์๋ฅผ ๋ชจ๋ฅด๊ฒ ๋ฌ๊นใ ใ
๊ทธ๋ฆผ์ ๊ทธ๋ ค์ ์ค๋ช ํ์๋ฉด
์์ ์์ ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ๊ทธ๋ ค๋ณด๋ฉด ์ด๋ฐ ๊ทธ๋ฆผ์ด ๋์จ๋ค. ์ฌ๊ธฐ์ 0์ ๋ฌด์ํ๊ณ ! ์ซ์๋ผ๋ฆฌ ๋ถ์ด์์ผ๋ฉด ์ฐ๊ฒฐํด์ฃผ๋ฉด ๋๋ค.
์ฐ๊ฒฐ๋ ๋ฉ์ด๋ฆฌ๊ฐ ์์ญ์ด๋ผ๋ ๊ฐ๋ ์ด๋ค.
๋ฌธ์ ์์๋ ๋ฉ์ด๋ฆฌ์ ๊ฐ์๋ฅผ numberOfArea๋ก, ๊ฐ์ฅ ํฐ ๋ฉ์ด๋ฆฌ์ ์ฌ์ด์ฆ๋ฅผ maxSizeOfOneArea๋ผ๋ ๋ณ์์ ๋ด์ ๋ฆฌํดํ๋ผ๋ ๊ฒ์ด๋ค ใ ใ ๋ฌธ์ ๋ถํฐ ์ฐธ .. ๋นก์ธ๋ค.
๋ด ๋์ ์ฝ๋ค๋๋ฐ ์ด๊ฑธ ์ปดํจํฐํํ ์ด๋ป๊ฒ ์ดํด์์ผ์ผ ํ๋๊ฑด๊ฐ.. ํ์ฐธ์ ๊ทธ๋ฆผ ๊ทธ๋ ค๋ณด๊ณ ๊ณ ๋ฏผํ๋ ๊ฒ ๊ฐ๋ค.
[ ์ฌ๊ทํจ์ ๊ตฌํ ]
๋ด๊ฐ ์ ํํ ๋ฐฉ์์ ์ฌ๊ท! (x,y)๋ฒ์งธ์ ์๋ ๊ฐ๊ณผ ๊ฐ์ ์์ญ์ ์ฐพ๋๋ค ํ๋ฉด ๊ฐ๊ฐ ์ํ์ข์ฐ์ ์๋ (x+1,y), (x-1,y), (x, y+1), (y, y-1)์ ํ์ํ๊ณ ์ด๋ฏธ ํ์ํ ์์น๋ ๋ค์๋ ํ์ํ ์ ์๊ฒ ์ฒดํฌํด์ค๋น
์ด ํ์์ ์ํด ๊ตฌํํ ํจ์๊ฐ sizeOfArea๋ค.
ํด๋น ์์น์ ๊ฐ์ด ์๋ฏธ์๋ ๊ฐ์ด ์๋๊ฒฝ์ฐ, ํด๋น ํจ์๋ฅผ ์ฌ๊ทํธ์ถํด ์ธ์ ํ ์์น์ ๊ฐ๊น์ง ๋ถ๋ฌ์จ๋ค. ๋ฆฌํด๊ฐ์ ์ฌํ๊น์ง ์ฐพ์ ์ธ์ ํ ์์ญ์ ๊ฐ์๊ฐ ๋๋ค. ์ด ์์น์ ๊ฐ์ ๋์ด์ ์ฒดํฌํ์ง ๋ชปํ๋๋ก 0์ผ๋ก ๋ง๋ค์ด์ค๋ค.
์๋ฏธ์๋ ๊ฐ์ ๊ธฐ์ค์ (1) ์ธ๋ฑ์ค๋ฅผ ๋ฒ์ด๋ ๊ฒฝ์ฐ(0๋ณด๋ค ์๊ฑฐ๋, m๋๋ n์ ๊ฐ์ ๋์ด์ ๊ฒฝ์ฐ) (2) ์ธ์ ํ ์์ญ๊ณผ ๋ค๋ฅธ๊ฐ์ ๊ฐ์ง ๊ฒฝ์ฐ (3) 0์ธ๊ฒฝ์ฐ์ด๋ค. ์ด ๊ฒฝ์ฐ์ ํด๋นํ๋ค๋ฉด 0์ ๋ฆฌํดํ๋ค.
์ด๋ ๊ฒ sizeOfAreaํจ์๋ฅผ ๊ตฌํํ๊ณ for๋ฌธ์ ํตํด ์์ญ์ ํฌ๊ธฐ๋ฅผ ๊ฐ๊ฐ ๋ฐ์์จ๋ค.
๋ฆฌํด๊ฐ์ด 0๋ณด๋ค ํฐ ๊ฒฝ์ฐ๋ ์๋ก์ด ์์ญ์ ์ฐพ์๋ค๋ ๋ป์ด๊ธฐ์ numberOfArea์ฆ๊ฐ, ๊ธฐ์กด์ max๊ฐ๋ณด๋ค ๋ ํฐ ๊ฐ์ธ ๊ฒฝ์ฐ max๊ฐ์ ๊ฐฑ์ ํด์ค๋ค.
๐ฅ [์ต์ข ์ฝ๋]
import java.util.*;
class Solution {
public int[] solution(int m, int n, int[][] picture) {
int numberOfArea = 0;
int maxSizeOfOneArea = 1;
int[][] tmp = new int[m][n];
for(int i = 0; i < m; i++) {
for(int j = 0; j < n; j++) {
tmp[i][j] = picture[i][j];
}
}
for(int i = 0; i < m; i++) {
for(int j = 0; j < n; j++) {
int result = sizeOfArea(tmp, tmp[i][j], i, j);
if(result == 0) {
continue;
} else {
numberOfArea++;
if(result > maxSizeOfOneArea) {
maxSizeOfOneArea = result;
}
}
}
}
int[] answer = new int[2];
answer[0] = numberOfArea;
answer[1] = maxSizeOfOneArea;
return answer;
}
public int sizeOfArea(int[][] picture, int num, int x, int y) {
if(x >= picture.length || y >= picture[0].length || x < 0 || y < 0 || (picture[x][y] == 0) || (picture[x][y] != num))
return 0;
picture[x][y] = 0;
return 1
+ sizeOfArea(picture, num, x+1, y)
+ sizeOfArea(picture, num, x-1, y)
+ sizeOfArea(picture, num, x, y+1)
+ sizeOfArea(picture, num, x, y-1);
}
}
๐ฅ [์๊ฐ]
picture 2์ฐจ์ ๋ฐฐ์ด ๊ทธ๋๋ก ์ฌ์ฉํ๋ฉด ์๋๋ค๋๊ฑฐ... ๋ณต์ฌํด์ ์ฌ์ฉํด์ผํ๋ค๋๊ฑฐ.. ์ ์๋ฌด๋ ๋ํํ ๋ง ์ํด์คฌ์ด?
๋ถ์กฑํ ์ ํผ๋๋ฐฑ ์ฃผ์๋ฉด ์์ผ๋ก์ ํฌ์คํ ์ ๋ฐ์ํ๊ฒ ์ต๋๋ค! ๋ด์ฃผ์ ์ ์ ๋ง ๊ฐ์ฌํฉ๋๋ค :)
-budtree