๐ ๋ฌธ์
๊ณ ๊ณ ํ์์ธ ํ๋ธ๋ ๊ณ ๋ ์ ์ ์ง์์ ๋ณด๋ฌผ๊ณผ ์ ์ ์ด ๊ฐ๋ํ ๊ฒ์ผ๋ก ์ถ์ ๋๋ ๋น๋ฐ์ ๋ฌธ์ ๋ฐ๊ฒฌํ์์ต๋๋ค. ๊ทธ๋ฐ๋ฐ ๋ฌธ์ ์ด๋ ค๊ณ ์ดํด๋ณด๋ ํน์ดํ ํํ์ ์๋ฌผ์ ๋ก ์ ๊ฒจ ์์๊ณ ๋ฌธ ์์๋ ํน์ดํ ํํ์ ์ด์ ์ ํจ๊ป ์๋ฌผ์ ๋ฅผ ํธ๋ ๋ฐฉ๋ฒ์ ๋ํด ๋ค์๊ณผ ๊ฐ์ด ์ค๋ช ํด ์ฃผ๋ ์ข ์ด๊ฐ ๋ฐ๊ฒฌ๋์์ต๋๋ค.
์ ๊ฒจ์๋ ์๋ฌผ์ ๋ ๊ฒฉ์ ํ ์นธ์ ํฌ๊ธฐ๊ฐ 1 x 1์ธ N x N ํฌ๊ธฐ์ ์ ์ฌ๊ฐ ๊ฒฉ์ ํํ์ด๊ณ ํน์ดํ ๋ชจ์์ ์ด์ ๋ M x M ํฌ๊ธฐ์ธ ์ ์ฌ๊ฐ ๊ฒฉ์ ํํ๋ก ๋์ด ์์ต๋๋ค.
์๋ฌผ์ ์๋ ํ์ด ํ์ฌ ์๊ณ ์ด์ ๋ํ ํ๊ณผ ๋๊ธฐ ๋ถ๋ถ์ด ์์ต๋๋ค. ์ด์ ๋ ํ์ ๊ณผ ์ด๋์ด ๊ฐ๋ฅํ๋ฉฐ ์ด์ ์ ๋๊ธฐ ๋ถ๋ถ์ ์๋ฌผ์ ์ ํ ๋ถ๋ถ์ ๋ฑ ๋ง๊ฒ ์ฑ์ฐ๋ฉด ์๋ฌผ์ ๊ฐ ์ด๋ฆฌ๊ฒ ๋๋ ๊ตฌ์กฐ์ ๋๋ค. ์๋ฌผ์ ์์ญ์ ๋ฒ์ด๋ ๋ถ๋ถ์ ์๋ ์ด์ ์ ํ๊ณผ ๋๊ธฐ๋ ์๋ฌผ์ ๋ฅผ ์ฌ๋ ๋ฐ ์ํฅ์ ์ฃผ์ง ์์ง๋ง, ์๋ฌผ์ ์์ญ ๋ด์์๋ ์ด์ ์ ๋๊ธฐ ๋ถ๋ถ๊ณผ ์๋ฌผ์ ์ ํ ๋ถ๋ถ์ด ์ ํํ ์ผ์นํด์ผ ํ๋ฉฐ ์ด์ ์ ๋๊ธฐ์ ์๋ฌผ์ ์ ๋๊ธฐ๊ฐ ๋ง๋์๋ ์๋ฉ๋๋ค. ๋ํ ์๋ฌผ์ ์ ๋ชจ๋ ํ์ ์ฑ์ ๋น์ด์๋ ๊ณณ์ด ์์ด์ผ ์๋ฌผ์ ๋ฅผ ์ด ์ ์์ต๋๋ค.
์ด์ ๋ฅผ ๋ํ๋ด๋ 2์ฐจ์ ๋ฐฐ์ด key์ ์๋ฌผ์ ๋ฅผ ๋ํ๋ด๋ 2์ฐจ์ ๋ฐฐ์ด lock์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ด์ ๋ก ์๋ฌผ์ ๋ฅผ ์ด์ ์์ผ๋ฉด true๋ฅผ, ์ด ์ ์์ผ๋ฉด false๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
๐ ์ ํ์ฌํญ
- key๋ M x M(3 ≤ M ≤ 20, M์ ์์ฐ์)ํฌ๊ธฐ 2์ฐจ์ ๋ฐฐ์ด์ ๋๋ค.
- lock์ N x N(3 ≤ N ≤ 20, N์ ์์ฐ์)ํฌ๊ธฐ 2์ฐจ์ ๋ฐฐ์ด์ ๋๋ค.
- M์ ํญ์ N ์ดํ์ ๋๋ค.
- key์ lock์ ์์๋ 0 ๋๋ 1๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
- 0์ ํ ๋ถ๋ถ, 1์ ๋๊ธฐ ๋ถ๋ถ์ ๋ํ๋ ๋๋ค.
๐ ํ์ด
ํฌ๊ฒ 3๊ฐ์ง ๊ธฐ๋ฅ์ ๋ง๋ค๋ฉด ๋๊ฒ ๋ค๊ณ ์๊ฐํ๋ค.
1. lock์ 3๋ฐฐ๋ก ๋๋ฆฌ๊ธฐ
lock์ 3๋ฐฐ๋ก ๋๋ฆฌ๋ฉด์, ์ค์ lock์ ํด๋นํ์ง ์๋ ๊ฐ์ 3์ผ๋ก ์ค์ ํด์คฌ๋ค. (๋์ค์ ๊ณ์ฐํ ๋, ๋ฌด์ํ๊ธฐ ์ํจ)
ํ์ ๋ฐ๊ฒฌํ๋ฉด count++ (count๋ lock์ ํ์ ๊ฐ์๋ฅผ ์๋ฏธ)
2. ๋ชจ๋ ํ์ด ์ฑ์์ก๋์ง ํ์ธ
- ์ค์ lock์ ํด๋นํ์ง ์๋ ๊ฐ(3)์ ๋ฌด์.
- lock๊ณผ key ๋ชจ๋ ๋๊ธฐ๋ผ๋ฉด ์๋ฌผ์ ๋ฅผ ํ ์ ์๋ค๋ ๊ฒ.
- lock์ด ํ์ด๊ณ , key๊ฐ ๋๊ธฐ๋ฉด ํ์ด ์ฑ์์ก๋ค๋ ์๋ฏธ๋ก tempCount++
์ค์ lock์ ํ์ ๊ฐ์(count)์ ์ฑ์์ง ํ์ ๊ฐ์(tempCount)๊ฐ ๊ฐ์ผ๋ฉด, ํด๋น ์ด์ ๋ก ์๋ฌผ์ ๋ฅผ ํ ์ ์๋ค๋ ๊ฒ.
3. key ๋ฐฐ์ด ์๊ณ๋ฐฉํฅ์ผ๋ก 90๋ ๋๋ฆฌ๊ธฐ
์ด 4๋ฒ ๋๋ฆฐ๋ค. (0๋, 90๋, 180๋, 270๋)
5๋ฒ์งธ๋ 360๋๋ก 0๋์ ๊ฐ์ ๊ฐ์ด๋ผ์ ๋๋ฆฌ์ง ์๋๋ค.
๐ ์ฝ๋
public class ์๋ฌผ์ ์์ด์ {
int count;
public boolean solution(int[][] key, int[][] lock) {
this.count = 0;
lock = initLock(lock);
for (int i = 0; i < 4; i++) {
if (isMatch(key, lock)) return true;
key = rotation(key);
}
return false;
}
private int[][] initLock(int[][] lock) {
int n = lock.length;
int[][] result = new int[n * 3][n * 3];
for (int i = 0; i < result.length; i++) {
for (int j = 0; j < result.length; j++) {
if (i >= n && i < n * 2 && j >= n && j < n * 2) {
result[i][j] = lock[i - n][j - n];
if (result[i][j] == 0) this.count++;
} else {
result[i][j] = 3;
}
}
}
return result;
}
private boolean isMatch(int[][] key, int[][] lock) {
int keySize = key.length;
int lockSize = lock.length;
for (int i = 0; i <= lockSize - keySize; i++) {
for (int j = 0; j <= lockSize - keySize; j++) {
if (isMatch(key, lock, i, j)) return true;
}
}
return false;
}
private boolean isMatch(int[][] key, int[][] lock, int x, int y) {
int n = key.length;
int tempCount = 0;
for (int i = x; i < x + n; i++) {
for (int j = y; j < y + n; j++) {
if (lock[i][j] == 3) continue;
if (lock[i][j] == 1 && key[i - x][j - y] == 1) return false;
if (lock[i][j] == 0 && key[i - x][j - y] == 1) tempCount++;
}
}
return count == tempCount;
}
private int[][] rotation(int[][] key) {
int n = key.length;
int[][] result = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
result[i][j] = key[n - 1 - j][i];
}
}
return result;
}
}
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๐ค BOJ16954 ์์ง์ด๋ ๋ฏธ๋ก ํ์ถ (Java) (0) | 2021.03.08 |
---|---|
๐ 2019 ์นด์นด์ค ๋ธ๋ผ์ธ๋ ๊ณต์ฑ: ํ๋ณดํค (Java) (0) | 2020.05.03 |
๐ค 2020 ์นด์นด์ค ๋ธ๋ผ์ธ๋ ๊ณต์ฑ: ์๋ฌผ์ ์ ์ด์ (Java) (0) | 2020.04.28 |
๐ ํ๋ก๊ทธ๋๋จธ์ค: Lv3. ์ ๊ตญ ์ฌ์ฌ (Java) (0) | 2020.04.25 |
๐ ์นด์นด์ค 2019 ๊ฒจ์ธ ์ธํด์ญ: ๋ถ๋ ์ฌ์ฉ์(Lv3) (0) | 2020.04.05 |
๐ ์นด์นด์ค 2019 ๊ฒจ์ธ ์ธํด์ญ: ํฌ๋ ์ธ ์ธํ๋ฝ๊ธฐ ๊ฒ์(Lv2) (0) | 2020.04.01 |