String Process Algorithm
Contents
์คํธ๋ง ํ์ ์๊ณ ๋ฆฌ์ฆ
- ๋ฌธ์ ์์ฑ ์
- ํ
์คํธ(text) : ๋ฌธ์
- ํจํด(pattern) : ํ์ํ ์คํธ๋ง
- ์คํธ๋ง(string)
- ๋ฌธ์๊ฐ ์ฐ์์ ์ผ๋ก ๋์ด๋ ๊ฒ
- ํ
์คํธ(text) ์คํธ๋ง
- ์ด์ง(binary) ์คํธ๋ง
- ์คํธ๋ง ํ์ ์๊ณ ๋ฆฌ์ฆ์ ์ค๊ณ ๋ชฉ์
- ํ์ฐ์ ์ผ๋ก ์๋ชป๋ ์์(false start) ๋ฐ์
- (๋ถ์ผ์น๊ฐ ๋ฐ์ํ ์์น๊น์ง ๋น๊ตํ 0๊ฐ ์ด์์ ๋ฌธ์๋ฅผ ์๋ฏธ)
- ์๋ชป๋ ์์์ ํ์์ ๊ธธ์ด๋ฅผ ์ค์ด๋ ๊ฒ
์ง์ ์ ์๊ณ ๋ฆฌ์ฆ
aka. ๋ฌด์์ ๋ฌด์ง์ฑ ์๊ณ ๋ฆฌ์ฆ
- ํ ๊ธ์ ๋๋ ํ ๋นํธ์ฉ ์ค๋ฅธ์ชฝ์ผ๋ก ์งํ
- ํ
์คํธ์ ์ฒ์๋ถํฐ ๋๊น์ง ๋ชจ๋ ๋น๊ตํ๋ฉฐ ํ์ํ๋ ์๊ณ ๋ฆฌ์ฆ
Pseudo Code
BruteForce(p[], t[]) // ๋จ์ํ algo์ง๋ง ์ง์ ๊ตฌํํ๋ฉด ์ด๋ ค์ธ ์ ์๋ค.
M โ ํจํด์ ๊ธธ์ด; N โ ํ
์คํธ์ ๊ธธ์ด;
for (i โ 0, j โ 0; j < M and i < N; i โ i + 1, j โ j + 1) do {
if (t[i] =ฬธ p[j]) then {
i โ i - j; // i๊ฐ 1์นธ ์ด๋
j โ -1;
}
}
if (j = M) then return i - M;
else return i;
end ButeForce()
์๊ฐ๋ณต์ก๋
์ต์
์ ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋๋ ํ
์คํธ์ ๋ชจ๋ ์์น์์ ํจํด์ ๋น๊ตํด์ผ ํ๋ฏ๋ก O(MN)
์ด ๋จ
KMP ์๊ณ ๋ฆฌ์ฆ
- KMP : Knuth, Morris and Pratt
- ๋ถ์ผ์น๊ฐ ๋ฐ์ํ์ ๊ฒฝ์ฐ ํ
์คํธ ์คํธ๋ง์ ์ ๋ถ๋ถ์ ์ด๋ค ๋ฌธ์๊ฐ ์๋์ง๋ฅผ ๋ฏธ๋ฆฌ ์๊ณ ์๋ค๋ฉด, ๋ถ์ผ์น๊ฐ ๋ฐ์ํ ์ ๋ถ๋ถ์ ๋ํด์๋ ๋ค์ ๋น๊ตํ์ง ์๊ณ ๋งค์นญ์ ์ํํ ์ ์์
- ํจํด์ ์ ์ฒ๋ฆฌํ์ฌ ๋ฐฐ์ด
next[M]
์ ๊ตฌํด์ ์๋ชป๋ ์์์ ์ต์ํํจ
next[M]
: ๋ถ์ผ์น๊ฐ ๋ฐ์ํ์ ๊ฒฝ์ฐ ์ด๋ํ ๋ค์ ์์น
- ์ผ๋ง๋งํผ ์ ํํ ์ง ์ ํ์ ์์ธ ๋ฅผ
next
๋ฐฐ์ด์ ์ ์ฅ
p[0~i]
์ ์ ๋ฏธ์ฌ์ ์ผ์นํ ์ต์ฅ ์ ๋์ฌ์ ๋์๋ฆฌ ์์น
- ๋จ, ์ต์ฅ์ ๋์ฌ != ์ ์ฒด๋ฌธ์์ด
์๊ฐ ๋ณต์ก๋
O(M+N)
Pseudo Code: ์ฌ์์ ์์น ์๊ณ ๋ฆฌ์ฆ
InitNext(p[])
M โ ํจํด์ ๊ธธ์ด;
next[0] โ -1;
for (i โ 0, j โ -1; i < M; i โ i + 1, j โ j + 1) do
{
next[i] โ j;
while ((j โฅ 0) and (p[i] =ฬธ p[j])) do
j โ next[j];
}
end InitNext()
next[]
์ ์๋ฏธ
next[i]
๋ ์ฃผ์ด์ง ๋ฌธ์์ด์ 0~(i-1)๊น์ง์ ๋ถ๋ถ ๋ฌธ์์ด ์ค์์ prefix == suffix๊ฐ ๋ ์ ์๋ ๋ถ๋ถ ๋ฌธ์์ด ์ค์์ ๊ฐ์ฅ ๊ธด ๊ฒ์ ๊ธธ์ด
Pseudo Code: KMP ์๊ณ ๋ฆฌ์ฆ
KMP(p[], t[])
M โ ํจํด์ ๊ธธ์ด; N โ ํ
์คํธ์ ๊ธธ์ด;
InitNext(p);
for(iโ0,jโ0; j <M and i<N; iโi+1,jโj+1) do
while ((j โฅ 0) and (t[i] =ฬธ p[j])) do
j โ next[j];
if (j = M) then return i - M;
else return i;
end KMP()
ํจํด์ด ๋ด์ฅ๋ KMP ์๊ณ ๋ฆฌ์ฆ
- KMP ์๊ณ ๋ฆฌ์ฆ์ ์ํ ์ ํ ์ํ ์ฅ์น
- ์ ํ ์ํ ์ฅ์น (finite state machine: FSM)
- ์ํ(state; ์์ผ๋ก ํ์)
- ์ ์ด(transition; ์ ์ผ๋ก ํ์)
- ์ผ์น ์ ์ด(match transition; ์ค์ ์ผ๋ก ํ์) - ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋
- ๋ถ์ผ์น ์ ์ด(non-match transition; ์ ์ ์ผ๋ก ํ์) - ์ผ์ชฝ์ผ๋ก ์ด๋
- ์์์ (์ผ์ชฝ ๋์ ์ฌ๊ฐํ)
- ์ข
๋ฃ์ (์ค๋ฅธ์ชฝ ๋์ ์ฌ๊ฐํ)
- ๊ฐ์ ๋ ์ ํ ์ํ ์ฅ์น
InitNext
์๊ณ ๋ฆฌ์ฆ์ next[i] โ j;
๋ณ๊ฒฝ
if (p[i] == p[j]) then next[i] โ next[j];
else next[i] โ j
๋ณด์ด์ด-๋ฌด์ด ์๊ณ ๋ฆฌ์ฆ
- ์ค๋ฅธ์ชฝ์์ ์ผ์ชฝ์ผ๋ก ์คํธ๋ง ํ์์ ์งํ
- ๋ถ์ผ์น ๋ฌธ์ ๋ฐฉ์ฑ
(mismatched character heuristic) ์ฌ์ฉ
- ํ
์คํธ์ ์๋ ๋ถ์ผ์น๊ฐ ๋ฐ์ํ ๋ฌธ์๊ฐ ํจํด์ ๋ฌธ์๊ฐ ์ผ์นํ๋๋ก ํจํด์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋
- ์ผ์น ์ ๋ฏธ๋ถ ๋ฐฉ์ฑ
(good suffix heuristic) ์ฌ์ฉ
- ํจํด์์ ๋ถ์ผ์น๊ฐ ๋ฐ์ํ ๋ฌธ์์ ์ค๋ฅธ์ชฝ์ ์๋ ์ต๋ ์ ๋ฏธ๋ถ๊ฐ ์ผ์นํ๋๋ก ํจํด์ ์ค๋ฅธ์ชฝ์ ์ด๋ํ๋ ๊ฒ
- ๋ ๋ฐฉ๋ฒ ์ค ํจํด์ ์ฐ์ธก์ผ๋ก ์ด๋ํ๋ ๊ฑฐ๋ฆฌ๊ฐ ๋ ๊ธด ๊ฒ์ ์ ํ
- ์ต์ ์ ๊ฒฝ์ฐ ์๊ฐ ๋ณต์ก๋ :
O (m + n /m + |ฮฃ|)
- ์ํ๋ฒณ์ด ํฐ ๊ฒฝ์ฐ
O(m+n/m+|ฮฃ|)
์๊ฐ์ ์ํ๋ ๊ฐ๋ฅ์ฑ์ด ๋งค์ฐ ๋์
๋ถ์ผ์น ๋ฌธ์ ๋ฐฉ์ฑ
๊ณผ ์ผ์น ์ ๋ฏธ๋ถ ๋ฐฉ์ฑ
Pseudo Code: ๋ถ์ผ์น ๋ฌธ์ ๋ฐฉ์ฑ
์๊ณ ๋ฆฌ์ฆ
void InitSkip(char *p) {
int i, M = strlen(p);
for (i = 0; i < NUM; i++) skip[i] = M;
for (i = 0; i < M; i++) skip[index(p[i])] = M - i - 1;
}
MisChar(p[], t[])
M โ ํจํด์ ๊ธธ์ด; N โ ํ
์คํธ์ ๊ธธ์ด;
InitSkip(p);
for (i โ M-1, j โ M-1; j โฅ 0; i โ i - 1, j โ j - 1) do
while (t[i] =ฬธ p[j]) do {
k โ skip[index(t[i])];
if (M-j > k) then i โ i + M - j; // M-j = 5-1 = 4
else i โ i + k; // k = 0
if (i โฅ N ) then return N;
j โ M - 1;
}
return i+1;
end MisChar()
๋ผ๋น-์นดํ ์๊ณ ๋ฆฌ์ฆ
- ์คํธ๋ง์ ์ซ์๊ฐ์ผ๋ก ๋ฐ๊พผ ๋ค์ ํด์ ๊ฐ์ ๊ณ์ฐํ์ฌ ๋งค์นญํ๋ ์๊ณ ๋ฆฌ์ฆ
- ์ต์
์ ์๊ฐ ๋ณต์ก๋๋
O(MN)
์ด์ง๋ง ํ๊ท ์ ์ผ๋ก๋ ์ ํ์ ๊ฐ๊น์ด ๋น ๋ฅธ ์๋๋ฅผ ๊ฐ์ง๋ ์๊ณ ๋ฆฌ์ฆ
Levenshtein Distance ํธ์ง๊ฑฐ๋ฆฌ ์๊ณ ๋ฆฌ์ฆ
๋งํฌ ์ฐธ๊ณ
ํจํด ๋งค์นญ ์๊ณ ๋ฆฌ์ฆ
ํจํด ๋งค์นญ (pattern matching)
- ํ
์คํธ ์คํธ๋ง์์ ์ํ๋ ๋ฌธ์ ํจํด์ ์ฐพ์ ๋ด๋ ๊ฒ
- ํจํด ๊ธฐ์
-
- ์ ํฉ (concatenation)
- ํจํด์์ ์ธ์ ํด ์๋ ๋ ๋ฌธ์๊ฐ ํ
์คํธ์์ ๋ํ๋๋ฉด ๋งค์น
-
- ๋
ผ๋ฆฌํฉ (or)
- ๋ ๊ฐ์ ๋ฌธ์ ์ค ํ๋๊ฐ ํ
์คํธ์ ๋ํ๋๋ฉด ๋งค์น
-
- ํํฌ (closure)
- ํน์ ํ ๋ฌธ์๊ฐ 0๊ฐ ์ด์ ๋ํ๋๋ฉด ๋งค์น
์ ๊ท์ (regular expression)
- ํน์ ํ ๊ท์น์ ๊ฐ์ง ๋ฌธ์์ด์ ์งํฉ์ ํํํ๋๋ฐ ์ฌ์ฉํ๋ ํ์ ์ธ์ด
- ์ธ ๊ฐ์ง ๊ธฐ๋ณธ ์ฐ์ฐ๋ค๋ก ์ด๋ฃจ์ด์ง ์ฌ๋ณผ๋ค์ ์คํธ๋ง
- ์ฌ๋ณผ (symbol)
*
: ๊ดํธ ์์ ์๋ ๋ฌธ์๋ค์ด 0๋ฒ ์ด์ ๋ํ๋จ
?
: ์ด๋ค ๋ฌธ์์๋ ๋งค์น๋จ
+
: ๋๋ (or) ์ฐ์ฐ
- ์
?*(ie+ei)?*
: ie
๋๋ ei
๋ฅผ ๊ฐ์ง๊ณ ์๋ ๋ชจ๋ ๋จ์ด
(1+01)*(0+1)
: ์ฐ์์ ์ผ๋ก ๋ ๊ฐ์ 0
์ด ๋์ค์ง ์๋ 0
๊ณผ 1
๋ก ์ด๋ฃจ์ด์ง ๋ชจ๋ ์คํธ๋ง
ํจํด ๋งค์นญ ์ฅ์น (pattern matching machine)
- ํจํด ๋งค์นญ์ ์ฌ์ฉ๋๋ ์ฅ์น ํจํด
- ๊ฒฐ์ ์ (deterministic) ์ฅ์น
- ๋น๊ฒฐ์ ์ (nondeterministic) ์ฅ์น
- ํจํด์ ๋งค์นํ๊ธฐ ์ํด ํ๋ ์ด์์ ๋ฐฉ๋ฒ์ด ์์ ๊ฒฝ์ฐ, ์ฅ์น๊ฐ ์ฌ๋ฐ๋ฅธ ๊ฒ์ ์ฐพ์ ๋๊ฐ๋ ๊ฒ
- ํ
์คํธ ์คํธ๋ง์์,
(A*B+AC)D
์ ๊ฐ์ ์ ๊ท์์ ์ฐพ๋ ๊ฒฝ์ฐ ์ฌ์ฉ๋๋ฉฐ, ์ ์ผํ ์์ ์ํ์ ์ข
๋ฃ ์ํ๋ฅผ ๊ฐ์ง๋ค.
ํจํด ๋งค์นญ ์ฅ์น ๊ตฌํ
- ์ฅ์น๋ฅผ ๊ตฌํํ๋๋ฐ ๊ฐ์ฅ ์ ํฉํ ์๋ฃ๊ตฌ์กฐ : Deque[๋ฐํฌ] (Double-Ended Queue)
- ์คํ๊ณผ ํ์ ํน์ง์ ์กฐํฉ
- ์๋ฐฉํฅ์์ ํญ๋ชฉ์ ์ถ๊ฐํ๋ ๊ฒ์ด ๊ฐ๋ฅ
- ์
๋ ฅ์ ์๋ฐฉํฅ์์ ๊ฐ๋ฅ
- ์ญ์ ๋ ๋ฐํฌ์ ์ฒ์์์๋ง ๊ฐ๋ฅํ โ์ถ๋ ฅ-์ ํ ๋ฐํฌ (output-restricted deque)โ ์ฌ์ฉ
- <img src=โhttps://user-images.githubusercontent.com/73745836/171321018-3a604596-b32f-447a-8441-fa7e3243dfad.jpegโ width = 30%/>
๋์ ๊ณผ์
- ๊ฐ์
-
- ๋ฌธ์๊ฐ ๋งค์น๋จ โ ์๋ก์ด ์ํ๋ฅผ ๋ฐํฌ์ ๋์ ์ฝ์
(
insertLast
)
-
- ์ํ๊ฐ ๋น์ด ์์ โ ๋ ๊ฐ์ ๊ฐ๋ฅํ ์ํ๋ฅผ ๋ฐํฌ์ ์ฒ์์ ์ฝ์
(
insertionFirst
)
-
scan
์ ๋ง๋จ โ ์
๋ ฅ ์คํธ๋ง์ ๋ํ ํฌ์ธํฐ๋ฅผ ๋ค์ ๋ฌธ์๋ก ์ด๋
- ์ข
๋ฃ ์กฐ๊ฑด
- ์
๋ ฅ์ ๋๊น์ง ๊ฐ์ ๋ (๋งค์น๋์ง ์์)
- ์ํ 0์ ๋ง๋จ (๋งค์น๋จ)
- ๋ฐํฌ์
scan
๋งํฌ ํ๋๋ง ๋จ์ (๋งค์น๋์ง ์์)
<img src=โhttps://user-images.githubusercontent.com/73745836/171323280-63ef8485-dd51-483a-8c14-61671bfe78d8.jpegโ width = 60%/>
ํ์ผ ์์ถ ์๊ณ ๋ฆฌ์ฆ
ํํ๋ง ์ธ์ฝ๋ฉ (Huffman encoding)
with Priority Queue
์๊ณ ๋ฆฌ์ฆ
- ๋ชจ๋ ๋
ธ๋๋ฅผ PQ์
insert
ํ๋ค.
- freq๊ฐ ๊ฐ์ฅ ์์ ๋ ๋
ธ๋๋ฅผ PQ์์ ๋นผ์จ๋ค.
- ๊ทธ ๋ ๋
ธ๋๋ฅผ ํ๋์ ๋
ธ๋๋ก ๋ฌถ๋๋ค.
- ํ๋๋ก ๋ฌถ์ ๋
ธ๋๋ฅผ ๋ค์ PQ์ ๋ฃ๋๋ค.
- 2๋ฒ ~ 4๋ฒ์ ๊ณผ์ ์ ๊ณ์ ๋ฐ๋ณตํ๋ค.
์ํธํ ์๊ณ ๋ฆฌ์ฆ
๊ณต๊ฐ ํค ์ํธํ ์์คํ
RSA(Rivest-Shamir-Adleman) ์๊ณ ๋ฆฌ์ฆ
-
- ์๋ก ๋ค๋ฅธ ๋ ๊ฐ์ ํฐ ์์
p
, q
์ ํ (100์๋ฆฌ)
-
- ํ๋์ ํฐ ์ซ์
e
์ ํ (๊ณต๊ฐ ์ํธํ ํค)
p-1
, q-1
๊ณผ ๊ฐ๊ฐ ์๋ก์์ด์ด์ผ ํจ
p
, q
๋ณด๋ค ํฐ ์ด๋ค ์์์ด์ดํ ํจ
-
- ๋น๋ฐ ํด๋
ํค
d
๊ณ์ฐ
(e*d) % {(p-1)*(q-1)} == 1
์ ๋ง์กฑํ๋ d
์ฐพ๊ธฐ
- ํ๊ธฐ๋ฒ :
d*e = 1 modulo (p-1)*(q-1)
mod
์ฐ์ฐ์ ๋ํ ํ๊ธฐ๋ฒ ์ฐธ๊ณ
-
- ์ ์
r
๊ณผ e
๋ ๊ณต๊ฐํ๊ณ , d
๋ ๋น๋ฐ๋ก ์ ์ง
-
- ํ๋ฌธ
P
๋ก๋ถํฐ ์ํธ๋ฌธ C = P^e modulo r
๊ณ์ฐ
-
- ์ํธ๋ฌธ
C
๋ก๋ถํฐ ํ๋ฌธ P = C^d modulo r
๊ณ์ฐ
>>> p = 3
>>> q = 5
>>> r = p*q
>>> r
15
>>> (p-1)*(q-1)
8
>>>
>>> # let e be 11 (prime greater than both p, q)
>>> e = 11
>>>
>>> # find d
>>> # d*e = 1 modulo (p-1)*(q-1)
>>> # d*11 = 1 modulo 8
>>> # so, d = 3
>>> d = 3
>>>
>>> ## Encryption ###
>>> # let P = 13 (Plain text)
>>> P = 13
>>> # C = P^e modulo r
>>> # C = P**e % r
>>> # C = 13*11 % 15
>>> C = P**e % r
>>> C
7
>>>
>>> ### Decryption ###
>>> # P = C^d modulo r
>>> # P = C**d % r
>>> # P = 7**3 % 15
>>> P = C**d % r
>>> P
13
๋ฐ์ก์ธ S๊ฐ ์์ ์ธ R์๊ฒ ๋ฉ์์ง P ์ ์ก
๋ฐ์ก์ธ S :
์์ ์ธ R :
S๊ฐ ๋ฉ์์ง P๋ฅผ ์ ์กํ์๋ค๋ ๊ฒ์ ํ์ธํ ์ ์์!