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 : 
&space;\right&space;)&space;=&space;C)
์์ ์ธ R : 
&space;\right&space;)&space;&=&space;E_S\left&space;(&space;D_R\left&space;(E_R\left&space;(&space;D_S\left&space;(&space;P&space;\right&space;)&space;\right&space;)\right&space;)&space;\right&space;)&space;\\&space;&=&space;E_S\left&space;(&space;D_S\left&space;(&space;P&space;\right&space;)&space;\right&space;)&space;\\&space;&=&space;P\end{align*})
  S๊ฐ ๋ฉ์์ง P๋ฅผ ์ ์กํ์๋ค๋ ๊ฒ์ ํ์ธํ  ์ ์์!