๐ช [์นด์ ๋ฌ๋ ฅ]
6064๋ฒ: ์นด์ ๋ฌ๋ ฅ
์ ๋ ฅ ๋ฐ์ดํฐ๋ ํ์ค ์ ๋ ฅ์ ์ฌ์ฉํ๋ค. ์ ๋ ฅ์ T๊ฐ์ ํ ์คํธ ๋ฐ์ดํฐ๋ก ๊ตฌ์ฑ๋๋ค. ์ ๋ ฅ์ ์ฒซ ๋ฒ์งธ ์ค์๋ ์ ๋ ฅ ๋ฐ์ดํฐ์ ์๋ฅผ ๋ํ๋ด๋ ์ ์ T๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ํ ์คํธ ๋ฐ์ดํฐ๋ ํ ์ค๋ก ๊ตฌ์ฑ๋๋ค.
www.acmicpc.net
๐ ๋ฌธ์ ์ค๋ช
์ต๊ทผ์ ICPC ํ์ฌ๋๋ ๋จ์๋ฉ๋ฆฌ์นด์ ์์นด ์ ๊ตญ์ด ๋๋ผ์ด ๋ฌธ๋ช ์ ์ง๋ ์นด์ ์ ๊ตญ์ ํ ๋๋ก ํ์ฌ ์ธ์์ก๋ค๋ ์ฌ์ค์ ๋ฐ๊ฒฌํ๋ค. ์นด์ ์ ๊ตญ์ ๋ฐฑ์ฑ๋ค์ ํน์ดํ ๋ฌ๋ ฅ์ ์ฌ์ฉํ ๊ฒ์ผ๋ก ์๋ ค์ ธ ์๋ค.
- ๊ทธ๋ค์ M๊ณผ N๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๋ ๊ฐ์ ์์ฐ์ x, y๋ฅผ ๊ฐ์ง๊ณ ๊ฐ ๋ ๋๋ฅผ <x:y>์ ๊ฐ์ ํ์์ผ๋ก ํํํ์๋ค.
- ๊ทธ๋ค์ ์ด ์ธ์์ ์์ด์ ํด๋นํ๋ ์ฒซ ๋ฒ์งธ ํด๋ฅผ <1:1>๋ก ํํํ๊ณ , ๋ ๋ฒ์งธ ํด๋ฅผ <2:2>๋ก ํํํ์๋ค.
- <x:y>์ ๋ค์ ํด๋ฅผ ํํํ ๊ฒ์ <x':y'>์ด๋ผ๊ณ ํ์. ๋ง์ผ x < M ์ด๋ฉด x' = x + 1์ด๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด x' = 1์ด๋ค.
- ๊ฐ์ ๋ฐฉ์์ผ๋ก ๋ง์ผ y < N์ด๋ฉด y' = y + 1์ด๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด y' = 1์ด๋ค.
- <M:N>์ ๊ทธ๋ค ๋ฌ๋ ฅ์ ๋ง์ง๋ง ํด๋ก์, ์ด ํด์ ์ธ์์ ์ข ๋ง์ด ๋๋ํ๋ค๋ ์์ธ์ด ์ ํด ์จ๋ค.
- ์๋ฅผ ๋ค์ด, M = 10 ์ด๊ณ N = 12๋ผ๊ณ ํ์. ์ฒซ ๋ฒ์งธ ํด๋ <1:1>๋ก ํํ๋๊ณ , 11๋ฒ์งธ ํด๋ <1:11>๋ก ํํ๋๋ค. <3:1>์ 13๋ฒ์งธ ํด๋ฅผ ๋ํ๋ด๊ณ , <10:12>๋ ๋ง์ง๋ง์ธ 60๋ฒ์งธ ํด๋ฅผ ๋ํ๋ธ๋ค.
๋ค ๊ฐ์ ์ ์ M, N, x์ y๊ฐ ์ฃผ์ด์ง ๋, <M:N>์ด ์นด์ ๋ฌ๋ ฅ์ ๋ง์ง๋ง ํด๋ผ๊ณ ํ๋ฉด <x:y>๋ ๋ช ๋ฒ์งธ ํด๋ฅผ ๋ํ๋ด๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
๐๐จ ์ ์ถ๋ ฅ ๋ฐ์ดํฐ
[์ ๋ ฅ]
์ ๋ ฅ ๋ฐ์ดํฐ๋ ํ์ค ์ ๋ ฅ์ ์ฌ์ฉํ๋ค. ์ ๋ ฅ์ T๊ฐ์ ํ ์คํธ ๋ฐ์ดํฐ๋ก ๊ตฌ์ฑ๋๋ค.
์ ๋ ฅ์ ์ฒซ ๋ฒ์งธ ์ค์๋ ์ ๋ ฅ ๋ฐ์ดํฐ์ ์๋ฅผ ๋ํ๋ด๋ ์ ์ T๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ํ ์คํธ ๋ฐ์ดํฐ๋ ํ ์ค๋ก ๊ตฌ์ฑ๋๋ค.
๊ฐ ์ค์๋ ๋ค ๊ฐ์ ์ ์ M, N, x์ y๊ฐ ์ฃผ์ด์ง๋ค. (1 ≤ M, N ≤ 40,000, 1 ≤ x ≤ M, 1 ≤ y ≤ N)
์ฌ๊ธฐ์ <M:N>์ ์นด์ ๋ฌ๋ ฅ์ ๋ง์ง๋ง ํด๋ฅผ ๋ํ๋ธ๋ค.
3
10 12 3 9
10 12 7 2
13 11 5 6
[์ถ๋ ฅ]
์ถ๋ ฅ์ ํ์ค ์ถ๋ ฅ์ ์ฌ์ฉํ๋ค. ๊ฐ ํ ์คํธ ๋ฐ์ดํฐ์ ๋ํด, ์ ์ k๋ฅผ ํ ์ค์ ์ถ๋ ฅํ๋ค. ์ฌ๊ธฐ์ k๋ <x:y>๊ฐ k๋ฒ์งธ ํด๋ฅผ ๋ํ๋ด๋ ๊ฒ์ ์๋ฏธํ๋ค. ๋ง์ผ <x:y>์ ์ํด ํํ๋๋ ํด๊ฐ ์๋ค๋ฉด, ์ฆ, <x:y>๊ฐ ์ ํจํ์ง ์์ ํํ์ด๋ฉด, -1์ ์ถ๋ ฅํ๋ค.
33
-1
83
๐ ๋ฌธ์ ํ์ด
๋ฌธ์ ๋ฅผ ํ๋ฉด์ ์์ฑํ ์ฝ๋๋ค์ ๋ค์๊ณผ ๊ฐ๋ค.
โป [์ฐธ๊ณ ] ์๋ชป๋ ์ฒซ ๋ฒ์งธ ํ์ด
from sys import stdin
def get_year(max_x, max_y, val_x, val_y) -> int:
if val_x == val_y == 1:
return 1
for i in range(2, max_x * max_y + 1):
if (max_x - val_x) % i == 0 and (max_y - val_y) % i == 0:
return i
return -1
if __name__ == '__main__':
t = int(stdin.readline().rstrip())
ans_list = []
for i in range(t):
m, n, x, y = map(int, stdin.readline().split())
ans_list.append(str(get_year(m, n, x, y)))
ans = '\n'.join(ans_list)
print(ans)
์ฒซ ๋ฒ์งธ ํ์ด ์ฝ๋์ ๊ฒฝ์ฐ ์์ ๊ฐ์๋ค. ์ด์ ์ฃผ์ด์ง ํ ์คํธ ์ผ์ด์ค๋ฅผ ๋๋ ค๋ณด์๋๋ ๊ฒฐ๊ณผ๋ ์๋ง์ง์ฐฝ์ด์๋ค.
get_year()์ด๋ผ๋ ํจ์ ๋ด๋ถ์ ์กฐ๊ฑด๋ฌธ์ if (max_x - val_x) % i == 0 and (max_y - val_y) % i == 0๋ผ๊ณ ํ์๋๋ฐ, ํด๋น ์กฐ๊ฑด์์ด ์๋ชป๋์๊ธฐ ๋๋ฌธ์ด์๋ค. ์ฆ, ์ด๋ ํ์์ถฉ๋ถ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์กฐ๊ฑด์์ด ์๋๊ธฐ ๋๋ฌธ์ด๋ค.
์๋ฅผ ๋ค์ด max_x, max_y๊ฐ 10, 12์ด๊ณ val_x, val_y๊ฐ 4, 4๋ผ๊ณ ํด๋ณด์. ์ด ๊ฒฝ์ฐ, ์ ๋ต์ธ i๋ 4์ด์ด์ผ ํ๋ค.
ํ๋ i=2์ผ ๊ฒฝ์ฐ, max_x - val_x์ max_y - val_y ๋ชจ๋ 2๋ก ๋๋์ด ๋จ์ด์ง๋ฏ๋ก ์กฐ๊ฑด๋ฌธ์ ๋ง์กฑํด ๋ต์ผ๋ก ์ธ์๋๊ฒ ๋๋ค. ์ฆ ์ฆ i=4์ผ ๊ฒฝ์ฐ ์กฐ๊ฑด๋ฌธ์ ๋ง์กฑํ๊ธด ํ์ง๋ง ํด๋น ๊ฒฝ์ฐ์๋ง ๋ง์กฑํ๋ ๊ฒ์ด ์๋๋ฏ๋ก ํ์์ถฉ๋ถํ ์กฐ๊ฑด์ด ์๋๊ธฐ์ ์ด๋ ์๋ชป๋ ์กฐ๊ฑด๋ฌธ์ด๋ค. ๋ฐ๋ผ์ ํ์์ถฉ๋ถ ์๊ฑด์ ๋ง์กฑํ๋๋ก ์กฐ๊ฑด๋ฌธ์ ์์ ํ์ฌ ์ฝ๋๋ฅผ ์ฌ์์ฑํด์ฃผ์๋ค. ์ฝ๋๋ ์๋์ ๊ฐ๋ค.
๐ ์ฅ ๊ทธ๋ฅ ๋ค ์๋ชป๋ ๋ฏ? i๋ฅผ ๋๋ ์ผ๋๋๋ฐ i๋ก ๋๋ด๋ค. ํด๋น ํ์ด ๋ฌด์ํ๊ธฐ.
from sys import stdin
def get_year(max_x, max_y, val_x, val_y) -> int:
for i in range(1, max_x * max_y + 1):
if (i % max_x == val_x % max_x) and (i % max_y == val_y % max_y): # same as (i-1) % max_x == (val_x - 1)..
return i
return -1
if __name__ == '__main__':
t = int(stdin.readline().rstrip())
ans_list = []
for i in range(t):
m, n, x, y = map(int, stdin.readline().split())
ans_list.append(str(get_year(m, n, x, y)))
ans = '\n'.join(ans_list)
print(ans)
๋ ๋ฒ์งธ ํ์ด ์ฝ๋์ ๊ฒฝ์ฐ, ์ฒซ ๋ฒ์งธ ์ฝ๋์ ๋ฌธ์ ๋ฅผ ๋ณด์ํ์ฌ ์์ฑํ์๊ธฐ์ ๋ฐฑ์ค ์ฌ์ดํธ์์ ์ ๊ณตํ๋ ํ ์คํธ์ผ์ด์ค๋ฅผ ๋ง์กฑํ์๋ค. ํ๋ ์ ์ถ์ ์๊ฐ์ด๊ณผ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ ๊ฒ์ ํ์ธํ ์ ์์๋ค. ์ด๋ M๊ณผ N์ ๋ฒ์๊ฐ 1์ด์ 40,000 ์ดํ์ธ๋ฐ ์ ์ฒด ๊ฒฝ์ฐ์ ์์ธ M*N์ด 1,600,000,000๊ฐ์ง๊ฐ ๋์ด๋ฒ๋ฆฌ๋ฏ๋ก ์๊ฐ์ ํ์ธ 1์ด๋ฅผ ๋๊ธฐ๊ธฐ ๋๋ฌธ์ด์๋ค. (1์ด=1์ต)
๊ทธ๋ ๋ค๋ฉด ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ณ์ฐํด์๋ ์๋๋ค๋ ๊ฒ์ธ๋ฐ ์ด๋ฅผ ์ด๋ป๊ฒ ํด์ผํ ๊น?
๊ตฌํ๊ณ ์ ํ๋ ์๋ฅผ โก๋ผ๊ณ ํ์. โก๋ ๋ค์๊ณผ ๊ฐ์ ๋ ๊ฐ์ง ์กฐ๊ฑด์ ๋ง์กฑํด์ผ ํ๋ค.
- โก๋ฅผ M์ผ๋ก ๋๋ ๋๋จธ์ง = X (์ด๋, M๊ณผ X๋ ์์)
- โก๋ฅผ N์ผ๋ก ๋๋ ๋๋จธ์ง = Y (์ด๋, N๊ณผ Y๋ ์์)
์ด ์ค 1์ ๋ค๋ฅด๊ฒ ํํํด๋ณด๋ฉด 'โก = i * M + X'๋ผ๋ ๊ฒ์ด๋ค. ๋ํ ์ด๋ 2์ ์กฐ๊ฑด์ ๋ง์กฑํด์ผ ํ๋๋ฐ, 2์ ์กฐ๊ฑด์ ํด๋นํ๋ ์๋ N์ ์ฃผ๊ธฐ๋ก ๋ฐ๋ณต๋๋ค. ์ฆ ๊ตฌํ๊ณ ์ ํ๋ ์ โก๋ M*N์ด๋ด์ ๋ชจ๋ ์์์ ์ฐพ์ ํ์ ์์ด, ํด๋น ์์์ i๊ฐ 0<=i<=N์ธ ๋ฒ์์์ ์ฐพ๊ธฐ๋ง ํ๋ฉด ๋๋ค. ์ด๋ฅผ ์ด์ฉํ๋ฉด ๊ฒฝ์ฐ์ ์๊ฐ 1<=N<=40,000์ผ๋ก ํ์ฐํ ์ค๊ฒ ๋๋ค. ๋ฐ์ํ์ฌ ์ง ์ฝ๋๋ ์๋์ ๊ฐ๋ค.
from sys import stdin
def get_year(max_x, max_y, val_x, val_y) -> int:
for k in range(0, max_y):
if (k * max_x + val_x) % max_y == val_y % max_y:
return k * max_x + val_x
return -1
if __name__ == '__main__':
t = int(stdin.readline().rstrip())
ans_list = []
for i in range(t):
m, n, x, y = map(int, stdin.readline().split())
ans_list.append(str(get_year(m, n, x, y)))
ans = '\n'.join(ans_list)
print(ans)
→ ์ด๋ 1<=val_x<=N์ด๋ฏ๋ก %N์ ๊ฐ ์ฃผ์ํ๊ธฐ!
๐ ํ์ด/๊ฐ๋ ์ ๋ฆฌ
- ๋ธ๋ฃจํธํฌ์ค ๋ฌธ์ ์์ ๊ฒฝ์ฐ์ ์๊ฐ ๋๋ฌด ๅค!
๐ M*N = 16์ต์ผ๋ก ์๊ฐ์ด ์ด๊ณผ๋๊ธฐ ๋๋ฌธ.
→๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ ํด๋ณด๊ธฐ.
→ ๊ฑด๋ ๋ฐ์ด ๊ตฌํ ์ ์๋ ๊ฒฝ์ฐ ๊ณ ๋ คํด๋ณด๊ธฐ.
→ ์ํ, ๋ ์ค ํ๋์ ๋ฒ์๋ง ๊ณ ๋ คํด์ผ ๊ฒ ๊ตฌ๋๋ผ๊ณ ์ถ์ธก! ๐ ๋ชจ๋๋ฌ(%) TIP
→ X % N = X'์ด๋ฉด, (X-X')%N = 0์ด๋ค.- โญ %N์ ๊ฐ๊ณผ ๊ฒฐ๊ณผ๊ฐ์ ๋ฒ์๊ฐ ๋ค๋ฅผ๋ ์ฃผ์ํ๊ธฐ! โญ
→ 0<= %N <= N-1์ธ๋ฐ 1<=๊ฒฐ๊ณผ๊ฐ<=N์ธ ๊ฒฝ์ฐ!
'Algorithm > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [๋ฐฑ์ค] 1463. 1๋ก ๋ง๋ค๊ธฐ (0) | 2022.03.07 |
|---|---|
| [๋ฐฑ์ค] 14500. ํ ํธ๋ก๋ฏธ๋ ธ (์์ฑ ไธญ) (0) | 2022.03.02 |
| [๋ฐฑ์ค] 1107. ๋ฆฌ๋ชจ์ปจ (0) | 2022.03.01 |
| [๋ฐฑ์ค] 1476. ๋ ์ง ๊ณ์ฐ (0) | 2022.03.01 |
| [๋ฐฑ์ค] 3085. ์ฌํ ๊ฒ์ (0) | 2022.02.23 |