Problem
Solution
ํด๋น ๋ฌธ์ ๋ ํจ์จ์ฑ์ด ํต์ฌ์ธ ๋ฌธ์ ์์ต๋๋ค.
์ต๋ ํ๊ณผ ์ด์ด ๊ฐ 10^9, ์ต๋ ์ฟผ๋ฆฌ ๊ฐฏ์๊ฐ 20๋ง์ผ๋ก ์ด๋ง์ด๋งํ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๊ณ ์์ด ๋ง์ฝ ๋ชจ๋ ์์น์์ ์๋ฎฌ๋ ์ด์ ์ ๋๋ฆด ๊ฒฝ์ฐ
์ต๋ 10^9 * 10^9 * 200000 ์ด ๋ฉ๋๋ค.
์๊ฐ์ด๊ณผ๋ฅผ ํผํ๊ธฐ ์ํด์ ๋ชฉ์ ์ง์์๋ถํฐ ์ฟผ๋ฆฌ์ ์ญ์์ผ๋ก ๋๋์๊ฐ๋ฉด์ ๊ฐ๋ฅํ ๋ฒ์๊ฐ ์ด๋๊น์ง์ธ์ง๋ฅผ
์ฒดํฌํ๋ ๊ฒ์ด ์ค์ํ์ต๋๋ค.
์ด๋ก ์ค๋ช
์๋์ ๊ฐ์ด ๋ชฉ์ ์ง์ ์ฟผ๋ฆฌ๊ฐ ์๋ค๊ณ ๊ฐ์ ํ๊ฒ ์ต๋๋ค.( ๋ฌธ์ ์์ 2๋ฒ์ ๋๋ค.)
๊ฐ์ฅ ๋จผ์ ์์ํ ๋ ๋ชฉ์ ์ง ๊ทธ ์์ฒด์ ๋ฒ์์ ๋๋ค. (1,0)
์ฌ๊ธฐ์ ์ญ์์ผ๋ก ์คํ์์ผ๋ณด๋ฉด ๊ฐ์ฅ ๋ง์ง๋ง ์ฟผ๋ฆฌ๊ฐ ์๋ก ์ด๋ํ๋ ๊ฒ์ด์๊ณ ํ์ฌ ๋ณ์ ์์น์ y๊ฐ 0์ด๋ฏ๋ก
์ฟผ๋ฆฌ๊ฐ ์คํ๋๊ธฐ ์ ์์น๋ ํ์ฌ์์น ๋๋ ๋ฐ๋ก ์๋ ์์น์์ ๊ฒ์ ๋๋ค.
๊ทธ๋ฌ๋ฉด ๋ชฉ์ ์ง์ ๋๋ฌํ๊ธฐ ์ํ ๋ฒ์๊ฐ ์๋๋ก ํ์ฅ๋ฉ๋๋ค.
๊ทธ ๋ค์ ์ฟผ๋ฆฌ๋ฅผ ์คํํด๋ณด๋ฉด ์ผ์ชฝ์ผ๋ก ์ด๋ํ ๊ฒ์ ๋๋ค.
์ผ์ชฝ์ผ๋ก ์ด๋ํ์ ๋ ๋ชฉ์ ์ง์ ์์น๊ฐ ๋๊ธฐ ์ํด์ (2,0)์์ ์ด๋ํ ๊ฒ์ด๋ฏ๋ก ๋ณ์ ์์น๋ฅผ
2,0์ผ๋ก ์ด๋ํด์ค๋๋ค.
๊ทธ ๋ค์ ์ฟผ๋ฆฌ๋ ์์ชฝ์ผ๋ก ์ธ ๋ฒ ์ด๋ํ ๊ฒ์ ๋๋ค.
๋ณ์ y์์น๊ฐ 0์ด๋ฏ๋ก ํ์ 3์ค ๋ ํ์ฅํ ์ ์์ง๋ง ์์์์ ์ต๋ ํ์ ๊ธธ์ด๊ฐ 2์ด๋ฏ๋ก
ํ์ฅ์ํฌ ์๊ฐ ์์ต๋๋ค.
...
์ด๋ฐ ์์ผ๋ก ์ฃผ์ด์ง ๊ฒฉ์ ๋ฒ์ ๋ฐ๊นฅ์ผ๋ก ์คํ๋๋ ์ฟผ๋ฆฌ๊ฐ ์๋ค๋ฉด ๊ฐ๋ฅํ ๋ฒ์๋ฅผ ํ์ฅ์์ผ์ฃผ๊ณ
์์ผ๋ก ์คํ๋๋ ์ฟผ๋ฆฌ๊ฐ ์๋ค๋ฉด ๋ชฉ์ ์ง๋ฅผ ์ด๋์์ผ์ค๋๋ค.
๊ทธ๋ ๊ฒ ๋ชฉ์ ์ง๊น์ง ๋์ฐฉํ ์ ์๋ ๋ฒ์๋ฅผ ๊ตฌํด์ ๋ฐํํด์ค๋๋ค.
์ฝ๋ ์ค๋ช
1. ์ฟผ๋ฆฌ๋ฅผ ์ญ์์ผ๋ก ์คํ์ํจ๋ค.
for query in queries.reversed() {
if !isEdge(query: query) {
if !checkRightQuery(query: query) { return 0 }
moveStart(query: query)
}
extendEnd(query: query)
}
2. ๊ฐ์ฅ์๋ฆฌ์ธ์ง ์๋์ง ํ์ธํ๋ค.
func isEdge(query:[Int]) -> Bool {
return (query[0] == 0 && range.startX == 0) || (query[0] == 1 && range.endX == range.M) || (query[0] == 2 && range.startY == 0) || (query[0] == 3 && range.endY == range.N)
}
3. ๊ฐ์ฅ์๋ฆฌ๋ผ๋ฉด ๋ฒ์๋ฅผ ํ์ฅ์์ผ์ค๋ค.
func extendEnd(query:[Int]) {
switch query[0] {
case 0:
range.endX = min(range.M,range.endX+query[1])
case 1:
range.startX = max(0,range.startX-query[1])
case 2:
range.endY = min(range.N,range.endY+query[1])
default:
range.startY = max(0,range.startY-query[1])
}
}
4. ๊ฐ์ฅ์๋ฆฌ๊ฐ ์๋๋ผ๋ฉด ์ด๋์์ผ์ค๋ค.
์ด๋์์ผ์ฃผ๋ ๋ฐฉ๋ฒ์ ์์๊ณผ ๋์ ๋์์ ๋๋ ค์ฃผ๋ฉด ๋ฉ๋๋ค.
func moveStart(query:[Int]){
switch query[0] {
case 0:
range.startX = min(range.M,range.startX+query[1])
case 1:
range.endX = max(0,range.endX-query[1])
case 2:
range.startY = min(range.N,range.startY+query[1])
default:
range.endY = max(0,range.endY-query[1])
}
}
5. ์ฌ๋ฐ๋ฅธ ์ฟผ๋ฆฌ์ธ์ง ํ์ธํด์ค๋ค.
๋ชฉ์ ์ง๋ฅผ ์ด๋ํด์ค์ผ ํ๋ ์ฟผ๋ฆฌ๊ฐ ๋์์ ๋ ์ฃผ์ด์ง ๊ฒฉ์๋ณด๋ค ๋ ํฌ๋ค๋ฉด ์๋ชป๋ ์ฟผ๋ฆฌ์ด๋ฏ๋ก 0์ ๋ฐํํด์ค๋๋ค.
(ํ ์คํธ ์ผ์ด์ค 33๋ฒ 34๋ฒ์ ์ํ ์ฝ๋)
func checkRightQuery(query:[Int]) -> Bool {
switch query[0] {
case 0:
if range.startX+query[1] > range.M { return false }
case 1:
if range.endX-query[1] < 0 { return false }
case 2:
if range.startY+query[1] > range.N { return false }
default:
if range.endY-query[1] < 0 { return false }
}
return true
}
6. ์ฌ๋ฐ๋ฅธ ์ฟผ๋ฆฌ๋ผ๋ฉด ๋ฒ์๋ฅผ ๋ฐํํ๋ค.
return Int64(range.getArea)
Source Code
P.S
๋ฌธ์ ์ ์ดํด๋ฅผ ๋๊ธฐ ์ํ ์๋ฎฌ๋ ์ด์ ์ ๋ณด๊ณ ์์ํ๋ ๊ฒ์ด ํจ์ ์ด์๋ค.
์๋ฎฌ๋ ์ด์ ์ ๋ณด๋ฉด ๋น์ฐํ ์์ฐจ์ ์ผ๋ก ์คํํด์ ์ฝ๋๋ฅผ ์ง์ผํ ๊ฒ ๊ฐ์ ๋๋์ธ๋ฐ ์คํ๋ ค ๋ฐ๋๋ก ์๊ฐํด์ผ ํ๋ค.
๋ํ 33๋ฒ,34๋ฒ ํ ์คํธ ์ผ์ด์ค๋ ๋ชฉ์ ์ง์ ๋๋ฌํ์ง ์๋ ์๋ชป๋ ์ฟผ๋ฆฌ๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ฒ์ด์๋ค.
์ด๊ฑด ์ข ์ต์ง๋ก ์ฃ์ง ์ผ์ด์ค๋ฅผ ๋ง๋ค์ด๋ธ ๊ฒ์ด ์๋๊ฐ๋ผ๋ ์๊ฐ์ด ๋ ๋ค.
์๋ฌดํผ ์ด ๋ฌธ์ ๋ฅผ ๋์ผ๋ก ์ด๋ฒ ๋ ๋ ๋ชฉํ์๋ ํ๋ก๊ทธ๋๋จธ์ค 3๋จ๊ณ ๋ฌธ์ ๋ฅผ ๋ชจ๋ ํ์๋ค!
์ผ์ฃผ์ผ์ ํ ๋ฌธ์ ์ฉ๋ง ๊พธ์คํ ํ์๋ ์๊ฐ์ผ๋ก ์กฐ๊ธ ์ค๋ ๊ฑธ๋ ธ์ง๋ง ๋ฟ๋ฏํ๋ค..
ํ๋ก๊ทธ๋๋จธ์ค ์์๋ 257๋ฑ์ ๋ฌ์ฑํ๊ณ ๋ค์ ๋ ๋์ 4๋จ๊ณ,5๋จ๊ณ๋ฅผ ๋ชจ๋ ํธ๋ ๋ชฉํ๋ก ๋ฌ๋ ค๊ฐ์ผ๊ฒ ๋ค.
๋๊ธ