โฐ๋ฌธ์
๋ช ํจ ์ง๊ฐ์ ๋ง๋๋ ํ์ฌ์์ ์ง๊ฐ์ ํฌ๊ธฐ๋ฅผ ์ ํ๋ ค๊ณ ํฉ๋๋ค. ๋ค์ํ ๋ชจ์๊ณผ ํฌ๊ธฐ์ ๋ช ํจ๋ค์ ๋ชจ๋ ์๋ฉํ ์ ์์ผ๋ฉด์, ์์์ ๋ค๊ณ ๋ค๋๊ธฐ ํธํ ์ง๊ฐ์ ๋ง๋ค์ด์ผ ํฉ๋๋ค. ์ด๋ฌํ ์๊ฑด์ ๋ง์กฑํ๋ ์ง๊ฐ์ ๋ง๋ค๊ธฐ ์ํด ๋์์ธํ์ ๋ชจ๋ ๋ช ํจ์ ๊ฐ๋ก ๊ธธ์ด์ ์ธ๋ก ๊ธธ์ด๋ฅผ ์กฐ์ฌํ์ต๋๋ค.
์๋ ํ๋ 4๊ฐ์ง ๋ช ํจ์ ๊ฐ๋ก ๊ธธ์ด์ ์ธ๋ก ๊ธธ์ด๋ฅผ ๋ํ๋ ๋๋ค.
๋ช ํจ ๋ฒํธ | ๊ฐ๋ก ๊ธธ์ด | ์ธ๋ก ๊ธธ์ด |
1 | 60 | 50 |
2 | 30 | 70 |
3 | 60 | 30 |
4 | 80 | 40 |
๊ฐ์ฅ ๊ธด ๊ฐ๋ก ๊ธธ์ด์ ์ธ๋ก ๊ธธ์ด๊ฐ ๊ฐ๊ฐ 80, 70์ด๊ธฐ ๋๋ฌธ์ 80(๊ฐ๋ก) x 70(์ธ๋ก) ํฌ๊ธฐ์ ์ง๊ฐ์ ๋ง๋ค๋ฉด ๋ชจ๋ ๋ช ํจ๋ค์ ์๋ฉํ ์ ์์ต๋๋ค. ํ์ง๋ง 2๋ฒ ๋ช ํจ์ ๊ฐ๋ก๋ก ๋ํ ์๋ฉํ๋ค๋ฉด 80(๊ฐ๋ก) x 50(์ธ๋ก) ํฌ๊ธฐ์ ์ง๊ฐ์ผ๋ก ๋ชจ๋ ๋ช ํจ๋ค์ ์๋ฉํ ์ ์์ต๋๋ค. ์ด๋์ ์ง๊ฐ ํฌ๊ธฐ๋ 4000(=80 x 50)์ ๋๋ค.
๋ชจ๋ ๋ช ํจ์ ๊ฐ๋ก ๊ธธ์ด์ ์ธ๋ก ๊ธธ์ด๋ฅผ ๋ํ๋ด๋ 2์ฐจ์ ๋ฐฐ์ด sizes๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๋ชจ๋ ๋ช ํจ์ ์๋ฉํ ์ ์๋ ๊ฐ์ฅ ์์ ์ง๊ฐ์ ๋ง๋ค ๋, ์ง๊ฐ์ ํฌ๊ธฐ๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- sizes์ ๊ธธ์ด๋ 1 ์ด์ 10,000 ์ดํ์
๋๋ค.
- sizes์ ์์๋ [w, h] ํ์์ ๋๋ค.
- w๋ ๋ช ํจ์ ๊ฐ๋ก ๊ธธ์ด๋ฅผ ๋ํ๋ ๋๋ค.
- h๋ ๋ช ํจ์ ์ธ๋ก ๊ธธ์ด๋ฅผ ๋ํ๋ ๋๋ค.
- w์ h๋ 1 ์ด์ 1,000 ์ดํ์ธ ์์ฐ์์ ๋๋ค.
์ ์ถ๋ ฅ ์
sizes | result |
[[60, 50], [30, 70], [60, 30], [80, 40]] | 4000 |
[[10, 7], [12, 3], [8, 15], [14, 7], [5, 15]] | 120 |
[[14, 4], [19, 6], [6, 16], 18, 7], [7, 11]] | 133 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
๋ฌธ์ ์์์ ๊ฐ์ต๋๋ค.
์
์ถ๋ ฅ ์ #2
๋ช
ํจ๋ค์ ์ ์ ํ ํ์ ์์ผ ๊ฒน์ณค์ ๋, 3๋ฒ์งธ ๋ช
ํจ(๊ฐ๋ก: 8, ์ธ๋ก: 15)์ด ๋ค๋ฅธ ๋ชจ๋ ๋ช
ํจ๋ณด๋ค ํฌ๊ธฐ๊ฐ ํฝ๋๋ค. ๋ฐ๋ผ์ ์ง๊ฐ์ ํฌ๊ธฐ๋ 3๋ฒ์งธ ๋ช
ํจ์ ํฌ๊ธฐ์ ๊ฐ์ผ๋ฉฐ, 120(=8 x 15)์ return ํฉ๋๋ค.
์
์ถ๋ ฅ ์ #3
๋ช
ํจ๋ค์ ์ ์ ํ ํ์ ์์ผ ๊ฒน์ณค์ ๋, ๋ชจ๋ ๋ช
ํจ์ ํฌํจํ๋ ๊ฐ์ฅ ์์ ์ง๊ฐ์ ํฌ๊ธฐ๋ 133(=19 x 7)์
๋๋ค.
๐กํ์ด
๐ ์ ๊ทผ
* POINT! ๋ช ํจ์ ํ์ ์ํฌ ์ ์๋ค!
1. ๊ฐ๋ก์ ์ธ๋ก์ ๋ํด ๊ณ ์ ๋ ํ๋ง ์ง์คํ๋ฉด ๋จธ๋ฆฌ๊ฐ ๋ ์ํ์ง ์ ์๋ค.
2. ๊ฐ๋ก์ ์ธ๋ก๋ก ๊ตฌ๋ถ์ง์ง ์๊ณ ๋ ๊ธธ์ด ์ค ๊ธด ๋ถ๋ถ๊ณผ ์งง์ ๋ถ๋ถ์ผ๋ก ๊ตฌ๋ถํ๋ค.
(๊ฐ๋ก: ๊ธด ๋ถ๋ถ, ์ธ๋ก: ์งง์ ๋ถ๋ถ)
3. ๊ฐ๋ก, ์ธ๋ก์์ ๊ฐ๊ฐ Max๊ฐ์ ์ฐ์ถํ๋ค.
๊ฐ ๋ช ํจ์ ๊ธธ์ด ์ค ๊ธด ๋ถ๋ถ๊ณผ ์งง์ ๋ถ๋ถ์ ๊ตฌํ๋ค.
for(int i = 0; i < sizes.length; i++){
int w = Math.max(sizes[i][0], sizes[i][1]); // ๊ธด ๋ถ๋ถ
int h = Math.min(sizes[i][0], sizes[i][1]); // ์งง์ ๋ถ๋ถ
}
๊ฐ๋ก, ์ธ๋ก์ ๊ธฐ์กด max๊ฐ(max_w, max_h)๊ณผ ํ์ฌ์ max๊ฐ(w, h)์์์ Max๊ฐ์ ๋ค์ ์ค์ ํ๋ค.
max_w = Math.max(max_w, w);
max_h = Math.max(max_h, h);
โญ์ ์ถ ์ฝ๋
class Solution {
public int solution(int[][] sizes) {
int max_w = 0;
int max_h = 0;
for(int i=0; i<sizes.length; i++){
int w = Math.max(sizes[i][0], sizes[i][1]); //๊ธด ๋ถ๋ถ
int h = Math.min(sizes[i][0], sizes[i][1]); //์งง์ ๋ถ๋ถ
max_w = Math.max(max_w, w);
max_h = Math.max(max_h, h);
}
return max_w*max_h;
}
}
'๐ Algorithm > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Programmers] ๋ฑ์ ๋งค๊ธฐ๊ธฐ(์๋ฐ) (0) | 2023.08.01 |
---|---|
[Programmers] ์น์์ด(2)(์๋ฐ) (0) | 2023.06.12 |
[Programmers] ์ด์ง์ ๋ํ๊ธฐ(์๋ฐ) (0) | 2023.04.25 |
[Programmers] ์น์์ด(1)(์๋ฐ) (0) | 2023.04.24 |
[Programmers] ๋คํญ์ ๋ํ๊ธฐ(์๋ฐ) (0) | 2023.04.18 |