๐์ต์ฅ ๊ณตํต ๋ถ๋ถ ์์ด ์ด๋? (LCS, Longest Common Subsequence)
๋๊ฐ์ ๋ฌธ์์ด์ด ์ฃผ์ด์ก์ ๋ ๊ณตํต์ผ๋ก ๋ค์ด ์๋ ๋ถ๋ถ ์์ด ์ค ๊ฐ์ฅ ๊ธด ์์ด์ ๋งํ๋ค.
์๋ฅผ ๋ค์ด
ABCDE์ ACDFG์ด ์ฃผ์ด์ก๋ค๋ฉด ๋ ๋ฌธ์์ด์ ๊ณตํต ๋ถ๋ถ ์์ด์
{A}, {C}, {D}, {AC}, {AD}, {ACD} ์ด๊ณ LCS๋ ๋ฐ๋ก {ACD}๋ฅผ ๋งํ๋ค.
- LCS์ LCS (์ต์ฅ ๊ณตํต ๋ถ๋ถ ์์ด๊ณผ ์ต์ฅ ๊ณตํต ๋ถ๋ถ ๋ฌธ์์ด)
์ฌ์ค LCS๋ ๋ป์ด ๋๊ฐ์ง๋ค ..!
LCS( Longest Common Subsequence) ์ด ์๊ณ
์ต์ฅ ๊ณตํต ๋ถ๋ถ ๋ฌธ์์ดLCS( Longest Common Substring) ์ด ์๋ค.
์ ๋ ๋ฌธ์์ด ABCDE์ ACDFG์ ๋ํด์ ์ต์ฅ ๊ณตํต ๋ถ๋ถ ์์ด๋ {ACD}์ง๋ง ์ต์ฅ ๊ณตํต ๋ถ๋ถ ๋ฌธ์์ด์ ์ฐ์ด์ด์ ธ์ผ ํ๋ค.
๋ฐ๋ผ์ {CD} ์ด๋ค.
โ๏ธ ์ ๊ทผ ๋ฐฉ๋ฒ
์ด ๋ฌธ์ ๋ DP(dynamic programming)์ผ๋ก ์ ๊ทผํ์ฌ ์ ํ์์ผ๋ก ํ๋ฉด ๊ฐ๋จํ๊ฒ ํ ์ ์๋ค๊ณ ํ๋ค.
์ฌ๊ธฐ์ ๋ฐ๋ก
DP๋ก ๋ฌธ์ ํ๊ธฐ ์ํ ์กฐ๊ฑด
- ์์ ๋ฌธ์ ๊ฐ ๋ฐ๋ณต์ ์ผ๋ก ์ผ์ด๋๋ค.
- ๊ฐ์ ๋ฌธ์ ๋ ๊ตฌํ ๋๋ง๋ค ์ ๋ต์ด ๊ฐ๋ค.
์ฆ ํฐ ๋ฌธ์ ๋ฅผ ํ ๋ ์์ ๋ฌธ์ ๋ก ๋๋ ์ ํธ๋๋ฐ ์์ ๋ฌธ์ ์ ํฐ ๋ฌธ์ ํธ๋ ๋ฐฉ๋ฒ์ด ๊ฐ๋ค๋ ๊ฒ์ด๋ค.
๐๐จLCS ์ ํ์
LCS์ ์ ํ์์ ๋ค์๊ณผ ๊ฐ๋ค.
์๋ฅผ ๋ค์ด
ABCDE์ ACDFG ๋ ๋ฌธ์์ด์ด ์๋ค๊ณ ํ์
X : ABCDE
Y : ACDFG
X์ ๋ง์ง๋ง ๋ฌธ์(E)๋ฅผ ํ๋ ์ง์๋ณด์ ๊ทธ๋ฌ๋ฉด ABCD๊ฐ ๋ ๊ฒ์ด๋ค. ๊ทธ๋๋ LCS์๋ ์๊ด์ด ์๋ค.
X์ ๋ง์ง๋ง ๋ฌธ์(D)๋ฅผ ํ๋ ๋ ์ง์ฐ๋ฉด ABC๊ฐ ๋๊ณ ์ด๋ฒ์๋ LCS ๊ธธ์ด๊ฐ ํ๋ ์ค์ด๋ ๋ค.
์ฆ ์์ด์ ๋ง์ง๋ง ๋ฌธ์๋ฅผ ์ ๊ฑฐํ๋ฉด 1. LCS ๊ธธ์ด๊ฐ ๊ทธ๋๋ก๋ค 2. LCS ๊ธธ์ด๊ฐ ์ค์ด๋ ๋ค. ๋๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๊ฐ์ง๋ค.
c[i, j]๋ฅผ Xi์ Yi์ ์ต์ฅ ๊ณตํต ๋ถ๋ถ ์์ด์ด๋ผ๊ณ ํ์. i์ j๋ ๋ฌธ์์ด์ ๊ฐ๋ฆฌํค๋ ์ธ๋ฑ์ค๋ค.
i์ ๋ฒ์ 1 <= i <= 5
j์ ๋ฒ์ 1<= j <=5
1) i = 0 or j = 0 ์ธ๊ฒฝ์ฐ
๋ฌธ์์ด ๊ธธ์ด๊ฐ 0 ์ด๋ฉด LCS ๋ 0์ด ๋ ์ ๋ฐ์ ์๋ค.
2) i != 0 and j !=0 ์ด๊ณ Xi != Yj ์ธ ๊ฒฝ์ฐ
์๋ฅผ ๋ค์ด
X : ABCDE, Y : ACDFG ์ผ ๋
X์ ๋ง์ง๋ง ๋ฌธ์ E์ Y์ ๋ง์ง๋ง ๋ฌธ์ G๊ฐ ๋ค๋ฅด๋ค.
๊ทธ๋ฌ๋ฉด ๋๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋๋ ์๊ฐ ํด ๋ณผ ์ ์๋ค.
1) LCS๊ฐ E๋ก ๋๋๋ ๊ฒฝ์ฐ
2) LCS๊ฐ G๋ก ๋๋๋ ๊ฒฝ์ฐ
1) LCS๊ฐ E๋ก ๋๋๋ ๊ฒฝ์ฐ G๋ ์ต์ฅ ๊ณตํต ์์ด์ ์ํฅ์ ๋ฏธ์น์ง ์๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก
c[i, j] = c[i, j - 1]๋ก๋ ์๊ฐ ํ ์ ์์ ๊ฒ์ด๋ค.
1) LCS๊ฐ G๋ก ๋๋๋ ๊ฒฝ์ฐ ๋ฐ๋๋ก E๊ฐ ์ต์ฅ ๊ณตํต ์์ด์ ๋ง๋๋๋ฐ ์ํฅ์ ๋ฏธ์น์ง ์์ผ๋ฏ๋ก ์ง์๋ ์๊ด ์๋ค.
๋ฐ๋ผ์ c[i -1, j] = c[i, j]
์ฐ๋ฆฌ๋ ์ต์ฅ ๊ณตํต ์์ด์ ์ํ๋ฏ๋ก c[i, j] = max(c[i, j - 1], c[i -1, j] )์ ๊ฐ์ ๊ฐ์ง ๊ฒ์ด๋ค.
2) i != 0 and j !=0 ์ด๊ณ Xi == Yj ์ธ ๊ฒฝ์ฐ
์๋ฅผ ๋ค์ด ASC ์ AEC ๋ ๋ฌธ์์ด์ ๋ง์ง๋ง ๊ฐ(C)์ด ๊ฐ๋ค๋ฉด C๋ ์ด๋ฏธ ์ต์ฅ ๊ธธ์ด ๋ฌธ์์ด์ ์์๋ก ํ๋ณดํด ๋๊ณ C๋ฅผ ์ ์ธํ
AS์ AE์ ๋น๊ต ๊ณผ์ ์ ๊ฑฐ์น๊ณ ์ถ์ ๊ฒ์ด๋ค.
๊ทธ๋ฌ๋ฏ๋ก c[i, j] = c[i - 1][j - 1] + 1 ์ด ๋๋ค.
๐ณ ํ๋ ฌ์ ์ด์ฉํ ๊ฐ ๊ณ์ฐ
์ฌ์ค ์๊ณ ๋ฆฌ์ฆ ์๊ฐ์ ์ด๋ ๊ฒ ๋ฐฐ์ ์๋ค ๋ฐ์ํ ๊ต์๋์ ๋ฒ๋ฒ ๊ฑฐ๋ฆผ๊ณผ ํจ๊ป ๋ง์ด๋ค.
๊ทธ๋์ ์ด ๋ฐฉ์์ด ๋ ์ต์ํ๊ณ ์ด๋ฅผ dp ์ ํ์ ์ ๋๊ธฐ ์ด๋ ต๋ค ๋๊ปด์ง๋ฉด ํ๋ ฌ๋ก ๋จผ์ ์น๊ทผํด์ง๋ ๊ฒ์ด ๋ ์ข์ ๋ฏ ํ๋ค.
์์๋ก ๋ค์๋ ABCDE์ ACDFG๋ฅผ ํ๋ ฌ์ ๊ฐ์ผ๋ก ๋ฃ์ด์ฃผ์๋ค.
์ด์ฐจ์ ํ๋ ฌ๋ก ๋ง๋ค๊ณ 0๋ฒ์งธ ์ธ๋ฑ์ค๋ค์ 0์ผ๋ก ์ด๊ธฐํ ์์ผ์ค๋ค.
X ๋ฌธ์์ด์ ๋ํด ๊ฒ์ฌ๋ฅผ ์์ํ๋๋ฐ A ๋ฌธ์์ด์ด ๊ฐ๋ค!! ๊ทธ๋ฌ๋ฉด ์ข์ธก๊ฐ 0๊ณผ ์์ชฝ ๊ฐ 0 ์ค ํฐ ๊ฐ (๊ฒฐ๊ตญ 0)์ +1์ ํด์ค๋ค.
X์ i =1 ์ผ๋ ์ฆ A ์์์ ๋ํด ์ํํด์ฃผ๋ฉด
์ด๋ ๊ฒ ํ ์ค์ด ์์ฑ์ด ๋๊ฒ ๋ค
B๋ ๋ง์น๊ฐ์ง๋ก ํด์ฃผ๊ณ C๋ฅผ ๋ณด๊ฒ ๋๋ฉด
์ฒ์ A ํ ๊ฒ ์ฒ๋ผ C ์ญ์ ์์ ์ ์ข์ธก๊ฐ(1)๊ณผ ์ฐ์ธก ๊ฐ(1) ์ค ํฐ ๊ฐ์ +1์ ํ๋ค. ๊ทธ๋ฌ๋ฉด 2๊ฐ ๋๋ค
๋ฐ๋ณต์ ์ธ ์ผ๋ค์ +1์ฉ ์ฆ๊ฐ์ํค๋ฉด์ (DP์ ์กฐ๊ฑด) ๋ง์ง๋ง๊น์ง ํ๋ ฌ์ ์์ฑํ๊ฒ ๋๋ฉด
์ด๋ ๊ฒ ํ๋ ฌ์ด ์์ฑ๋๊ณ ํ๋ ฌ์ ๋ง์ง๋ง ๊ฐ์ด LCS์ ๊ธธ์ด ์ฆ 3์ด ๋์ถ๋๋ค.
โฐ c++ ์ฝ๋ :
//
// 9251_LCS.cpp
// SOMA๐ฉ๐ป๐ป
//
// Created by JoSoJeong on 2021/03/01.
//
#include <cstdio>
#include <cstring>
#include <algorithm>
char X[1010];
char Y[1010];
int C[1010][1010];
using namespace std;
int main()
{
scanf("%s", &X);
scanf("%s", &Y);
int lenX = (int)strlen(X);
int lenY = (int)strlen(Y);
for (int i = 1; i <= lenX; i++) {
for (int j = 1; j <= lenY; j++) {
if (X[i - 1] == Y[j - 1])
C[i][j] = C[i - 1][j - 1] + 1;
else
C[i][j] = max(C[i - 1][j], C[i][j - 1]);
}
}
printf("%d\n", C[lenX][lenY]);
return 0;
}
'Data Structure๐งถ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์์ ์ ๋ ฌ Topological Sort (0) | 2021.06.13 |
---|---|
๊ทธ๋ํ ์ด๋ก - DFS์ BFS (0) | 2021.04.21 |
๊ทธ๋ํ ์ด๋ก - ์ด๋ถ ๊ทธ๋ํ (0) | 2021.02.25 |
์ ๋ ฌ - ์ ํ, ๋ฒ๋ธ, ์ฝ์ , ๋ณํฉ, ํ, ํต (0) | 2021.02.19 |
๋๊ธ