LCS(Longest Common Subsequence, ์ต์ฅ ๊ณตํต ๋ถ๋ถ ์์ด) ๋ฌธ์ ๋ ๋ ์์ด์ด ์ฃผ์ด์ก์ ๋, ๋ชจ๋์ ๋ถ๋ถ ์์ด์ด ๋๋ ์์ด ์ค ๊ฐ์ฅ ๊ธด ๊ฒ์ ์ฐพ๋ ๋ฌธ์ ์ด๋ค.
์๋ฅผ ๋ค์ด, ACAYKP ์ CAPCAK์ LCS๋ ACAK๊ฐ ๋๋ค.
์ฒซ์งธ, ๋์งธ ์ค์ ๋ ๋ฌธ์์ด์ด ์ฃผ์ด์ง๊ณ , ๋ฌธ์์ด์ ์ํ๋ฒณ ๋๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์๊ณ , ์ต๋ 1000๊ธ์๋ก ์ด๋ฃจ์ด์ ธ์๋ค.
์ฒซ์งธ ์ค์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ๋ฌธ์์ด์ LCS์ ๊ธธ์ด๋ฅผ ์ถ๋ ฅํ๋ค.
์ด ๋ฌธ์ ๋ ์ ํ์ ์ธ dynamic programming ๋ฌธ์ ์ด๋ค. ํ์์ ์ผ๋ก ์์์ผ ํ๋ ๋ฌธ์ ๋ผ๊ณ ํจ.
์ด์จ๋ ๋ ๋ฌธ์์ด์ ๋น๊ตํ๋ฉด์ ๋ต์ ์ฐพ์์ผํ๋๋ฐ, ๋น๊ตํ๋ ๋ฐฉ๋ฒ์ ์ฐพ์๋ด๋๊ฒ ์ข ๊น๋ค๋ก์ด ๊ฒ ๊ฐ๋ค. ๊ฐ ๋ฌธ์์ด์ '' ๋น ๋ฌธ์์ด์์ ์ฃผ์ด์ง ๋ฌธ์์ด ํํ๋ก ํ๋์ฉ ์ถ๊ฐํ๋ฉด์ ๋ ๋ฌธ์์ด์ ๋น๊ตํ๋ค๊ณ ์๊ฐํ๋ฉด ์ฝ๋ค.
์ฒซ ์ค์ ๋ณด๋ฉด, ๋ฌธ์์ด A์ ์ฒซ๋ฒ์งธ ๋ฌธ์์ด ๋ถํฐ ๋น๊ตํ๋ค. ๋ฌธ์์ด B๋ ''๋ถํฐ ์์ํ๋ค.
(A, '') ์ ๊ฐ์ด ๋น ๋ฌธ์์ด๊ณผ ๋น๊ตํ์ ๋๋, ๊ณตํต๋๋ ๋ถ๋ถ์ด ์๊ธฐ ๋๋ฌธ์ 0์ผ๋ก ์ด๊ธฐํ ๋์ด์๋ค.
(A, C)
A, C๋ ๊ฐ์ง ์๋ค. ํด๋น ๋จ๊ณ์์ ๊ฐ์ ธ๊ฐ๋ ๊ฐ์ 0. ์ด์ ๋จ๊ณ๋ค์์ ์ค๋ณต๋๋ ๋ฌธ์์ด์ด ์์๋ค๋ฉด ์ถ๊ฐ ๋์์ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ (A, ''), ('', C) ๋น๊ต์์ ์ป์ ๊ฐ๋ค ์ค ์ต๋ ๊ฐ์ ๊ฐ์ ธ์จ๋ค(์์ ํํฌ์ ๋ถ๋ถ๋ค). ๋๋ค 0 ์ด๋ฏ๋ก, A,C ๋น๊ต ๋จ๊ณ์์ ์ต๋ ๋ถ๋ถ ์์ด์ ๊ธธ์ด๋ 0
(A, CA)
A์ A๋ ๊ฐ๋ค. ํด๋น ๋จ๊ณ์์ ๋ถ๋ถ ์์ด์ A๋ก ๊ธธ์ด๊ฐ 1์ด ๋์๋ค. ๋ฌธ์์ด A์์์ 'A'์ ๋ฌธ์์ด B์์ 'A' ๋ชจ๋ ๊ณ ๋ คํ์ฌ 1๋ก ์ถ๊ฐํ ๊ฒ์ด๋ค.
๋ง์ฐฌ๊ฐ์ง๋ก ์ด์ ๋จ๊ณ์์ ๊ฐ์ ธ์ฌ ์ ์๋ ๊ฐ์ ๊ฐ์ ธ์์ผ ํ๋๋ฐ ์ด๋ฏธ ๊ฐ ๋ฌธ์์ด์์ ํ์ฌ A๋ฅผ ๋ถ๋ถ์์ด๋ก ์ถ๊ฐํ์๊ธฐ ๋๋ฌธ์, ์ด์ ๋จ๊ณ๋ ์ด A๋ฅผ ๊ณ ๋ คํ์ง ์์ ๋ฐ๋ก ์ ๋จ๊ณ๋ฅผ ์๊ฐ ํด์ผํ๋ค. (A, CA) ์์ ๋ชจ๋ A๋ฅผ ๊ณ ๋ คํ์ง ์๋ ์ง์ ์ ('', C) ๋น๊ต ์ง์ ์ด๋ค. ์ด ๋จ๊ณ์ ๊ฐ์ 0 ์ด๊ธฐ ๋๋ฌธ์
ํ์ฌ ๋จ๊ณ ๊ฐ + ์ด์ ๋จ๊ณ = 1+ 0 = 1 ์ด ๋๋ค.
(A, CAP)
A์ P๋ ๊ฐ์ง ์๋ค.
์ด์ ๋จ๊ณ๋ (A, CA) ๋น๊ต ์ง์ , ('', CAP) ๋น๊ต ์ง์ ์ด ๋๋ค. ์ด๋ฅผ ์์นํ ํ๋ฉด ๊ฐ๊ฐ dp[i, j-1]
, dp[i-1, j]
์ง์ ์ด๋ผ๊ณ ํ ์ ์๋ค.
ํ์ฌ ๊ฐ์ด ๊ฐ์ง ์์ ๊ฒฝ์ฐ์๋ ์๋์ ๊ฐ์ด ํํํ ์ ์๊ณ , 'A'์ 'CAP' ๋ฌธ์๋ฅผ ๋น๊ตํ์์ ๋ ์ต๋ ๋ถ๋ถ ์์ด์ ๊ธธ์ด๋ 1์ด ๋๋ค.
dp[i][j] = max(dp[i][j-1], dp[i-1][j])
(A, CAPC)
A, C๋ ๊ฐ์ง ์๊ณ , ์์ ๋์ผํ ๋ฐฉ๋ฒ์ผ๋ก ์งํํ๋ค.
(A, CAPCA)
A, A๋ ๊ฐ๋ค.
ํด๋น 'A'๋ฅผ ๋ถ๋ถ ์์ด๋ก ์ถ๊ฐํ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ์ด์ ๋จ๊ณ์์ ํ์ฌ ๋ถ๋ถ ์์ด 'A'์ ๊ธธ์ด์ธ 1์ ๋ํด์ฃผ์ด์ผ ํ๋ค. ์ฌ๊ธฐ์ ์ด์ ๋จ๊ณ๋ ์ด 'A'๋ฅผ ๊ณ ๋ คํ์ง ์์ ('', CAPC) ๊ฐ ๋๊ณ ํด๋น ๋จ๊ณ๋ dp[i-1][j-1]
๋ก ํํํ ์ ์๋ค.
๋ฐ๋ผ์
dp[i][j] = dp[i-1][j-1]+1
์์ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก (ACAYKP, CAPCAK)๋ฅผ ๋น๊ตํด๋๊ฐ๋ฉด dp[len(A)][len(B)]
์์น์ ์ต์ฅ ๋ถ๋ถ ์์ด ๊ธธ์ด๊ฐ ์ค๊ฒ ๋๋ค.
A = input()
B = input()
dp = [[0] * (len(A)+1) for _ in range(len(B)+1)]
for i in range(1, len(A)+1):
for j in range(1, len(B)+1):
if A[i-1] == B[j-1]:
dp[i][j] = dp[i-1][j-1]+1
else:
dp[i][j] = max(dp[i][j-1], dp[i-1][j])
print(dp[len(A)][len(B)])
๐ ํจ์คํธ ์บ ํผ์ค: ์๊ณ ๋ฆฌ์ฆ/ ์๋ฃ๊ตฌ์กฐ ์จ๋ผ์ธ ๊ฐ์์ ํด์ค์ ์ฐธ๊ณ ํ์์.