๐ ๋ฌธ์
https://www.acmicpc.net/problem/6064
๐ ์ฒซ๋ฒ์งธ ํ์ด - ํ๋ ธ์ต๋๋ค
var n = Int(readLine()!)!
for _ in 0..<n {
let mnxy = readLine()!.split(separator: " ").map{ Int($0)! }
var year = 1
let maxYear = 40000
while true {
if (year - mnxy[2]) % mnxy[0] == 0, (year - mnxy[3]) % mnxy[1] == 0 {
print(year)
break
}
if year == maxYear {
print(-1)
break
}
year += 1
}
}
์ฒซ๋ฒ์ฌ ํ์ด๋ ๋ต์ ํ๋ ธ๋ค. ๊ทธ๋ฅ ๋ด๊ฐ maxYear์ 40000์ผ๋ก ๋๊ณ ํ์๊ธฐ ๋๋ฌธ์ด๋ค. ์นด์๋ฌ๋ ฅ์์ ๋ง์ฝ M๊ณผ N์ด 10, 12๋ก ์ฃผ์ด์ง๋ค๋ฉด, ์ต๋ ๋ ๋๋ 40000์ด ์๋๋ค. x์ y๊ฐ 10, 12๋ก ์ถ๋ ฅ๋๋ 60์ด ์ต๊ณ ๋ ๋๊ฐ ๋๋ค. ๋ฌด์จ ๊ณตํต์ ์ด๋๋ฉด, ์ฃผ์ด์ง๋ M๊ณผN์ ์ต์๊ณต๋ฐฐ์๊ฐ ํด๋น ์นด์๋ฌ๋ ฅ์ ์ต๋๋ ๋๊ฐ ๋๋ ๊ฒ์ด๋ค. ์ด๊ฒ์ ์ ํ ๊ณ ๋ คํ์ง ์์์ฑ ์ฝ๋๋ฅผ ์ง์ ๋ฌธ์ ๋ฅผ ํ๋ ธ๋ค.
๐ ๋๋ฒ์งธ ํ์ด - ์๊ฐ์ด๊ณผ
์ต์๊ณต๋ฐฐ์๋ฅผ ๊ตฌํ๋ ๊ณต์์ ์ถ๊ฐํด์ฃผ์๋ค.
var n = Int(readLine()!)!
for _ in 0..<n {
let mnxy = readLine()!.split(separator: " ").map{ Int($0)! }
var year = 1
let gcd = mnxy[0] > mnxy[1] ? gcd(mnxy[0], mnxy[1]) : gcd(mnxy[1], mnxy[0])
let maxYear = (mnxy[0] * mnxy[1]) / gcd
while true {
if (year - mnxy[2]) % mnxy[0] == 0, (year - mnxy[3]) % mnxy[1] == 0 {
print(year)
break
}
if year == maxYear {
print(-1)
break
}
year += 1
}
}
private func gcd(_ n: Int, _ m: Int) -> Int {
return m == 0 ? n : gcd(m, n%m)
}
gcd ๋ฉ์๋๋ฅผ ๋ง๋ค์ด์ ์ต๋๊ณต์ฝ์๋ฅผ ๋จผ์ ๊ตฌํด์ค๋ค์, ๋ ์์ ๊ณฑ์ ์ต๋๊ณต์ฝ์๋ก ๋๋ ์ค ๊ฒ์ด ์ต์๊ณต๋ฐฐ์๊ฐ ๋๋ ์ฑ์ง์ ์ด์ฉํด์ maxYear์ ๊ตฌํ๋ค.
์ด๋ ๊ฒ ํธ๋๊น, ์๊ฐ์ด๊ณผ๊ฐ ๋ฌ๋ค. ์ด์จ๋ ๋์ ์ฝ๋๋ year์ +1 ํด์ฃผ๋ฉด์, ์์ฑ๋๋ ๋ชจ๋ ์์ ๋ํ์ฌ ๊ฐ์ฅ ์ต๋๋ก for๋ฌธ์ ๋๋ฆฌ๊ฒ ๋๋ค. ์ด๋ถ๋ถ์์ ์๊ฐ๋ณต์ก๋๋ฅผ ์ค์ฌ์ผํ๋ค๊ณ ์๊ฐํ๋ค.
maxYear์ ์ ๋ถ ์ดํด๋ณด๋ ๋ฐฉ๋ฒ ๋์ , ๊ฒฝ์ฐ์์๋ฅผ ์ค์ฌ์ ๋ณด๋ ๋ฐฉ์์ผ๋ก ํ์ด์ผํ๋ค....
๐ ์ธ๋ฒ์งธ ํ์ด - ๋ง์์ต๋๋ค!
๐ M๊ณผ N์ ๊ตฌ๋ณํด์ ์๊ฐํด๋ณด์.
๋ด๊ฐ ์ฒ์ ํ์ดํ ๊ฒ์, M๊ณผ N์ ๋ชจ๋ ๋์์ ๊ณ ๋ คํ๋ฉด์ year์ +1์ฉํด์ฃผ์๋ค. ์ฌ๊ธฐ์ M๊ณผ N์ ๋ถ๋ฆฌํด์ ๋จ๊ณ๋ณ๋ก ์๊ฐํด๋ณด์.
๐ฌ (์์ ์ ๋ ฅ1) M = 10, N = 12
๊ทธ๋ฆผ์ฒ๋ผ ์ด๋ ๊ฒ 10๊ฐ, 12๊ฐ์ฉ ๋ฐ๋ณต๋๋ค. ๊ฒฐ๊ตญ ์ฐ๋ฆฌ์ ์นด์๋ฌ๋ ฅ์ ์ต๋ 60๊ฐ์ ๊ฐ์ ๊ฐ์ง๋ค. ๊ทธ๋ ๋ค๋ฉด, ํ๊ดํฌ ์น ํ ๋ถ๋ถ์์ ๋นจ๊ฐ๋ฉ์ด๋ฆฌ๋ 6๋ฉ์ด๋ฆฌ (60 / 10), ์ฐ๋์ ํ๊ดํฌ ๋ฉ์ด๋ฆฌ๋ 5๋ฉ์ด๋ฆฌ (60 / 12)๊ฐ ๋์ฌ ๊ฒ์ด๋ค.
๐ฌ ๊ทธ๋ผ X = 3 ์ธ ๊ฒฝ์ฐ๋ ๋ช๊ฐ์ง์?
๋จผ์ X๊ฐ 3์ธ ๊ฒฝ์ฐ๋ง ์ดํด๋ณด์. ์์์ ๋นจ๊ฐ๋ฉ์ด๋ฆฌ๋ 6๊ฐ๊ฐ ๋์จ๋ค๊ณ ํ๋ค. ์ฆ, X๊ฐ 3์ธ ๊ฒฝ์ฐ๋ 5๊ฐ์ง์ด๋ค.
X = 3 ์ธ ๊ฒฝ์ฐ -> ( maxYear / M) ๊ฐ
๐ฌ ๊ทธ๋ ๋ค๋ฉด ๊ฒฐ๊ตญ, X=3์ด๋ฉด์, Y=9์ธ ๊ฒฝ์ฐ๋ฅผ ์ฐพ์ผ๋ฉด ๋๋๊ฑฐ ์๋?
X = 3์ผ ๋๋, ๋ช๋ ์ผ๊น?
3๋ , 13๋ , 23๋ ,,, ์ด๋ ๊ฒ ๊ฐ ๊ฒ์ด๋ค. ์ด๊ฒ์ for๋ฌธ์ผ๋ก ๋ง๋ค์ด์ ๊ท์น์ ์ฐพ์์ฃผ๋ฉด ์๋์ฒ๋ผ ๋ ๊ฒ์ด๋ค.
for i in 0..<maxYear/M {
let year = i * M + X
}
year์ ๊ฐ๊ฐ 3, 13, 23, 33, 43, 53 ์ด๋ ๊ฒ ์ฌ์ฏ๊ฐ๊ฐ ๋์ค๊ฒ ์ง!?
๊ทธ๋ผ ๊ฐ๊ฐ 3, 13, 23,,,,์ผ๋ y = 9 ์ธ ๊ฒฝ์ฐ๋ฅผ ์ฐพ์์ฃผ์
year๊ฐ ๋ง์ฝ 3์ด๋ผ๋ฉด, y๋ 3์ด๋๋ค.
year๊ฐ ๋ง์ฝ 13์ด๋ผ๋ฉด, y๋ 1์ด ๋๋ค. y๋ N๋งํผ์ฉ ์ํํ๊ธฐ ๋๋ฌธ์ 12๋ก ๋๋ ์ค ๋๋จธ์ง๊ฐ์ ๊ฐ๋๋ค
์ด๊ฒ์ ์ฝ๋๋ก ์์ฑํด๋ณด์.
for i in 0..<maxYear/M {
let year = i * M + X
let y = year % N
}
๊ทผ๋ฐ ์ด๋ ๊ฒ ํ๋ฉด, ์์ธ์ฌํญ์ด ์๊ธด๋ค. ๋๋จธ์ง๊ฐ 0์ธ๊ฒฝ์ฐ y๋ 0์ด๋๋ค. ์ฌ์ค ์ฐ๋ฆฌ๋ 0์ด ์๋๋ผ N๊ทธ๋๋ก๋ฅผ ์ถ๋ ฅํด์ฃผ์ด์ผํ๋ค. ๊ทธ๋์ ์๋์ฒ๋ผ ์ผํญ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํด์ ๋๋จธ์ง๊ฐ 0์ธ๊ฒฝ์ฐ๋ฅผ ์ฒ๋ฆฌํด์ฃผ์๋ค.
for i in 0..<maxYear/M {
let year = i * M + X
let y = year % N == 0 ? N : year % N
}
์ด๋ ๊ฒ y๊น์ง ํ๋จํด์ฃผ๊ณ , ์ด y๊ฐ ์ ๋ ฅ๋ฐ์ Y(9)์ ๊ฐ๋ค๋ฉด, break ํด์ for๋ฌธ์ ํ์ถํด์ฃผ์.
์ ์ฒด ์ฝ๋๋ฅผ ๋ณด๋ฉด ์๋์ ๊ฐ๋ค.
์ด์ ์๋ ๋ฌด์กฐ๊ฑด 40000๋ฒ์ ๋์๋๊ฒ๊ณผ ๋ฌ๋ฆฌ, ์ต์์ ๊ฒฝ์ฐ์์ ๋งํผ๋ง for๋ฌธ์ ๋๊ฒ ๋๋ค.
var n = Int(readLine()!)!
for _ in 0..<n {
let mnxy = readLine()!.split(separator: " ").map{ Int($0)! }
let gcd = mnxy[0] > mnxy[1] ? gcd(mnxy[0], mnxy[1]) : gcd(mnxy[1], mnxy[0])
let maxYear = (mnxy[0] * mnxy[1]) / gcd
var isinCal = false
for i in 0..<maxYear / mnxy[0] {
let year = i * mnxy[0] + mnxy[2]
let y = year % mnxy[1] == 0 ? mnxy[1] : year % mnxy[1]
if y == mnxy[3] {
print(year)
isinCal = true
break
}
}
if !isinCal {
print(-1)
}
}
private func gcd(_ n: Int, _ m: Int) -> Int {
return m == 0 ? n : gcd(m, n%m)
}