- Published on
Codility - Number of Disc Intersections
- Author

- Name
- yceffort
Number of Disc Intersections
๋ฌธ์
N๊ฐ์ ๋์คํฌ๊ฐ ์กด์ฌํ๊ณ , ๋์คํฌ๋ ๊ฐ๊ฐ 0~ N-1์ ๋ฒํธ๋ฅผ ๊ฐ์ง๋ค. ์ด๋ A๋ผ๋ ๋ฐฐ์ด์์ ํํ๋๋๋ฐ, A[N] ๋ ํด๋น ๋์คํฌ์ ๋ฐ๊ฒฝ์ ์๋ฏธํ๋ค.
A[0] = 1
A[1] = 5
A[2] = 2
A[3] = 1
A[4] = 4
A[5] = 0

์ด ๋, ๊ต์ฐจํ๋ ๋์คํฌ์ ์๋ฅผ ๊ตฌํ๋ผ.
ํ์ด
function solution(A) {
const length = A.length
let intersections = 0
// ์์ ์ ๊ณผ ๋์ ์ ์ ์ฅํ๋ ์๋ก์ด ๋ฐฐ์ด์ ๋ง๋ ๋ค.
// [ [ -1, 1 ], [ -4, 6 ], [ 0, 4 ], [ 2, 4 ], [ 0, 8 ], [ 5, 5 ] ]
const info = A.map((disc, index) => [index - disc, index + disc])
// ์ด๋ฅผ ์์์ ์ด ์์ ์๋๋ก ๋ฐฐ์ดํ๋ค.
// [ [ -4, 6 ], [ -1, 1 ], [ 0, 4 ], [ 0, 8 ], [ 2, 4 ], [ 5, 5 ] ]
const sorted = info.sort((a, b) => a[0] - b[0])
// ๊ฐ์ฅ ๋ฐ๊นฅ์ ์๋ ์๋ถํฐ ๋๋ค
for (let i = 0; i < sorted.length; i++) {
// const targetStart = sorted[i][0]
const targetEnd = sorted[i][1]
// ๊ทธ ๋ค์ ๊ฒ ๋ถํฐ ๋๋ค
for (let j = i + 1; j < sorted.length; j++) {
const compareStart = sorted[j][0]
// const compareEnd = sorted[j][1]
// ๊ฒน์น๋ ๊ฒฝ์ฐ์๋ง
if (compareStart <= targetEnd) {
intersections += 1
// ๊ฒน์น๋ ํ์๊ฐ ํน์ ํ์๋ฅผ ๋์ด๊ฐ๋ฉด -1์ ๋ฆฌํดํ๋๋ค.
if (intersections > 10000000) {
return -1
}
} else {
// ์์์ ์์ผ๋ก ์ ๋ ฌํ์ผ๋ฏ๋ก, ์ด ์ดํ๋ ์๋ด๋ ์๊ฒน์น๋ค. ๋ฐ๋ผ์ break
break
}
}
}
return intersections
}
ํ๋์ฉ ๊ณ ๋ฏผํด๋ณด์. 1๊ณผ 5๊ณผ ๊ต์ฐจํ๊ธฐ ์ํด์๋ ์ด๋ป๊ฒ ํด์ผํ ๊น? ๋ ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ ์ผ๋จ 4๋ค. ๋ ๋ฐ์ง๋ฆ (๋ฐ๊ฒฝ)์ ํฉ์ด 4๋ฅผ ๋์ด์ผ ํ๋ค. for ๋ฌธ์ ๋๋ฉด์ ๋ ์ฌ์ด์ ์ฐจ์ด์ ๋ฐ์ง๋ฆ์ ํฉ์ ๊ณ์ฐํด์ ๊ตฌํด๋ณด๋ฉด ๋ ๊น?
๋ผ๊ณ ํ์ง๋ง ํ์์์ ์๋ฌ๊ฐ ๋ฌ๋ค. for๋ฌธ์ ์ด์ค์ผ๋ก ๋์์ผ ํ๊ธฐ ๋๋ฌธ์ O(N^2)๋ณต์ก๋๊ฐ ๋์จ๋ค. break๊ฐ ์์ด์ ๋นผ๋ ๋ฐ๋ ๋ชปํ๋ค.
๋์ด ๊ฒน์น๋์ง ์๊ฒน์น๋์ง ํ์ธํด๋ณผ ์ ์๋ ๋ฐฉ๋ฒ์ด ์์๊น? ๊ฐ ๊ทธ๋ฆฌ๋ ์๋ง๋ค ์์์ ๊ณผ ๋์ ์ [s, e] ์์ผ๋ก ์ ์ฅํด ๋์๋ค๊ฐ, ๋น๊ต ๋์์ ๋์ ๊ณผ ์์์ ์ด ๊ฒน์น๋์ง ํ์ธํด๋ณด๋ฉด ๋ ๊ฒ์ด๋ค.