์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 |
29 | 30 | 31 |
- ๋์ ํฉ
- ๊ทธ๋ฆฌ๋
- ๋์ ๊ณํ๋ฒ
- ํ์ด์ฌ
- ๋๋น์ฐ์ ํ์
- ๋จธ์ง์ํธ
- BFS
- DP
- ์๊ณ ๋ฆฌ์ฆ
- ์ค๋ธ์
- ์ฐ์ ์์ํ
- SQL
- ๊น์ด์ฐ์ ํ์
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- ๋ค์ด๋๋ฏนํ๋ก๊ทธ๋๋ฐ
- ์๋ฃ๊ตฌ์กฐ
- DFS
- ๋ณํฉ์ ๋ ฌ
- ๊ตฌํ
- ๊ทธ๋ํ
- ์์ํ์
- ๊ทธ๋ํํ์
- ๋ฐฑ์ค
- ์์๊ตฌํ๊ธฐ
- db
- LIS
- ๋ฐ์ดํฐ๋ฒ ์ด์ค
- ์ ๋ ฌ
- ์ํ
- ํ๋ก๊ทธ๋๋จธ์ค
๐๐ญ๐ฐ๐ธ ๐ฃ๐ถ๐ต ๐ด๐ต๐ฆ๐ข๐ฅ๐บ
[ํ๋ก๊ทธ๋๋จธ์ค] ์ ์ฐ๊ธฐ - C++ ๋ณธ๋ฌธ
[ํ๋ก๊ทธ๋๋จธ์ค] ์ ์ฐ๊ธฐ - C++
.23 2024. 4. 4. 17:42๋ฌธ์
์ขํํ๋ฉด์ ์ข์ํ๋ ์ง์๋ x์ถ๊ณผ y์ถ์ด ์ง๊ตํ๋ 2์ฐจ์ ์ขํํ๋ฉด์ ์ ์ ์ฐ์ผ๋ฉด์ ๋๊ณ ์์ต๋๋ค. ์ง์๋ ๋ ์์ ์ ์ k, d๊ฐ ์ฃผ์ด์ง ๋ ๋ค์๊ณผ ๊ฐ์ด ์ ์ ์ฐ์ผ๋ ค ํฉ๋๋ค.
- ์์ (0, 0)์ผ๋ก๋ถํฐ x์ถ ๋ฐฉํฅ์ผ๋ก a*k(a = 0, 1, 2, 3 ...), y์ถ ๋ฐฉํฅ์ผ๋ก b*k(b = 0, 1, 2, 3 ...)๋งํผ ๋จ์ด์ง ์์น์ ์ ์ ์ฐ์ต๋๋ค.
- ์์ ๊ณผ ๊ฑฐ๋ฆฌ๊ฐ d๋ฅผ ๋๋ ์์น์๋ ์ ์ ์ฐ์ง ์์ต๋๋ค.
์๋ฅผ ๋ค์ด, k๊ฐ 2, d๊ฐ 4์ธ ๊ฒฝ์ฐ์๋ (0, 0), (0, 2), (0, 4), (2, 0), (2, 2), (4, 0) ์์น์ ์ ์ ์ฐ์ด ์ด 6๊ฐ์ ์ ์ ์ฐ์ต๋๋ค.
์ ์ k์ ์์ ๊ณผ์ ๊ฑฐ๋ฆฌ๋ฅผ ๋ํ๋ด๋ ์ ์ d๊ฐ ์ฃผ์ด์ก์ ๋, ์ ์ด ์ด ๋ช ๊ฐ ์ฐํ๋์ง return ํ๋ solution ํจ์๋ฅผ ์์ฑํ์ธ์.
์ ํ์ฌํญ
- 1 ≤ k ≤ 1,000,000
- 1 ≤ d ≤ 1,000,000
์ ์ถ๋ ฅ ์
์ํ ํํธ.
์ฒ์์๋ (a*k, b*k) ์ขํ๊ฐ d ๋ฒ์ ๋ด์ ์๋ ์ง x, y์ขํ ๊ฐ๊ฐ ์ฒดํฌํ๋ ๋ฐฉํฅ์ผ๋ก ์ ๊ทผํ๋ ค ํ์ผ๋ k์ ์ ํ ๋ฒ์๊ฐ 100๋ง์ด๋ผ 2์ค ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ๋ฉด ์๋ ๊ฑฐ๊ฐ์์ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์ฐพ์๋ด์ผ ํ๋ค.
๊ทผ๋ฐ ๋ค ํ๊ณ ๋จ์ ์ฝ๋ ๋ณด๋๋ฐ C++๋ก๋ 2์ค for๋ฌธ ์ ๋นํ ์ฌ์ฉํ๋ฉด ๋๋๊ฑฐ๊ฐ๊ธดํ์
์์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ํ ์ถ์ ์ขํ๋ฅผ ๊ณ ์ ํ๊ณ , ๋ค๋ฅธ ์ถ์์ ์ต๋ ์ขํ๋ฅผ ๊ตฌํ์ฌ ๊ทธ ์ง์ ๋ถํฐ ๋ช ๊ฐ์ ์ ์ด ๋ค์ด๊ฐ ์ ์๋์ง ๊ฐ์๋ฅผ ์ธ์ด ๋ชจ๋ ๋ํด์ฃผ๊ธฐ๋ง ํ๋ฉด ๋๋ค. ์ด ๋, a์ b๊ฐ ๋ชจ๋ 0์ผ๋๋ ํฌํจ์ด๋ฏ๋ก ๋ง์ง๋ง์ 1์ ๋ํด์ค๋ค. ๋ฐ๋ผ์ ์ ์ฒด ์์์
$$ x=i, \\ y=\lfloor{\sqrt{d^2-x^2}}\rfloor$$
์ ๊ฐ์ด ์ค๊ณํ ๋ค, ๊ฐ๊ฒฉ์ด k์ผ ๋์ ์ ์ ๊ฐ์๋ฅผ $y/k + 1$ ์ ๊ฐ์ด ๊ณ์ฐํด์ฃผ๋ฉด ๋
์ธ๋ฐ, d์ k์ ๋ฒ์๊ฐ 1,000,000์ด๋ค ๋ณด๋ ๋ค์ ํ ๋ฒ ์ ์ํด์ ํ ๊ฒ์ y์ ์ขํ๋ฅผ ๊ตฌํ๋ ๊ณผ์ ์์ d*d๋ x*x์ ๊ฐ์ด int ๋ฒ์์์ overflow๊ฐ ๋ฐ์ํ ์ ์์ผ๋ ํ์ ์บ์คํธ๋ฅผ ํด์ค์ผ ํ๋ค....
๊ทธ๊ฑฐ๋๋ฌธ์ ํ๋ฒ ํ๋ ธ๋คใ
int x = i; ๋ถ๋ถ ์์ง์ฐ๋๊ฑฐ ๊น๋จน์๋ค
์ฝ๋
#include <string>
#include <vector>
#include <cmath>
using namespace std;
long long solution(int k, int d) {
long long answer = 0;
for(int i = 0; i <= d; i += k) {
int x = i;
int y = floor(sqrt((long)d * d - (long)i * i));
answer += y / k + 1;
}
return answer;
}
'์ฝ๋ฉํ ์คํธ ์ค๋น > ํ๋ก๊ทธ๋๋จธ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] N์ผ๋ก ํํ - C++ (0) | 2024.04.11 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค] ์กฐ์ด์คํฑ - C++ (0) | 2024.04.11 |
[ํ๋ก๊ทธ๋๋จธ์ค] ํ๋ก์ธ์ค - C++ (0) | 2024.04.08 |
[ํ๋ก๊ทธ๋๋จธ์ค] ์์ ๋์งํ - C++ (0) | 2024.04.04 |
[ํ๋ก๊ทธ๋๋จธ์ค] ์ฌ๋ฐ๋ฅธ ๊ดํธ - C++ (0) | 2024.04.04 |