์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | ||||||
2 | 3 | 4 | 5 | 6 | 7 | 8 |
9 | 10 | 11 | 12 | 13 | 14 | 15 |
16 | 17 | 18 | 19 | 20 | 21 | 22 |
23 | 24 | 25 | 26 | 27 | 28 |
- createSlice
- maeil-mail
- ์๊ณ ๋ฆฌ์ฆ
- redux-saga
- ์ด์ฝํ
- sw expert academy
- react-redux
- ํ ์ฝํ ์ฝ
- redux-toolkit
- react-router
- ๋ฆฌ์กํธ
- SW
- JavaScript
- ํ๋ก๊ทธ๋๋จธ์ค
- useDispatch
- Python
- java
- react
- redux
- programmers
- ์๋ฐ
- ํญํด99
- axios
- Algorithm
- json-server
- C++
- ํญํดํ๋ฌ์ค
- Get
- ๋งค์ผ๋ฉ์ผ
- ์ฝ๋ฉํ ์คํธํฉ๊ฒฉ์๋๊ธฐ
- Today
- Total
Binary Journey
[ํ ์ฝํ ์ฝ1.5 1-08] ๊ณต์ ๋ณธ๋ฌธ
[ํ ์ฝํ ์ฝ1.5 1-08] ๊ณต์
binaryJournalist 2025. 1. 14. 15:33๐กํ ์ฝํ ์ฝ ์์ฆ 1.5 1ํ ๋ชจ์ off-site ๋ฌธ์ ํ์ด์ ๋๋ค. (2025.01.12)
๋ฌธ์
์ถ์ฒ: ํ๋ก๊ทธ๋๋จธ์ค - PCCE ๊ธฐ์ถ๋ฌธ์ 10. ๊ณต์
๋ด์ฉ
์ง๋ฏผ์ด๋ ๋ค์ํ ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๋ชจ์ ๋์๋ฆฌ๋ฅผ ๊ฐ์ง๊ณ ๊ณต์์ ์ํ์ ๋์์ต๋๋ค. ๊ณต์์๋ ์ด๋ฏธ ๋์๋ฆฌ๋ฅผ ๊น๊ณ ์ฌ๊ฐ๋ฅผ ์ฆ๊ธฐ๋ ์ฌ๋๋ค์ด ๋ง์ ์ง๋ฏผ์ด๊ฐ ๊น ์ ์๋ ๊ฐ์ฅ ํฐ ๋์๋ฆฌ๊ฐ ์ด๋ค ๊ฑด์ง ํ์ธํ๋ ค ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ์ง๋ฏผ์ด๊ฐ ๊ฐ์ง๊ณ ์๋ ๋์๋ฆฌ์ ํ ๋ณ ๊ธธ์ด๊ฐ 5, 3, 2 ์ธ ์ข ๋ฅ์ด๊ณ , ์ฌ๋๋ค์ด ๋ค์๊ณผ ๊ฐ์ด ์์ ์๋ค๋ฉด ์ง๋ฏผ์ด๊ฐ ๊น ์ ์๋ ๊ฐ์ฅ ํฐ ๋์๋ฆฌ๋ 3x3 ํฌ๊ธฐ์ ๋๋ค.
์ง๋ฏผ์ด๊ฐ ๊ฐ์ง ๋์๋ฆฌ๋ค์ ํ ๋ณ์ ๊ธธ์ด๋ค์ด ๋ด๊ธด ์ ์ ๋ฆฌ์คํธ mats
, ํ์ฌ ๊ณต์์ ์๋ฆฌ ๋ฐฐ์น๋๋ฅผ ์๋ฏธํ๋ 2์ฐจ์ ๋ฌธ์์ด ๋ฆฌ์คํธ park
๊ฐ ์ฃผ์ด์ง ๋ ์ง๋ฏผ์ด๊ฐ ๊น ์ ์๋ ๊ฐ์ฅ ํฐ ๋์๋ฆฌ์ ํ ๋ณ ๊ธธ์ด๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ์๋ฌด๋ฐ ๋์๋ฆฌ๋ ๊น ์ ์๋ ๊ฒฝ์ฐ -1์ returnํฉ๋๋ค.
๊ธฐ๋กํ๊ธฐ
๐ก ์ด๋๊น์ง ์๊ฐํด๋ดค๋์ง ๋จ๊ณ์ ์ผ๋ก ๊ธฐ๋กํด๋ด ๋๋ค.
์ด๋ค ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํ๋ ค ํ๋์?
DP, Dynamic Programming์ ์ด์ฉํ๋ ค ํ๋ค.
์ ์ฉ ๊ทผ๊ฑฐ๋ ๋ฌด์์ธ๊ฐ์?
ํ๋ก๊ทธ๋๋จธ์ค ๋ฌธ์ ์ค ๊ฐ์ฅ ํฐ ์ ์ฌ๊ฐํ ์ฐพ๊ธฐ ์ ์ ์ฌํ๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฌธ์ ํ์ด ๊ณผ์ ์์ ํด๋น ์๊ณ ๋ฆฌ์ฆ์ ์ด๋ป๊ฒ ์ฝ๋๋ก ๊ตฌํํ๋ ค ํ๋์?
ํ์ด ๋ฐฉ์์ ์ด๋ฏธ์ง๋ ์ด ๊ธ์ ์ฐธ๊ณ ํ๋ฉด ๋๋ค.
-1์ ๊ฐ์ง ์ต๋ ์ ์ฌ๊ฐํ์ ์ฐพ์ ํ ๋ณ์ ๊ธธ์ด๊ฐ 2, 3, 5 ์ค ๊ฐ๋ฅํ ํฐ ๊ฐ์ ๋ฐํํ๋ฉด ๋๋ค.
1. DP ๋ฐฐ์ด ์ ์ธ. (์๋๋ฉด ์ฃผ์ด์ง 2์ฐจ์ ๋ฐฐ์ด ๊ทธ๋๋ก ์ฌ์ฉํด๋ ๋จ)
1. ์ฒซ ํ์ ๊ทธ๋๋ก ์ง๋๊ฐ
2. ๋ ๋ฒ์งธ ํ๋ถํฐ ํ์ํ๋ ์นธ ๊ธฐ์ค์ผ๋ก ์ข, ์, ์ข์ ํ์
1. ํ์๊ฐ์ด 1์ผ ๊ฒฝ์ฐ ์ ์ฌ๊ฐํ ๋ง๋ค ์ ์๋ ๊ฐฏ์๋ฅผ ๊ธฐ๋ก
2. ์ซ์๊ฐ 2 ์ด์์ผ ๊ฒฝ์ฐ ์ข, ์ฐ, ์ข์ฐ ํ์ ๊ธฐ์ค์ผ๋ก ํด๋น ๋ณ์ ๊ธธ์ด๋ฅผ ๊ฐ์ง ์ ์ฌ๊ฐํ์ ๋ง๋ค ์ ์๋ค๊ณ ์ดํดํ๋ฉด ๋จ
3. ์๋ ํ๊น์ง ๋ง๋ค ์ ์๋ ์ ์ฌ๊ฐํ์ ๋ณ์ ๊ธธ์ด๋ฅผ ๋์ ํจ
1. ์ต๋ ๊ธธ์ด ๊ฐฑ์
2. ์ต๋ ์ ์ฌ๊ฐํ์ ๋ณ์ ๊ธธ์ด 2, 3, 5 ์ค ๋ฐํ
ํ์ด
ํ์ด ์๊ฐ
์์ ์๊ฐ | ์ข ๋ฃ ์๊ฐ | ์ด ์์ ์๊ฐ |
---|---|---|
22:02 | 22:37 | 35๋ถ |
๋ฌธ์ ๋ถ์
์ ์ฝ ์ฌํญ ํ์ & ํ ์คํธ ์ผ์ด์ค ์์ฑ
- 1 ≤
mats
์ ๊ธธ์ด ≤ 10- 1 ≤
mats
์ ์์ ≤ 20 mats
๋ ์ค๋ณต๋ ์์๋ฅผ ๊ฐ์ง์ง ์์ต๋๋ค.
- 1 ≤
- 1 ≤
park
์ ๊ธธ์ด ≤ 50- 1 ≤
park[i]
์ ๊ธธ์ด ≤ 50 park[i][j]
์ ์์๋ ๋ฌธ์์ด์ ๋๋ค.park[i][j]
์ ๋์๋ฆฌ๋ฅผ ๊น ์ฌ๋์ด ์๋ค๋ฉด "-1", ์ฌ๋์ด ์๋ค๋ฉด ์ํ๋ฒณ ํ ๊ธ์๋ก ๋ ๊ฐ์ ๊ฐ์ต๋๋ค.
- 1 ≤
์ ๋ ฅ๊ฐ ๋ถ์
๐ก ์ ๋ ฅ๊ฐ์ ๋ถ์ํ๋ฉด ๋ฌธ์ ์์ ์๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ ์ ์ผ๋ก ํ์ ํ ์ ์์ต๋๋ค.
mats | park | result |
---|---|---|
[5,3,2] | [["A", "A", "-1", "B", "B", "B", "B", "-1"], ["A", "A", "-1", "B", "B", "B", "B", "-1"], ["-1", "-1", "-1", "-1", "-1", "-1", "-1", "-1"], ["D", "D", "-1", "-1", "-1", "-1", "E", "-1"], ["D", "D", "-1", "-1", "-1", "-1", "-1", "F"], ["D", "D", "-1", "-1", "-1", "-1", "E", "-1"]] |
์์ฌ ์ฝ๋ ์์ฑ
๐ก ์์ฌ ์ฝ๋๋ ๋์ ์ค์ฌ์ผ๋ก ์์ฑํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
๐ก ์์ฌ ์ฝ๋๋ ๋ฌธ์ ํด๊ฒฐ ์์๋ก ์์ฑํฉ๋๋ค.
๐ก ์์ฌ ์ฝ๋๋ฅผ ์ถฉ๋ถํ ํ ์คํธํด๋ด ๋๋ค.
1. DP ๋ฐฐ์ด ์ ์ธ. (์๋๋ฉด ์ฃผ์ด์ง 2์ฐจ์ ๋ฐฐ์ด ๊ทธ๋๋ก ์ฌ์ฉํด๋ ๋จ)
1. ์ฒซ ํ์ ๊ทธ๋๋ก ์ง๋๊ฐ
2. ๋ ๋ฒ์งธ ํ๋ถํฐ ํ์ํ๋ ์นธ ๊ธฐ์ค์ผ๋ก ์ข, ์, ์ข์ ํ์
1. ํ์๊ฐ์ด 1์ผ ๊ฒฝ์ฐ ์ ์ฌ๊ฐํ ๋ง๋ค ์ ์๋ ๊ฐฏ์๋ฅผ ๊ธฐ๋ก
2. ์ซ์๊ฐ 2 ์ด์์ผ ๊ฒฝ์ฐ ์ข, ์ฐ, ์ข์ฐ ํ์ ๊ธฐ์ค์ผ๋ก ํด๋น ๋ณ์ ๊ธธ์ด๋ฅผ ๊ฐ์ง ์ ์ฌ๊ฐํ์ ๋ง๋ค ์ ์๋ค๊ณ ์ดํดํ๋ฉด ๋จ
3. ์๋ ํ๊น์ง ๋ง๋ค ์ ์๋ ์ ์ฌ๊ฐํ์ ๋ณ์ ๊ธธ์ด๋ฅผ ๋์ ํจ
1. ์ต๋ ๊ธธ์ด ๊ฐฑ์
2. ์ต๋ ์ ์ฌ๊ฐํ์ ๋ณ์ ๊ธธ์ด 2, 3, 5 ์ค ๋ฐํ
solution(int[] mats, int[][] park) {
int maxLength = 0;
for (int i ; park.length) {
for (int j ; park[0].length) {
// 1 ์ฐพ๊ธฐ
// ์ข, ์, ์ข์ ํ์ธํ๊ณ +1 ํด์ฃผ๊ธฐ
// ํด๋น ์นธ = min + 1
// maxLength ๊ฐฑ์
}
}
int answer = -1;
for (int m : mats) {
// m <= maxLength ์ผ ๊ฒฝ์ฐ answer ๊ฐฑ์
}
return answer;
}
๊ตฌํ
class Solution {
public int solution(int[] mats, String[][] park) {
int n = park.length;
int m = park[0].length;
int[][] dp = new int[n][m];
// ๊ณ์ฐ ํธํ๊ฒ ํ๊ธฐ ์ํด String -> int ๋ณํ
for (int i = 0;i < n; i++) {
for (int j = 0;j < m; j++) {
// -1 ์ฐพ๊ธฐ
dp[i][j] = park[i][j].equals("-1") ? 1 : 0;
}
}
int maxLength = 0;
for (int i = 1;i < n; i++) {
for (int j = 1;j < m; j++) {
if (dp[i][j] > 0) {
// ์ข, ์, ์ข์ ํ์ธํ๊ณ +1 ํด์ฃผ๊ธฐ
int min = Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]);
dp[i][j] = min + 1;
// maxLength ๊ฐฑ์
maxLength = Math.max(maxLength, min + 1);
}
}
}
int answer = -1;
for (int mat : mats) {
// answer < mat <= maxLength ์ผ ๊ฒฝ์ฐ answer ๊ฐฑ์
if (answer < mat && mat <= maxLength) {
answer = mat;
}
}
return answer;
}
}
๋ณต๊ธฐํ๊ธฐ
๋ต์๊ณผ ๋์ ํ์ด๋ฅผ ๋น๊ตํด๋ณด์ธ์
- ๋์๋ฆฌ๋ฅผ max ๊ฐ๋ถํฐ ํ์ํ๋ ๊ฒ ๋ ๋นจ๋ฆฌ ๋๋๋ค.
- ์ ๋ ฅ๊ฐ ๋ถ์ํด๋ณด๋ฉด ์ ์ฒดํ์๋ ๊ฐ๋ฅํ๋ค. (n^2 * m^2 ์ ๊ฒฝ์ฐ 2500๋ง์)
์์ฝํ๊ธฐ
- ๊ฒฐ๊ตญ ๋ง์ด ํ๋ฉด ์์ฉ์ด ๋๋ค.
'Algorithm > ํ ์ฝํ ์ฝ1.5(2025.01)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ ์ฝํ ์ฝ1.5 1-10] ๊ฐ์ฅ ๋ง์ด ๋ฐ์ ์ ๋ฌผ (0) | 2025.01.14 |
---|---|
[ํ ์ฝํ ์ฝ1.5 1-09] ๋ถ๋ ๊ฐ๊ธฐ (0) | 2025.01.14 |
[ํ ์ฝํ ์ฝ1.5 1-07] ์งํ ์ ๊ธฐ (0) | 2025.01.12 |
[ํ ์ฝํ ์ฝ1.5 1-06] ๋๋ค์ ๊ท์น (0) | 2025.01.12 |
[ํ ์ฝํ ์ฝ1.5 1-05] ๋ฒ์ค (0) | 2025.01.12 |