๋ฌธ์
๊ฐ๋ก ๊ธธ์ด๊ฐ Wcm, ์ธ๋ก ๊ธธ์ด๊ฐ Hcm์ธ ์ง์ฌ๊ฐํ ์ข
์ด๊ฐ ์์ต๋๋ค. ์ข
์ด์๋ ๊ฐ๋ก, ์ธ๋ก ๋ฐฉํฅ๊ณผ ํํํ๊ฒ ๊ฒฉ์ ํํ๋ก ์ ์ด ๊ทธ์ด์ ธ ์์ผ๋ฉฐ, ๋ชจ๋ ๊ฒฉ์์นธ์ 1cm x 1cm ํฌ๊ธฐ์
๋๋ค. ์ด ์ข
์ด๋ฅผ ๊ฒฉ์ ์ ์ ๋ฐ๋ผ 1cm × 1cm์ ์ ์ฌ๊ฐํ์ผ๋ก ์๋ผ ์ฌ์ฉํ ์์ ์ด์๋๋ฐ, ๋๊ตฐ๊ฐ๊ฐ ์ด ์ข
์ด๋ฅผ ๋๊ฐ์ ๊ผญ์ง์ 2๊ฐ๋ฅผ ์๋ ๋ฐฉํฅ์ผ๋ก ์๋ผ ๋์์ต๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก ํ์ฌ ์ง์ฌ๊ฐํ ์ข
์ด๋ ํฌ๊ธฐ๊ฐ ๊ฐ์ ์ง๊ฐ์ผ๊ฐํ 2๊ฐ๋ก ๋๋์ด์ง ์ํ์
๋๋ค. ์๋ก์ด ์ข
์ด๋ฅผ ๊ตฌํ ์ ์๋ ์ํ์ด๊ธฐ ๋๋ฌธ์, ์ด ์ข
์ด์์ ์๋ ์ข
์ด์ ๊ฐ๋ก, ์ธ๋ก ๋ฐฉํฅ๊ณผ ํํํ๊ฒ 1cm × 1cm๋ก ์๋ผ ์ฌ์ฉํ ์ ์๋ ๋งํผ๋ง ์ฌ์ฉํ๊ธฐ๋ก ํ์์ต๋๋ค.
๊ฐ๋ก์ ๊ธธ์ด W์ ์ธ๋ก์ ๊ธธ์ด H๊ฐ ์ฃผ์ด์ง ๋, ์ฌ์ฉํ ์ ์๋ ์ ์ฌ๊ฐํ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
์ ํ์ฌํญ
- W, H : 1์ต ์ดํ์ ์์ฐ์
์ ์ถ๋ ฅ ์
W | H | result |
8 | 12 | 80 |
์ ์ถ๋ ฅ ์ ์ค๋ช
๊ฐ๋ก๊ฐ 8, ์ธ๋ก๊ฐ 12์ธ ์ง์ฌ๊ฐํ์ ๋๊ฐ์ ๋ฐฉํฅ์ผ๋ก ์๋ฅด๋ฉด ์ด 16๊ฐ ์ ์ฌ๊ฐํ์ ์ฌ์ฉํ ์ ์๊ฒ ๋ฉ๋๋ค. ์๋ ์ง์ฌ๊ฐํ์์๋ 96๊ฐ์ ์ ์ฌ๊ฐํ์ ๋ง๋ค ์ ์์์ผ๋ฏ๋ก, 96 - 16 = 80 ์ ๋ฐํํฉ๋๋ค.
ํด๊ฒฐ
key point, 1์ฐจ ํจ์๋ฅผ ์๊ฐํ๋ค!
- ์ข์ฐ๋์นญํ ๊ทธ๋ฆผ์ ์ดํด๋ณด๋ฉด
- ์ผ์ชฝ ํ๋จ ๊ผญ์ง์ ์ด (0, 0)์ด ๋๋ค
- ๊ทธ๋ฌ๋ฉด (0, 0), (8, 12)๋ฅผ ์ง๋๋ 1์ฐจ ํจ์๊ฐ ๊ทธ๋ ค์ง๊ณ
- ๊ทธ๋ ค์ง๋ 1์ฐจ ํจ์์ ์์ ๊ตฌํด๋ณด๋ฉด
- (y2 - y1) / (x2 - x1) = y ์ฆ๊ฐ๋ / x ์ฆ๊ฐ๋ = ๊ธฐ์ธ๊ธฐ
- x1, y1 ์ ์์ (0, 0)์ด ๋๋ฏ๋ก
- y = (y2/x2)x ์ด๋ค.
- 1์ฐจ ํจ์์ ์์ ์ด์ฉํ๋ฉด x๊ฐ์ ๋ฐ๋ผ ํจ์ ์๋๋ก ๊ทธ๋ ค์ง๋ ์ ์ฌ๊ฐํ์ ๊ฐ์๋ฅผ ์ ์ ์๋ค.
- ์ ์ํ ์ ์ ํจ์ ์์ ์ ์ฌ๊ฐํ๋ ๊ณ ๋ คํด์ผ ํ๋ฏ๋ก ์ ๋ต์ 2๋ฐฐ๋ฅผ ํด์ฃผ์ด์ผ ํ๋ค.
- ๋ํ, h, w๊ฐ ๊ฐ๊ฐ ์ต๋ 1์ต์ด ๋ ์ ์์ผ๋ฏ๋ก ๊ณฑํ๊ธฐ ์ฐ์ฐ์ ํ๋ฉด์ int ๋ฒ์๋ฅผ ๋์ด๊ฐ ์ ์๊ณ
answer ๋ํ ๋์ ํฉ์ ๊ตฌํ๋ฉด์ int ๋ฒ์๊ฐ ๋์ด๊ฐ ์ ์์ผ๋ฏ๋ก ๋ฐ๋์ long longํ์ผ๋ก ๋ฐ๊ฟ์ฃผ์ด์ผ ํ๋ค.
์ฝ๋
1
2
3
4
5
6
7
8
9
|
using namespace std;
long long solution(int w,int h) {
long long answer = 0;
for(int i = 0; i < w; i++){
answer += ((long long)h * (long long)i) / w;
}
return answer * 2;
}
|
cs |
'๐ฅ PS(Problem Solving) ๐ฅ > programmers' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[programmers] ์คํํ, ๋ค๋ฆฌ๋ฅผ ์ง๋๋ ํธ๋ญ (0) | 2020.07.03 |
---|---|
[programmers] ์คํ/ํ, ํ (0) | 2020.06.02 |
[programmers] 2020 kakao, ๋ฌธ์์ด ์์ถ (0) | 2020.05.12 |
[programmers] ์์ ํ์, ์นดํซ (0) | 2020.03.11 |
[programmers] ์์ ํ์, ๋ชจ์๊ณ ์ฌ (0) | 2020.03.11 |
๋๊ธ