๋งค๋ด์ฒ ์๊ณ ๋ฆฌ์ฆ์ด๋?
๋ฌธ์์ด S๊ฐ ์ฃผ์ด์ง ๋, ํฐ๋ฆฐ๋๋กฌ ๋ถ๋ถ ๋ฌธ์์ด์ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ปํ๋ค.
ํฐ๋ฆฐ๋๋กฌ ๋ถ๋ถ ๋ฌธ์์ด์ S์ ๋ถ๋ถ ๋ฌธ์์ด ์ค ํฐ๋ฆฐ๋๋กฌ์ธ ๊ฒฝ์ฐ๋ฅผ ์๋ฏธํ๋ค(banana์์ anana๊ฐ ๋ถ๋ถ ๋ฌธ์์ด ํฐ๋ฆฐ๋๋กฌ์ด๋ค).
๋ชจ๋ i์ ๋ํด i๋ฒ ๋ฌธ์๊ฐ ์ค์ฌ์ธ ์ต๋ ๊ธธ์ด์ ํฐ๋ฆฐ๋๋กฌ ๋ถ๋ถ๋ฌธ์์ด์ ๊ฒ์ํ๋ ์๊ณ ๋ฆฌ์ฆ.
ํฐ๋ฆฐ๋๋กฌ์ ๊ธธ์ด๋ ์ฃผ๋ก ํฐ๋ฆฐ๋๋กฌ์ ๋ฐ์ง๋ฆ์ ํํ๋ก ์ ์ฅ๋๋ค(๋ฐ์ง๋ฆ์ด๋, ํฐ๋ฆฐ๋๋กฌ์ ์ค์ฌ์ผ๋ก๋ถํฐ ๊ฐ์ฅ ๋จผ ๋ฌธ์๊ฐ ์ผ๋ง๋ ๋จ์ด์ ธ ์๋์ง๋ฅผ ํ์ธํ๊ธฐ ์ํ ๊ฒ์ด๋ค(aba์์ ๋ฐ์ง๋ฆ์ 1์ด ๋๋ค).
ํฐ๋ฆฐ๋๋กฌ์ ๊ธธ์ด๊ฐ i๋ผ๋ฉด ๋ฐ์ง๋ฆ์ (i -1) / 2๊ฐ ๋๋ค.
๋งค๋ด์ฒ ์๊ณ ๋ฆฌ์ฆ์ ์์๋ณด๊ธฐ ์ ์ ํฐ๋ฆฐ๋๋กฌ์ด ์ ํํ ๋ฌด์์ธ์ง ์ง๊ณ ๋์ด๊ฐ์.
ํฐ๋ฆฐ๋๋กฌ(ํ๋ฌธ, palindrome)
๋ค์ง์ด๋ ๊ฐ์ ๋ฌธ์์ด์ ๋ปํ๋ค.
๊ฑฐ๊พธ๋ก ์ฝ์ด๋ ๊ฐ์ ๋ฌธ์์ด์ด ํฐ๋ฆฐ๋๋กฌ์ ์์ด๋ค.
ํ ๊ธ์๋ก ์ด๋ฃจ์ด์ง ๋ชจ๋ ๋ฌธ์์ด์ ํ๋ฌธ์ด๋ค.
- a, b, c ๋ฑ๋ฑ
๋ค์๊ณผ ๊ฐ์ ๋ฌธ์์ด์ ๋ชจ๋ ํฐ๋ฆฐ๋๋กฌ์ด๋ค.
- bob, abcba, level ๋ฑ๋ฑ
๋ค์๊ณผ ๊ฐ์ ๋ฌธ์์ด์ ๋ชจ๋ ํ๋ฌธ์ด ์๋๋ค.
- banana, array, manacher ๋ฑ๋ฑ
ํฐ๋ฆฐ๋๋กฌ์ ์ฑ์ง
ํฐ๋ฆฐ๋๋กฌ์ ๊ฑฐ๊พธ๋ก ์ฝ์ด๋ ์๋ ๋ฌธ์์ด๊ณผ ๋์ผํ๋ค(์ ์์ ๊ฐ์)
๊ฐ ํฐ๋ฆฐ๋๋กฌ์ ์ค์ฌ์ด ๋๋ ์ถ์ ๊ฐ์ง๋ค.
ํฐ๋ฆฐ๋๋กฌ์ ๊ธธ์ด๊ฐ n์ผ ๋ n์ด ํ์์ธ ๊ฒฝ์ฐ๋ (n+1) / 2๋ฒ์งธ ๋ฌธ์๊ฐ ์ค์ฌ์ด ๋๊ณ ,
n์ด ํ์์ธ ๊ฒฝ์ฐ, n / 2๋ฒ์งธ, n / 2 +1๋ฒ์งธ ๋ฌธ์ ์ฌ์ด๊ฐ ์ถ์ด ๋๋ค.
ํฐ๋ฆฐ๋๋กฌ์ ์๋ค์ ๊ฐ์ ๋ฌธ์๋ฅผ ๋ถ์ด๋ฉด ๊ณ์ ํ๋ฌธ์ด ๋๋ค.
์๋ค์ ๊ฐ์ ๋ฌธ์๋ฅผ ๋ถ์ผ ๊ฒฝ์ฐ, ๋ค์ง์์ ๋๋ ์๋ค์ ๊ฐ์ ๋ฌธ์๋ฅผ ๋ถ์ด๊ฒ ๋๊ธฐ ๋๋ฌธ(aba -> aabaa: ๋ ๋ค ํฐ๋ฆฐ๋๋กฌ์ด๋ค).
Manacher ์๊ณ ๋ฆฌ์ฆ - ์์
S = banana, A[i]: i๋ฒ ๋ฌธ์๋ฅผ ์ค์ฌ์ผ๋ก ํ์ ๋ ์ต๋ ๋ฐ์ง๋ฆ์ผ ๋
A[0] = 0: banana
A[1] = 0: banana
A[2] = 1: banana
A[3] = 2: banana
A[4] = 1: banana
A[5] = 0: banana
์์ ๊ฐ์ ํฐ๋ฆฐ๋๋กฌ์ ๋ง๋ค ์ ์๋ค(๊ธ์๊ฐ ์ด๋ก์์ธ ๋ถ๋ถ์ด ํฐ๋ฆฐ๋๋กฌ์ด๋ค).
A[i]๋ฅผ ๋๋ฉด์ A[i]๋ฅผ ํฐ๋ฆฐ๋๋กฌ์ ์ค์ฌ์ผ๋ก ์ผ๊ณ ์๋ค๋ก ๋๋ ค๊ฐ๋ฉด์ ๊ฐ์ ๊ฐ์ด ์๋์ง ์ฒดํฌํ๋ ๊ฒ์ด๋ค.
์๊ณ ๋ฆฌ์ฆ์ ๊ณ์ฐ
A[i]๋ฅผ 0์ผ๋ก ์ด๊ธฐํํ๊ณ ,
S[i - A[i] - 1]์ด๋ S[i + A[i] + 1]์ด ๊ฐ๋ค๋ฉด A[i]๋ฅผ 1์ฉ ๋๋ ค ์ค๋ค.
์์ ์๋ฅผ ์์๋ก ๋ค๋ฉด i๊ฐ 1์ผ ๋, S[i - A[i] - 1]๋ S[0]๊ฐ ๋๊ณ , S[i + A[i] + 1]๋ S[2]๊ฐ ๋๋ค.
๋ ๋ฌธ์๊ฐ ๋ฌ๋ฆฌ์ง๊ฑฐ๋ ๋ฌธ์์ด์ ๋์ ๋๋ฌํ ๋๊น์ง ๋ฐ๋ณตํ๋ค.
์ต์ ํ ๊ณ์ฐ
๋ฌธ์์ด์ ๋์นญ์ฑ์ ์ด์ฉํด A[i]๋ฅผ ๋น ๋ฅด๊ฒ ๊ณ์ฐํด ์ค ์ ์๋ค.
์ด๋ค ๋์นญ์ถ์ด j์ ์์ ๋, i์ 2j-i๊ฐ ์์๋, ๋ค์๊ณผ ๊ฐ์ ๊ณต์์ด ์ฑ๋ฆฝ๋๋ค.
A[i] == A[2j-i]
i + A[2j - i]๊ฐ j + A[j] ์ด์์ธ ๊ฒฝ์ฐ๋ j +A[j] + j๊ฐ ๋ณด์ฅ๋๋ค.
์ฌ์ง์ ํ๋ ์ ์ด ์ด๋ก ์ ์ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ๋ ์์ธ ์ฌํญ์ด ๋ ์ ์์ผ๋ฏ๋ก ๋ค๋ฅธ ๋ฐฉ์ธ์ ์ ์ํ๊ฒ ๋ค.
j + A[j]๊ฐ ๊ฐ์ฅ ํฐ j๋ฅผ ๊ณ ๋ฅธ๋ค.
i + A[2j - i]๊ฐ j + A[j]๋ณด๋ค ์์ ๊ฒฝ์ฐ๋ A[i] = Z[2j - i]์ด๋ค.
๊ทธ๋ ์ง ์์ผ๋ฉด, Z[i]๋ฅผ j + A[j] - i๋ถํฐ ์์ํด 1์ฉ ๋๋ ค๊ฐ๋ฉด์ ๊ณ์ฐํ๋ค.
์์ - ์ต๋ ๊ธธ์ด์ ํฐ๋ฆฐ๋๋กฌ ๋ถ๋ถ ๋ฌธ์์ด
Manacher ์๊ณ ๋ฆฌ์ฆ์ 1ํ ์ํํ๋ค.
๊ฐ ๋ฌธ์๋ฅผ ์ค์ฌ์ผ๋ก ํ ์ต๋์ ๊ธธ์ด ๋ถ๋ถ ๋ฌธ์์ด ์ค ๊ฐ์ฅ ๊ธด ๊ฒ์ ์ฐพ๋๋ค.
๋ชจ๋ ํ๋ฌธ์ ์ค์ฌ์ถ์ ๊ฐ์ง๋ฏ๋ก ๋ฌธ์ ํด๊ฒฐ์ด ๋ ๊น? ์ง์ ๊ธธ์ด์ ํ๋ฌธ์ ์ค์ฌ์ด ๋๋ ๋ฌธ์๊ฐ 2๊ฐ์ด๋ฏ๋ก ํ์์ด ๋ถ๊ฐํ๋ค.
ํฐ๋ฆฐ๋๋กฌ์ด ์ง์์ธ ๊ฒฝ์ฐ์๋ S์ ๋ฌธ์ ์ฌ์ด์ฌ์ด์ ํน์๊ธฐํธ๋ฅผ ๋ผ์ด๋ค. ๋งจ ์ ๋งจ๋ค ํฌํจ.
์) ababa -> ?a?b?a?b?a
๋ผ์ธ ๋ฌธ์๊ฐ ๋ฌธ์์ด์ ์๋ ๋ฌธ์์ผ ํ์๋ ์๋ค.
์ ๋ฆฌ
๋งค๋ด์ฒ ์๊ณ ๋ฆฌ์ฆ์ ์ค์ง ํฐ๋ฆฐ๋๋กฌ์ ์ธ ๋๋ง ์ฌ์ฉํ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
๋ฒ์ฉ์ฑ์ ๋จ์ด์ง ์ ์์ด๋ ๋ถ๋ถ ํฐ๋ฆฐ๋๋กฌ์ ๋น ๋ฅด๊ฒ ๊ตฌํ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ด๊ธฐ์ ๋น ๋ฅด๊ฒ ์ดํดํด์ ์ฝ๋์์ ์จ๋จน์ ์ ์๋๋ก ํด์ผ๊ฒ ๋ค..(์์ง์ ์ดํด๊ฐ ์ด๋ ต๋ค)
'๐ | Kotlin > ๐ค | ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ๋งค๊ฐ๋ณ์ ํ์(Parametric Search)๊ณผ ์ด๋ถ ํ์(Binary Search) (0) | 2024.06.26 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ๊ทธ๋ํ ํ์ ์๊ณ ๋ฆฌ์ฆ(DFS, BFS) (0) | 2024.06.22 |
[์๊ณ ๋ฆฌ์ฆ] ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ(Greedy Algorithm) (0) | 2024.06.18 |
[์๊ณ ๋ฆฌ์ฆ] ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ(Dynamic Programming) (0) | 2024.06.12 |
[Kotlin] ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ ์๊ณ ๋ฆฌ์ฆ (0) | 2022.10.24 |