Nghiên Cứu Thuật Toán Knuth Morris Pratt Và Ứng Dụng

- 1 -

Số hóa bởi Trung tâm Học liệu http://www.lrc-tnu.edu.vn/

ĐẠI HỌC THÁI NGUYÊN

TRƢỜNG ĐẠI HỌC CÔNG NGHỆ THÔNG TIN VÀ TRUYỀN THÔNG

ĐỖ QUỲNH ANH

NGHIÊN CỨU THUẬT TOÁN KNUTH-MORRIS-PRATT

VÀ ỨNG DỤNG

Chuyên ngành: Khoa học máy tính

Mã số: 60.48.01

LUẬN VĂN THẠC SĨ KHOA HỌC MÁY TÍNH

NGƢỜI HƢỚNG DẪN KHOA HỌC: PGS.TS: ĐỖ TRUNG TUẤN

Thái Nguyên – 2014

- 2 -


MỤC LỤC

MỤC LỤC ....................................................................................................................... 1

DANH MỤC CÁC KÝ HIỆU, CÁC CHỮ VIẾT TẮT .................................................. 5

DANH MỤC CÁC HÌNH VẼ VÀ CÁC BẢNG ............................................................ 6

MỞ ĐẦU ......................................................................................................................... 7

CHƢƠNG 1. SO KHỚP CHUỖI .................................................................................. 10

1.1. Khái niệm so khớp chuỗi ................................................................................... 10

1.2. Lịch sử phát triển ................................................................................................ 11

1.3. Các cách tiếp cận ................................................................................................ 12

1.4. Ứng dụng của so khớp chuỗi .............................................................................. 12

1.5. Các dạng so khớp chuỗi ..................................................................................... 13

1.5.1. So khớp đơn mẫu ........................................................................................ 13

1.5.2. So khớp đa mẫu........................................................................................... 14

1.5.3. So mẫu mở rộng .......................................................................................... 15

1.5.4. So khớp chính xác ....................................................................................... 16

1.5.5. So khớp xấp xỉ ............................................................................................ 17

1.5.5.1. Phát biểu bài toán ................................................................................ 17

1.5.5.2. Các tiếp cận so khớp xấp xỉ ................................................................. 18

1.5.5.3. Độ tƣơng tự giữa hai xâu ..................................................................... 19

1.5. Một số thuật toán so mẫu ................................................................................... 20

1.5.1. Thuật toán Brute Force ............................................................................... 20

1.5.2. Thuật toán Karp-Rabin ............................................................................... 21

1.5.3. Thuật toán BM ( Boyer- Moor) .................................................................. 24

1.5.4. Các thuật toán khác ..................................................................................... 27

1.6. Khớp chuỗi với otomat hữu hạn ......................................................................... 28

1.6.1. Otomat hữu hạn ........................................................................................... 28

1.6.1.1. Ôtômát hữu hạn đơn định DFA ........................................................... 29

1.6.1.2. Ôtômát hữu hạn không đơn định NFA ................................................ 33

1.6.2. Otomat khớp chuỗi...................................................................................... 36

1.6.2.1. Giới thiệu ............................................................................................. 36

1.6.2.2. Thuật toán xây dựng Otomat so khớp chuỗi ....................................... 38

1.7. Kết luận chƣơng ................................................................................................. 40

CHƢƠNG 2. THUẬT TOÁN SO KHỚP CHUỖI KNUTH-MORRIS-PRATT .......... 41

2.1. Thuật toán KMP ................................................................................................. 41

- 3 -


2.1.1. Giới thiệu thuật toán ................................................................................... 41

2.1.2. Bảng so sánh một phần ............................................................................... 45

2.1.3. Độ phức tạp của thuật toán KMP ................................................................ 47

2.2. Thuật toán KMP mờ ........................................................................................... 48

2.2.1. Otomat so mẫu ............................................................................................ 48

2.2.2. Thuật toán ................................................................................................... 49

2.2.2.1 Thuật toán tạo lập TFuzz ...................................................................... 49

2.2.2.2. Thuật toán tìm kiếm mẫu dựa vào bảng TFuzz ................................... 51

2.2.3. So sánh KMP và thuật toán KMP mờ ......................................................... 52

2.3. Thuật toán KMP - BM mờ ................................................................................. 53

2.3.1. Ý tƣởng của thuật toán ................................................................................ 53

2.4.2. Otomat mờ so mẫu ...................................................................................... 55

2.3.2.1. Giới thiệu ............................................................................................. 55

2.3.2.2. Hoạt động của otomat mờ so mẫu ....................................................... 55

2.3.3. Thuật toán tìm kiếm .................................................................................... 56

2.4. Kết luận chƣơng ................................................................................................. 57

CHƢƠNG 3. ỨNG DỤNG THUẬT TOÁN KMP TRONG TÌM KIẾM THÔNG TIN

TRÊN VĂN BẢN .......................................................................................................... 58

3.1. Bài toán tìm kiếm mẫu trên văn bản .................................................................. 58

3.1.1. Tìm kiếm mẫu ............................................................................................. 58

3.1.2. Tìm kiếm thông tin...................................................................................... 59

3.1.2.1 Giới thiệu .............................................................................................. 59

3.1.2.2 Các mô hình tìm kiếm thông tin thƣờng sử dụng ................................. 61

3.2. Mã nguồn mở Lucene ........................................................................................ 64

3.2.1. Giới thiệu .................................................................................................... 64

3.2.2. Các bƣớc sử dụng Lucene ........................................................................... 66

3.3. Ứng dụng tìm kiếm thông tin trên văn bản ........................................................ 67

3.4. Cài đặt chƣơng trình thử nghiệm ....................................................................... 68

3.4.1. Giải pháp, công nghệ sử dụng..................................................................... 68

3.4.2. Nội dung chƣơng trình ................................................................................ 68

3.4.3. Kết quả thực nghiệm ................................................................................... 71

3.4.3.1. Giao diện chính của chƣơng trình ....................................................... 72

3.4.3.2. Kết quả thử nghiệm của chƣơng trình khi tìm kiếm với từ khóa “Văn

bản” ................................................................................................................... 72

3.5. Kết luận chƣơng 3 .............................................................................................. 73

- 4 -


KẾT LUẬN ................................................................................................................... 74

TÀI LIỆU THAM KHẢO ............................................................................................. 76

- 5 -


DANH MỤC CÁC KÝ HIỆU, CÁC CHỮ VIẾT TẮT

BM Thuật toán Boyer - Moore

DFA Deterministic Finite Automata - Ôtômát hữu hạn đơn định

DOC Document

FA Finite Automata - Ôtômát hữu hạn

HTML HyperText Markup Language

IDF Inverse document frequency - Tần suất tài liệu ngƣợc

KMP KNUTH-MORRIS-PRATT

LAN Local area network

NFA Nondeterministic Finite Automata - Ôtômát hữu hạn không đơn định

TF Term frequency - Tần suất từ

- 6 -


DANH MỤC CÁC HÌNH VẼ VÀ CÁC BẢNG

Hình 1.1. Sơ đồ chuyển của một DFA ................................................................ 30

Hình 1.2. Mô tả một DFA ................................................................................... 31

Bảng 1.1. Ví dụ hàm chuyển δ của DFA ............................................................ 32

Hình 1.3. Sơ đồ của một NFA ............................................................................. 34

Hình 1.4. Di chuyển chuỗi .................................................................................. 35

Bảng 1.2. Ví dụ hàm chuyển trạng thái δ của NFA ............................................ 35

Hình1.5. Ví dụ so khớp chuỗi ............................................................................. 37

Hình 1.6. Ví dụ otomat so khớp chuỗi ................................................................ 38

Bảng 2.1. Bảng so sánh một phần ....................................................................... 46

Bảng 2.2. Thí dụ khác ......................................................................................... 46

Bảng 2.3. Trƣờng hợp mẫu xấu nhất với thuật toán KMP .................................. 47

Bảng 2.4. Bảng next ............................................................................................ 51

Bảng 2.5. Bảng TFuzz ......................................................................................... 51

Bảng 2.6. Minh họa thí dụ ................................................................................... 52

Hình 2.1. Dịch chuyển con trỏ trên mẫu ............................................................. 52

Bảng 2.7. Kết quả tìm sự xuất hiện mẫu P trong tệp S theo KMP và tiếp cận mờ

............................................................................................................................. 53

Hình 2.2. Ý tƣởng chung của thuật toán KMP-BM mờ ...................................... 55

Hình 3.1. Mô hình biểu diễn và so sánh thông tin .............................................. 60

Hình 3.2. Mô hình không gian vec tơ ................................................................. 62

Bảng 3.1. Tính điểm số ....................................................................................... 64

Hình 3.3. Mô hình đánh chỉ mục của Lucene ..................................................... 65

Hình 3.4. Mô hình ứng dụng tìm kiếm thông tin văn bản .................................. 68

Hình 3.5. Giao diện chính của chƣơng trình ....................................................... 72

Hình 3.6. Kết quả tìm kiếm của chƣơng trình ..................................................... 73

- 7 -


MỞ ĐẦU

1. Lý do chọn đề tài

Máy tính ngày nay đã đƣợc sử dụng trong hầu hết các lĩnh vực và đã góp

phần quan trọng vào việc thúc đẩy sự phát triển kinh tế, xã hội, khoa học kỹ

thuật, … Máy tính ra đời nhằm phục vụ cho những mục đích nhất định của con

ngƣời. Với tất cả sự xử lý của máy tính để lấy thông tin hữu ích và trong quá

trình xử lí đó một vấn đề đặc biệt quan trọng là tìm kiếm thông tin với khối

lƣợng lớn, độ chính xác cao, thời gian nhanh nhất.

Cùng với sự phổ biến của công nghệ thông tin, số lƣợng các tài liệu điện

tử cũng gia tăng từng ngày. Đến nay, số lƣợng các tài liệu đƣợc lƣu trữ lên đến

hàng tỷ trang. Trong khi đó, nhu cầu khai thác trong kho tài liệu khổng lồ này để

tìm kiếm những thông tin cần thiết đang là nhu cầu thƣờng ngày và thiết thực

của ngƣời sử dụng. Tuy nhiên, một trong những khó khăn con ngƣời gặp phải

trong việc khai thác thông tin là khả năng tìm chính xác thông tin họ cần trong

kho tài liệu. Để trợ giúp công việc này, các hệ thống tìm kiếm đã lần lƣợt đƣợc

phát triển nhằm phục vụ cho nhu cầu tìm kiếm của ngƣời sử dụng.

Những hệ thống tìm kiếm bắt đầu phát triển và đƣa vào ứng dụng, phổ

biến là các hệ thống tìm kiếm theo từ khóa. Nhiều hệ thống hoạt động hiệu quả

trên Internet nhƣ Google, Bing, Yahoo!… Tuy nhiên, phần lớn các công cụ tìm

kiếm này là những sản phẩm thƣơng mại và mã nguồn đƣợc giữ bí mật. Hoặc

các hệ thống tìm kiếm trên máy cá nhân nhƣ Windows Search, Google

Desktop… đã đáp ứng phần nào nhu cầu của ngƣời sử dụng, miễn phí cho cá

nhân, tuy nhiên cũng chỉ đáp ứng đƣợc trên phạm vi nhỏ và mới chỉ dừng lại ở

mức độ tìm kiếm từ khóa theo tiêu đề và phần tóm tắt.

Có một cách tiếp cận hiệu quả để giải quyết vấn đề này là thực hiện việc

- 8 -


so khớp và tìm kiếm toàn văn. Một trong những thuật toán so khớp chuỗi kinh

điển là thuật toán KMP. Có thể nói, KPM là một thuật toán mới mẻ ít đƣợc sử

dụng tại Việt Nam trong việc quản lý, lƣu trữ và xử lý lƣợng dữ liệu lớn nhƣng

rất hiệu quả và chính xác. Dựa trên hƣớng tiếp cận đó và sự hƣớng dẫn của giáo

viên, tôi mạnh dạn nhận đề tài “So khớp chuỗi và thuật toán Knuth-Morris-

Pratt”.

2. Đối tƣợng và phạm vi nghiên cứu

Các khái niệm so khớp chuỗi.

Các khái niệm thuật toán so khớp chuỗi KMP.

Một số ứng dụng trong thuật toán KMP.

3. Hƣớng nghiên cứu của đề tài

Nghiên cứu tìm kiếm Knuth–Morris–Pratt và ứng dụng trong việc

tìm kiếm thông tin trên văn bản.

Nghiên cứu giải pháp công nghệ cài đặt chƣơng trình thử nghiệm.

4. Những nội dung chính

Luận văn đƣợc trình bày trong 3 chƣơng, có phần mở đầu, phần kết luận,

phần mục lục, phần tài liệu tham khảo. Luận văn đƣợc chia làm ba chƣơng với

nội dung cơ bản nhƣ sau:

Chƣơng 1: Trình bày khái niệm về so khớp chuỗi, các hƣớng tiếp

cận, các dạng so khớp và một số thuật toán so mẫu.

Chƣơng 2: Trình bày về thuật toán KMP, thuật toán KMP mờ và

thuật toán KMP-BM mờ.

Chƣơng 3: Trình bày về bài toán tìm kiếm thông tin trên văn bản và

tiến hành cài đặt thử nghiệm chƣơng trình.

5. Phƣơng pháp nghiên cứu

Tổng hợp các tài liệu đã đƣợc công bố về thuật toán tìm kiếm thông tin,

- 9 -


khai phá dữ liệu, đặc biệt các kết quả nghiên cứu liên quan đến thuật toán tìm kiếm

thông tin.

Thực nghiệm thuật toán tìm kiếm KMP với dữ liệu mẫu. Nhận xét, đánh

giá kết quả thử nghiệm.

6. Ý nghĩa khoa học của đề tài

Luận văn nghiên cứu kỹ thuật, thuật toán tìm kiếm thông tin là cơ sở hỗ

trợ cho công tác dự báo, lập kế hoạch, quy hoạch, phân tích dữ liệu quản lý,

chuyên môn, nghiệp vụ.

- 10 -


CHƢƠNG 1. SO KHỚP CHUỖI

1.1. Khái niệm so khớp chuỗi

So khớp chuỗi là một kỹ thuật đóng vai trò nền tảng trong lĩnh vực xử lý

văn bản. Hầu nhƣ tất cả các trình soạn thoải và xử lý văn bản đều cần phải có

một cơ chế để so khớp các chuỗi trong tài liệu hiện tại. Việc tích hợp các thuật

toán so khớp chuỗi là một trong những khâu cơ bản đƣợc sử dụng trong việc

triển khai phần mềm và đƣợc thực hiện trên hầu hết các hệ điều hành.

Mặc dù hiện nay dữ liệu đƣợc lƣu trữ dƣới nhiều hình thức khác nhau,

nhƣng văn bản vẫn là hình thức chủ yếu để lƣu trữ và trao đổi thông tin. Trong

nhiều lĩnh vực nhƣ so khớp, trích chọn thông tin, tin sinh học…, một lƣợng lớn

dữ liệu thƣờng đƣợc lƣu trữ trong các tập tin tuyến tính. Hơn nữa khối lƣợng dữ

liệu thu thập đƣợc tăng lên rất nhanh nên đòi hỏi phải có các thuật toán xử lý và

so khớp dữ liệu văn bản hiệu quả

So khớp chuỗi là việc so sánh một hoặc nhiều chuỗi (thƣờng đƣợc gọi là

mẫu hoặc Pattern) với văn bản để tìm vị trí và số lần xuất hiện của chuỗi đó

trong văn bản.

Ta hình thức hoá bài toán so khớp chuỗi nhƣ sau: coi văn bản là một

mảng T[1..n] có chiều dài n và khuôn mẫu là một mảng P[1..m] có chiều dài m;

các thành phần của T và P là các ký tự đƣợc rút từ một bảng chữ cái hữu hạn ∑.

Ví dụ, ta có thể có ∑ = {0,1} hoặc ∑ ={a,b,....,z}. Các mảng ký tự P và T thƣờng

đƣợc gọi là các chuỗi ký tự. Ta nói rằng một chuỗi w là tiền tố (hậu tố) của một

chuỗi x, ký hiệu là w ⊂ x (w ⊃ x), nếu x = wy (x = yw), với y là một chuỗi nào

đó. Để ngắn gọn, ta kí hiệu Pk để thể hiện tiền tố k - ký tự P[1..k] của khuôn mẫu

P[1..m]. Ta nói rằng khuôn mẫu P xảy ra với khoá chuyển s trong văn bản T

(hoặc, theo tƣơng đƣơng, nói rằng khuôn mẫu P xảy ra bắt đầu tại vị trí s + i

trong văn bản T) nếu 0 ≤ s ≤ n-m và T[s + 1..s + m] = P[1..m] (nghĩa là, nếu

T[s+j] = P[j], với 1 ≤ j ≤ m). Bài toán so khớp chuỗi là bài toán tìm tất cả các

- 11 -


khoá chuyển hợp lệ với nó một khuôn mẫu P đã cho xảy ra trong một văn bản T

đã cho.

Ví dụ: khuôn mẫu P = abaa xuất hiện một lần trong văn bản T =

abcabaabcabac, tại khoá chuyển s = 3. Với bài toán này, rõ ràng ta có một cách

làm đơn giản là tìm tất cả các khoá chuyển hợp lệ dùng một vòng lặp kiểm tra

điều kiện P[1..m] = T[s+1..s+m] với n - m + 1 giá trị có thể của s.

1.2. Lịch sử phát triển

Trong năm 1970, S.A. Cook đã chứng minh một kết quả lý thuyết giúp

suy ra sự tồn tại của một thuật toán để giải bài toán so khớp mẫu có thời gian tỷ

lệ với (M+N) trong trƣờng hợp xấu nhất.

D.E.Knuth và V.R.Pratt đã kiên trì theo đuổi kiến trúc mà Cook đã dùng

để chứng minh cho định lý của ông và nhận đƣợc một thuật toán tƣơng đối đơn

giản. Đồng thời J.H.Morris cũng khám phá ra thuật toán này.

Knuth, Morris, Pratt đã không giới thiệu thuật này của họ cho đến năm

1976, và trong thời gian này R.S.Boyer và J.S.Moore đã khám phá ra một thuật toán

nhanh hơn nhiều.

Tháng 6 – 1975, Alfred V. Aho và Margret J. Corasick đã giới thiệu thuật

toán so khớp chuỗi đa mẫu Aho Corasick trong tài liệu “Communications of the

ACM 18”.

Năm 1980, Nigel Horspool đã giới thiệu thuật toán so khớp chuỗi tƣơng

tự thuật toán KMP, nhƣng đảo ngƣợc thứ tự so sánh trong tài liệu Software -

Practice & Experience, 10(6):501-506.

Tháng 3 - 1987, R.M.Karp và M.O.Rabin đã giới thiệu thuật toán đơn

giản gần nhƣ thuật toán Brute Force có thời gian thực thi tỉ lệ với m+n trong tài

liệu IBM J. Res develop – vol 31 no.2.

- 12 -


1.3. Các cách tiếp cận

Có 4 cách tiếp cận chính của các thuật toán so khớp chuỗi:

Thuật toán cổ điển: là các thuật toán chủ yếu dựa vào sự so sánh

giữa các ký tự. Các thuật toán điển hình bao gồm Brute Force,

Naïve,…

Thuật toán máy tự động hậu tố: là các thuật toán sử dụng cấu trúc

dữ liệu hậu tố tự động để nhận ra tất cả các hậu tố của mẫu. Các

thuật toán điển hình bao gồm Knuth – Morris – Pratt, Boyer –

Moore, Horspool,…

Thuật toán bit song song: là các thuật toán khai thác bản chất song

song của các dữ liệu bit để thực hiện các thao tác cùng lúc. Các

thuật toán điển hình bao gồm Shift – Or, …

Thuật toán băm: là các thuật toán sử dụng kỹ thuật băm, tránh việc

so sánh các ký tự có độ phức tạp bậc 2. Các thuật toán điển hình

bao gồm Karp – Rabin.

Độ phức tạp tính toán: Trên thực tế có nhiều loại ký tự khác nhau nhƣ:

binary, DNA, Alphabet, numeric… và mỗi loại ký tự có độ phức tạp khác nhau.

Độ phức tạp tính toán tỉ lệ thuận với chiều dài của mẫu, chiều dài của vănbản và

độ lớn của tập các ký tự.

Các thuật toán so khớp chuỗi thƣờng đƣợc thực hiện theo 2 bƣớc xử lý sau:

Bƣớc tiền xử lý: bao gồm xử lý mẫu và Khởi tạo cấu trúc dữ liệu.

Bƣớc so khớp: thực hiện việc so khớp mẫu trong văn bản.

1.4. Ứng dụng của so khớp chuỗi

So khớp chuỗi là một trong những bài toán cơ bản của ngành Tin học. So

- 13 -


khớp chuỗi đƣợc sử dụng rộng rãi trong nhiều ứng dụng và lĩnh vực khác nhau

nhƣ:

Chức năng search trong các trình soạn thảo văn bản và web

browser.

Các công cụ so khớp nhƣ: Google Search, Yahoo Search,….

Sinh học phân tử nhƣ trong so khớp các mẫu trong DNA,

protein,….

So khớp cơ sở dữ liệu.

Trong nhiễu kênh với cho phép chấp nhận đƣợc.

Trong so khớp mẫu hoặc vết của tấn công, đột nhập và các phần

mềm độc hại.

Trong lĩnh vực an toàn mạng và an toàn thông tin….

1.5. Các dạng so khớp chuỗi

Phân loại các thuật toán so khớp dựa trên các đặc tính của mẫu ta có các

dạng: so khớp đơn mẫu, so khớp đa mẫu (mẫu là tập các xâu), so khớp mẫu mở

rộng, so khớp biểu thức chính qui với hai hƣớng tiếp cận là so khớp chính xác

và xấp xỉ.

1.5.1. So khớp đơn mẫu

Cho xâu mẫu P dộ dài m, P = P1 P2…

Pm , và xâu độ dài n, S = S1 S 2… Sn

(S thƣờng dài, là một văn bản) trên cùng một bảng chữ A. Tìm tất cả các xuất

hiện của xâu P trong S.

Trong các thuật toán so mẫu thƣờng sử dụng các khái niệm: Khúc đầu,

khúc cuối, khúc con hay xâu con của một xâu, đƣợc định nghĩa nhƣ sau: Cho 3

xâu x, y, z. Ta nói x là khúc đầu (prefix) của xâu xy, là khúc cuối (suffix) của

xâu yx và là khúc con hay xâu con (factor) của xâu yxz.

- 14 -


Thuật toán “thô” nhất và đã đƣợc sử dụng rộng rãi là Brute- Force.

Phƣơng pháp này đơn giản chỉ là lần lƣợt bắt đầu từ vị trí trong S để đối sánh

với mẫu P. Mặc dù có tốc độ chậm, thời gian xấu nhất tỉ lệ với tích m.n, song

trong nhiều ứng dụng thực tế các chuỗi phát sinh ra thƣờng có thời gian xử lý

thực sự luôn tỷ lệ với m + n. Ngoài ra, một ƣu điểm khác là nó thích hợp với cấu

trúc của hầu hết các hệ máy tính.

Cho đến nay, rất nhiều thuật toán so đơn mẫu đƣợc đƣa, trong đó kinh

điển nhất là KMP.

Có thể xem nhƣ có ba tiếp cận chung cho các thuật toán so mẫu, phụ

thuộc vào cách duyệt tìm mẫu trong văn bản. Việc đánh giá tốc độ của các thuật

toán dựa trên kích cỡ của mẫu P và bảng chữ A.

Tiếp cận thứ nhất, lần lƣợt từng ký tự của văn bản S đƣợc đọc và tại mỗi

vị trí, sau khi đối sánh với một ký tự của mẫu sẽ cập nhật sự thay đổi để nhận ra

một khả năng xuất hiện mẫu. Hai thuật toán điển hình theo tiếp cận này là KMP

và Shift - Or.

Tiếp cận thứ hai sử dụng một “cửa sổ trƣợt” trên xâu S và so khớp mẫu

trong cửa sổ này. Tại mỗi vị trí trong cửa sổ, cần tìm một khúc cuối của cửa sổ

mà là khúc cuối của xâu mẫu P. Thuật toán BM là một điển hình cho tiếp cận

này và một biến thể đơn giản hoá của nó là Horspool.

Tiếp cận thứ ba mới xuất hiện gần đây cho ra đời các thuật toán hiệu quả

về thực hành đối với mẫu P đủ dài. Cũng tƣơng tự nhƣ tiếp cận thứ hai, song tại

mỗi thời điểm sẽ tìm khúc cuối dài nhất của cửa sổ mà là khúc con của mẫu.

Thuật toán đầu tiên theo tiếp cận này là BDM và khi P đủ ngắn, một phiên bản

đơn giản hơn, hiệu quả hơn là BNDM. Với những mẫu dài, thuật toán BOM

đƣợc đánh giá là nhanh nhất

1.5.2. So khớp đa mẫu

Cho một mẫu P gồm tập các từ khoá w1, w2,….,w k và xâu vào S =

- 15 -


S1S2…Sn trên cùng bảng chữ A. Tìm sự xuất hiện của các từ khoá wi trong S.

Một cách đơn giản để tìm nhiều từ khoá trong một xâu đích là sử dụng

thuật toán so đơn mẫu nhanh nhất đối với mỗi từ khoá. Rõ ràng phƣơng pháp

này không hiệu quả khi số lƣợng từ khoá lớn.

Cả ba tiếp cận tìm đơn mẫu ở trên đều đƣợc mở rộng cho tìm đa mẫu. Hai

điển hình theo tiếp cận thứ nhất là thuật toán nổi tiếng Aho- Corasisk, có tốc độ

cải thiện đáng kể khi số từ khoá nhiều và thuật toán Multiple Shift- And, đƣợc

sử dụng hiệu quả khi tổng độ dài của mẫu P rất nhỏ 2 .

Theo tiếp cận thứ hai có thuật toán nổi tiếng Commentz - Walter, trong đó

kết hợp ý tƣởng của Boyer - Moore và Aho- Corasisk , nhanh về lý thuyết, song

lại không hiệu quả trong thực hành. Một mở rộng của thuật toán Horspool là Set

Horspool. Cuối cùng là thuật toán Wu-Manber, một phƣơng pháp pha trộn giữa

tiếp cận so khớp hậu tố (suffix search approach) và một kiểu hàm băm, đƣợc

đánh giá là nhanh trong thực hành.

Trong tiếp cận thứ ba đã có những mở rộng từ thuật toán BOM và

SBOM; tƣơng tự với Shift- Or BNDM là Multiple BNDM.

1.5.3. So mẫu mở rộng

Trong nhiều ứng dụng, so khớp mẫu không chỉ đơn giản là dãy các ký tự.

Sau đây là một số mở rộng thƣờng thấy trong các ứng dụng:

Mở rộng đơn giản nhất cho phép mẫu là một dãy các lớp hay các tập ký

tự, giả sử đƣợc đánh số thứ tự là 1,2,…,m. Bất kỳ ký tự nào trong lớp thứ i cũng

có thể đƣợc xem là ký tự thứ i của mẫu.

Mở rộng thứ hai là giới hạn khoảng trên độ dài: Một số vị trí trên mẫu

đƣợc ấn định để khớp với một dãy văn bản nào đó có độ dài nằm trong một

khoảng xác định trƣớc. Điều này thƣờng đƣợc sử dụng trong các ứng dụng

sinh- tin học, chẳng hạn tìm mẫu PROSITE.

- 16 -


Mở rộng thứ ba sử dụng các ký tự tùy chọn và ký tự lặp. Trong xuất hiện

của mẫu trên văn bản, các ký tự tuỳ chọn có thể có hoặc không có, còn các ký tự

lặp có thể có một hoặc lặp nhiều lần.

Các vấn đề nảy sinh từ ba hƣớng mở rộng trên và những kết hợp từ ba

hƣớng này đƣợc giải quyết bằng cách điều chỉnh lại thuật toán Shift - Or và

BNDM, trong đó có sử dụng cơ chế song song bit để mô phỏng otomat đa định,

cho phép tìm tất cả các xuất hiện của mẫu.

1.5.4. So khớp chính xác

Tìm một (hoặc nhiều) vị trí xuất hiện chính xác cuả một xâu ký tự P[1..m]

(mẫu so khớp - pattern) ở trong một xâu ký tự lớn hơn hay trong một đoạn văn

bản nào đó T[1..n], m<=n. Ví dụ: ta có thể tìm thấy vị trí của xâu “abc” trong

xâu “abcababc” là 1 và 6.

Phát biểu hình thức bài toán nhƣ sau: gọi Σ là một tập hữu hạn (finite set)

các ký tự. Thông thƣờng, các ký tự của cả mẫu so khớp và đoạn văn bản gốc đều

nằm trong Σ. Tập Σ tùy từng ứng dụng cụ thể có thể là bảng chữ cái tiếng Anh từ

A đến Z thông thƣờng, cũng có thể là một tập nhị phân chỉ gồm hai phần tử 0 và

1 (Σ = {0,1}) hay có thể là tập các ký tự DNA trong sinh học (Σ = {A,C,G,T}).

Phƣơng pháp đơn giản nhất là lần lƣợt xét từng vị trí i trong xâu ký tự gốc

từ 1 đến n-m+1, so sánh T[i…(i+m-1)] với P[1..m] bằng cách xét từng cặp ký tự

một và đƣa ra kết quả so khớp. Ngƣời ta còn gọi phƣơng pháp này là cách tiếp

cận ngây thơ (Naïve string search). Dƣới đây là thủ tục đặc tả của phƣơng pháp này:

NAÏVE_STRING_MATCHER (T, P)

1. n ← length [T]

2. m ← length [P]

3. for s ← 1 to n-m+1 do

4. j ← 1

5. while j ≤ m and T[s + j] = P[j] do

6. j ← j +1

- 17 -


7. If j > m then

8. return s // s là vị trí tìm được

9. return false. // không có vị trí nào thỏa mãn

Độ phức tạp trung bình của thuật toán là O(n+m), nhƣng trong trƣờng hợp

xấu nhất độ phức tạp là O(n.m), ví dụ nhƣ so khớp mẫu “”aaaab” trong xâu

“aaaaaaaaab”.

1.5.5. So khớp xấp xỉ

1.5.5.1. Phát biểu bài toán

So mẫu xấp xỉ là bài toán tìm sự xuất hiện của một mẫu trong văn bản,

trong đó sự “khớp” giữa mẫu và xuất hiện của nó có thể chấp nhận k “lỗi” (k là

một giới hạn cho trƣớc). Có thể kể ra một vài kiểu “lỗi”, nhƣ những lỗi đánh

máy hay lỗi chính tả trong hệ thống trích rút thông tin, những sự biến đổi chuỗi

gen hay các lỗi đo đạc trong sinh- tin học và những lỗi truyền dữ liệu trong các

hệ thống xử lý tín hiệu,… Vì trong các hệ thống tin học khó có thể tránh đƣợc

các “lỗi” nên vấn đề so khớp xấp xỉ càng trở nên quan trọng.

Đặc biệt, khi sử dụng các hệ thống trích rút thông tin, ngƣời dùng ngày nay

còn đòi hỏi cả những kết quả gần giống hoặc có đƣợc kết quả phù hợp trả về nếu có

sự sai sót trong mẫu hay văn bản. Trong trƣờng hợp này “lỗi” có thể do nhiều

nguyên nhân khác nhau, có thể kể ra nhƣ sau:

- Câu truy vấn sai chính tả, xâu so khớp không đúng cú pháp so với văn bản.

- Lỗi in ấn, sai lỗi chính tả, sử dụng dấu chấm sai,…

- Do sự biến đổi hình thái từ trong một số ngôn ngữ.

- Dữ liệu đƣa vào cơ sở dữ liệu không chính xác, thƣờng xảy ra với tên

ngƣời, địa chỉ…

- Thông tin ngƣời tìm đƣa vào không chính xác, chỉ “đại loại”.

- 18 -


Vì vậy, một vấn đề đặt ra cho các hệ thống trích rút thông tin ngày nay là

đáp ứng đƣợc nhu cầu so khớp “mềm dẻo” này của ngƣời sử dụng.

Bài toán so mẫu xấp xỉ tổng quát đƣợc phát biểu nhƣ sau: Cho văn bản T

độ dài n và xâu mẫu P độ dài m trên cùng một bảng chữ A. Tìm các vị trí trong

văn bản khớp với mẫu, cho phép nhiều nhất k lỗi.

1.5.5.2. Các tiếp cận so khớp xấp xỉ

Thuật toán so khớp xấp xỉ hiện nay chia thành 4 loại:

1) Các thuật toán dựa trên quy hoạch động: Đây là tiếp cận xuất hiện đầu

tiên và đã đƣợc dùng để tính khoảng cách soạn thảo.

2) Các thuật toán sử dụng otomat so khớp: Trƣớc tiên xây dựng một hàm

của mẫu P và số lỗi k, sau đó tạo otomat đa định hữu hạn. Đây là hƣớng tiếp cận

đƣợc quan tâm nhiều vì có độ phức tạp thời gian trong trƣờng hợp xấu nhất là

O(n) (tuy nhiên đòi hỏi độ phức tạp không gian lớn hơn).

3) Các thuật toán sử dụng cơ chế song song bit: cách tiếp cận này cho ra

rất nhiều thuật toán hiệu quả nhờ khai thác bản chất song song của các phép toán

bit trên một từ máy trong bộ vi xử lý. Nói chung song song bit đƣợc dùng để

song song hoá các kỹ thuật khác, nhƣ tạo otomat đa định, lập ma trận quy hoạch

động. Nói chung kỹ thuật này làm việc khá tốt với mẫu ngắn và tăng tốc đáng kể

so với những cài đặt không tận dụng khả năng song song của thanh ghi. Một số

thuật toán dùng cơ chế song song bit là BPR và BPD để tái tạo một otomat đa

định hữu hạn và BDM để tái tạo các thuật toán quy hoạch động.

4) Các thuật toán sử dụng cơ chế lọc: Cố gắng thu hẹp không gian so

khớp của bài toán bằng cách loại đi các văn bản mà chắc chắn không chứa một

đoạn nào “khớp” với mẫu. Nói chung, phƣơng pháp này đạt đƣợc bằng cách áp

- 19 -


dụng kỹ thuật so mẫu chính xác cho các mẫu nhỏ của mẫu. Hai thuật toán hiệu

quả nhất theo tiếp cận này là PEX và ABNDM. Trong PEX, mẫu đƣợc chia

thành k + 1 đoạn và sắp xếp để so khớp đa mẫu trên các đoạn này, vì ít nhất một

đoạn phải có mặt trong một xuất hiện bất kỳ. Thuật toán ABNDM là một mở

rộng của thuật toán BNDM, trong đó tái tạo otomat đa định hữu hạn cho so khớp

xấp xỉ. Nói chung, các thuật toán sử dụng cơ chế lọc làm việc tốt hơn tỷ lệ k/m

nhỏ. Đối với trƣờng hợp tỷ lệ k/m lớn, các thuật toán sử dụng cơ chế song song

bit đƣợc đánh giá tốt hơn.

Đối với bài toán so khớp đa mẫu cũng đã có một số phát triển theo hƣớng

xấp xỉ. Thuật toán MultiHash chỉ làm việc với k = 1 song rất hiệu quả khi số

lƣợng mẫu lớn; MultiPEX là thuật toán hiệu quả nhất khi tỷ lệ k/m nhỏ; Multi

BP xây dựng các NFA của tất cả các mẫu và sử dụng kết quả này làm bộ lọc,

đây là lựa chọn tốt nhất cho tỷ lệ k/m cỡ trung bình.

Một vài tiếp cận xấp xỉ cho bài toán tìm mẫu mở rộng và tìm biểu thức

chính qui có thể kể ra nhƣ: thuật toán dựa trên quy hoạch động cho biểu thức

chính qui; thuật toán sử dụng một otomat đa định hữu hạn cho phép có “lỗi”,

thuật toán song song bit dựa trên phƣơng pháp của BPR, …

1.5.5.3. Độ tương tự giữa hai xâu

Để so khớp xấp xỉ, cần sử dụng một hàm khoảng cách đo độ tƣơng tự

giữa hai xâu. Tƣơng tự ở đây đƣợc hiểu là giữa hai xâu ký tự có một vài sai khác

ở những lỗi có thể nhận ra bằng mắt thƣờng, không xét về khía cạnh ngữ nghĩa

(OCR- optical character recognition errors), chẳng hạn “Việt Nam” và “Việt

Nan” hay “Việtt Nan”,… Có thể kể ra một số kỹ thuật phổ biến đo độ tƣơng tự

giữa hai xâu: Xâu con chung dài nhất, dãy con chung dài nhất, khoảng cách soạn

thảo. Nhiều ứng dụng sử dụng các biến thể của các hàm khoảng cách này.

1) Khoảng cách soạn thảo: Đối với hai xâu x, y khoảng cách soạn thảo

Edit distance(x,y) là số nhỏ nhất các phép sửa đổi về mặt soạn thảo để biến đổi

- 20 -


xâu x thành xâu y (việc tính toán khá phức tạp). Khoảng cách soạn thảo càng lớn

thì sự khác nhau giữa hai xâu càng nhiều (hay độ tƣơng tự càng nhỏ) và ngƣợc

lại. Khoảng cách soạn thảo thƣờng để kiểm tra chính tả hay tiếng nói. Tuỳ thuộc

vào quy ƣớc về các phép sửa đổi mà ta nhận đƣợc các loại khoảng cách soạn

thảo khác nhau, chẳng hạn nhƣ:

Khoảng cách Hamming: Phép sửa đổi chỉ là phép thay thế ký tự.

Khoảng cách Levenshtein: Phép sửa đổi bao gồm: Chèn, xoá, và thay

thế ký tự.

Khoảng cách Damerau: Phép sửa đổi bao gồm: Chèn, xoá, thay thế

và hoán vị liền kề của các ký tự.

2) Xâu con chung dài nhất (hay khúc con chung dài nhất): Một xâu w là

xâu con hay khúc con (substring or factor) của xâu x nếu x = uwv (u, v có thê

rỗng). Xâu w là khúc con chung của hai xâu x, y nếu w đồng thời là khúc con

của x và y. Khúc con chung dài nhất của hai xâu x và y, ký hiệu LCF (x,y), là một

khúc con có độ dài lớn nhất.

3) Dãy con chung dài nhất: Một dãy con của xâu x là một dãy các ký tự có

đƣợc bằng cách xoá đi không, một hoặc nhiều ký tự từ x. Dãy con chung của

hai xâu x, y là một dãy con của cả hai xâu x và y. Dãy con chung của x và y có

độ dài lớn nhất đƣợc gọi là dãy con chung dài nhất LCS (x,y). Có thể dùng độ

dài dãy con chung của hai xâu x, y để tính khoảng cách Levenstein giữa x và y

theo công thức:

LevDistance (x,y) = m + n - 2 length(LCS( x,y))

1.5. Một số thuật toán so mẫu

1.5.1. Thuật toán Brute Force

Thuật toán Brute Force thử kiểm tra tất cả các vị trí trên văn bản từ 1 cho

đến n-m+1. Sau mỗi lần thử thuật toán brute force dịch mẫu sang phải một ký tự

- 21 -


cho đến khi kiểm tra hết văn bản. Thuật toán không cần công việc chuẩn bị cũng

nhƣ các mảng phụ cho quá trình tìm kiếm. Độ phức tạp tính toán của thuật toán

này là O(n*m).

function IsMatch(const X: string; m: integer;

const Y: string; p: integer): boolean;

var i: integer;

begin

IsMatch := false;

Dec(p);

for i := 1 to m do

if X <> Y[p + i] then Exit;

IsMatch := true;

end;

procedure BF(const X: string; m: integer; const Y: string; n: integer);

var i: integer;

begin

for i := 1 to n - m + 1 do

if IsMatch(X, m, Y, i) then

Output(i); { Thông báo tìm thấy mẫu tại vị trí i của văn bản }

end;

1.5.2. Thuật toán Karp-Rabin

Karp-Rabin bài toán tìm kiếm chuỗi không khác nhiều so với bài toán tìm

kiếm chuẩn. Tại đây một hàm băm đƣợc dùng để tránh đi sự so sánh không cần

thiết. Thay vì phải so sánh tất các vị trí của văn bản, ta chỉ cần so sánh những

cửa sổ bao gồm những ký tự “có vẻ giống” mẫu.

Trong thuật toán này hàm băm phải thỏa mãn một số tính chất nhƣ phải

dễ dàng tính đƣợc trên chuỗi, và đặc biệt công việc tính lại phải đơn giản để ít

ảnh hƣởng đến thời gian thực hiện của thuật toán. Và hàm băm đƣợc chọn ở đây là:

hash(w[i…i+m-1]) = h

- 22 -


= (w*dm-1 + w[i+1]*dm-2 + … w[i+m-1]*d0) mod q

Việc tính lại hàm băm sau khi dịch cửa sổ đi một ký tự chỉ đơn gian nhƣ sau:

h = ((h – w*dm-1)*d + w[i+m]

Trong bài toán này ta có thể chọn d = 2 để tiện cho việc tính toán a*2

tƣơng đƣơng a shl 1. Và không chỉ thế ta chọn q = MaxLongint khi đó phép mod

q không cần thiết phải thực hiện vì sự tràn số trong tính toán chính là một phép

mod có tốc độ rất nhanh.

Việc chuẩn bị trong thuật toán Karp-Rabin có độ phức tạp O(m). Tuy vậy

thời gian tìm kiếm lại tỉ lệ với O(m*n) vì có thể có nhiều trƣờng hợp hàm băm

của chúng ta bị lừa và không phát huy tác dụng. Nhƣng đó chỉ là những trƣờng

hợp đặc biệt, thời gian tính toán của thuật toán KR trong thực tế thƣờng tỉ lệ với

O(n+m). Hơn nữa thuật toán KR có thể dễ dàng mở rộng cho các mẫu, văn bản

dạng 2 chiều, do đó khiến cho nó trở nên hữu ích hơn so với các thuật toán còn

lại trong việc xử lý ảnh.

procedure KR(const X: string; m: integer;

const Y: string; n: integer);

var

dM, hx, hy: longint;

i, j: integer;

begin

dM := 1;

for i := 1 to m - 1 do dM := dM shl 1;

hx := 0;

hy := 0;

for i := 1 to m do

begin

hx := (hx shl 1) + Ord(X);

hy := (hy shl 1) + Ord(Y);

end;

- 23 -


j := 1;

while j <= n - m do

begin

if hx = hy then

if IsMatch(X, m, Y, j) then Output(j);

{hàm IsMatch trong phần BruteForce}

hy := ((hy - Ord(Y[j])*dM) shl 1) + Ord(Y[j + m]); {Rehash}

Inc(j);

end;

if hx = hy then

if IsMatch(X, m, Y, j) then Output(j);

end;

- 24 -


1.5.3. Thuật toán BM ( Boyer- Moor)

Một tiếp cận phổ biến trong các thuật toán so đơn mẫu là duyệt tuần tự

qua tất cả các ký tự trên xâu vào S, mỗi lần một ký tự. Nhƣng trong thuật toán

BM, có thể có những bƣớc nhẩy xa trên S đƣợc thực hiện, nhờ vậy BM đƣợc

đánh giá là thuật toán nhanh nhất về thực hành, đây là lựa chọn hiệu quả cho

những ứng dụng thông thƣờng nhƣ các trình soạn thảo văn bản.

Ý tƣởng cơ bản của thuật toán là sử dụng một “Cửa sổ trƣợt” nhƣ sau:

“Cửa sổ” thực ra là một khúc độ dài m trên xâu vào S (m là độ dài của mẫu P)

đƣợc đối sánh với mẫu tại một thời điểm nào đó. Mỗi lần đối sánh mẫu P với

một cửa sổ trên S bằng cách so sánh từng ký tự từ phải sang trái. Khi gặp ký tự

không khớp, cửa sổ trƣợt sang phải qua một đoạn trên S (tƣơng ứng với việc

dịch mẫu P sang phải). Trƣờng hợp tốt nhất khi sự không khớp xảy ra tại vị trí

Pm và ký tự không khớp là Sk lại không phải là một ký tự trong mẫu P, lúc đó có

thể an toàn trƣợt cửa sổ sang phải qua m vị trí trên S và bắt đầu quá trình tìm

kiếm mới bởi việc so sánh Pm và Sk+ m.

Giả sử tại một thời điểm đang xét cửa sổ Sk - m+ 1Sk - m + 2 .... Sk và bắt đầu

so sánh Pmvới Sk.

(1) Giả sử Pm Sk có hai khả năng:

Nếu vị trí xuất hiện phải nhất của ký tự Sk trong P là m - g, ta có thể

dịch mẫu P sang phải g vị trí sao cho Pm-g dóng thẳng với Sk rồi bắt

đầu lại quá trình đối sánh bởi phép so sánh Pm và S k+ g

Nếu ký tự Sk không có mặt trong P, ta có thể dịch mẫu P sang phải

m vị trí. Đây là bƣớc dịch chuyển xa nhất có thể mà vẫn không bỏ

sót sự xuất hiện nào của mẫu.

(2) Giả sử m - i ký tự cuối của mẫu P đã khớp với m - i ký tự cuối của

S(k). Nếu i = 0, ta đã tìm đƣợc một xuất hiện của mẫu P. Ngƣợc lại, nếu i > 0 và

Pi Sk -m+i, xét hai khả năng:

- 25 -


Nếu vị trí xuất hiện trái nhất của ký tự Sk -m+i trong P là i - g, khi đó

mẫu P đƣợc dịch sang phải g vị trí sao cho Pi-g dóng thẳng với Sk-m+i

và sẽ bắt đầu quá trình đối sánh mới, bắt đầu từ Pm so với Sk+g. Nếu

Pi-g nằm bên phải của Pi (khi g < 0) thì mẫu P chỉ dịch sang phải 1

vị trí.

Giả sử sufi(P) là một xâu con của Pi+1-gPi+2-g....Pm-gvà Pi-g Pi (nếu

có nhiều xuất hiện nhƣ vậy của sufi(P) thì chọn vị trí phải nhất).

Khi đó sẽ dịch mẫu P sang phải một đoạn dài hơn so với trƣờng

hợp (2a) sao cho khúc Pi+1-gPi+2-g....Pm-g dóng thẳng với khúc Sk-

m+i+1Sk-m+i+2...Sk và bắt đầu quá trình đối sánh mới từ Pm so với Sk+g.

Nhƣ vậy, khi Pi Sj, mẫu P sẽ dịch sang phải đi một số vị trí. Thuật toán

sử dụng hai bảng d1và d2 để tính toán bƣớc địch chuyển này.

Bảng d1 bao hàm trƣờng hợp (1) và (2a): Với mỗi ký tự c, d1 c là số i lớn

nhất sao cho c = Pi hoặc d c = m nếu c không xuất hiện trong mẫu P.

Bảng d2 bao hàm trƣờng hợp (2b): Với mỗi i, 1 i m, d2 i đƣợc xác

định là: d2 i = min g + m - i| g 1 và (g i hoặc Pi-g Pi) và ((g k hoặc Pk-g

= Pk) với i k m)

Có nhiều cách tính toán bảng d2 đƣợc đƣa ra. Thuật toán dƣới đây tính

bảng dịch chuyển d2 là của Knuth, có sự sửa đổi của Mehlhorn. Thuật toán sử

dụng hàm f có tính chất f[m] = m+1 và với 1 j < m, f j = min i j < i < m và

Pi+1Pi+2....Pm = Pj+1Pj+2....Pm+j-i .

Thuật tính bảng dịch chuyển d2

procedure computed 2();

begin

for i: = 1 to m do d2 i : = 2 *m- i;

j := m; k: = m+ 1;

while j > 0 do

- 26 -


begin

f j : = k;

while k <= m and Pj Pi do

begin

d2 k := min d2 k , m- j ;

k: = f k];

end;

j := j - 1; k := k - 1;

end;

for i: = 1 to k do d2 i : = min d2 i , m +k - i

j: = f k ;

while k < = m do

begin

while k <=j do

begin

d2 k := min d2 k , j-k + m

k := k + 1;

end;

j: = f j ;

end;

end;

Thuật toán BM tìm sự xuất hiện của mẫu P trong xâu vào S

procedure BM();

var i, j: integer;

counter: integer;

begin

j:= m; counter: = 0;

while j <= n do

begin

i: = m;

while i >0 and Sj Pi do

begin i: = i - 1; j: = j - 1; end;

- 27 -


if i: = 0 then

begin Ghi nhận một lần xuất hiện mẫu tại vị trí j + 1;

counter: = counter + 1;

j := j + m + 1;

end;

else j: =j+ max d1 Sj , d2 i ;

end;

Ghi nhận counter;

end;

Độ phức tạp của thuật toán: Độ phức tạp thời gian là O(m + n) và độ phức

tạp không gian là O(m).

1.5.4. Các thuật toán khác

Một số thuật toán nêu trên chƣa phải là tất cả các thuật toán tìm kiếm

chuỗi hiện có. Nhƣng chúng đã đại diện cho đa số các tƣ tƣởng dùng để giải bài

toán tìm kiếm chuỗi.

Các thuật toán so sánh mẫu lần lƣợt từ trái sang phải thƣờng là các dạng

cải tiến (và cải lùi) của thuật toán Knuth-Morris-Pratt và thuật toán sử dụng

Automat nhƣ: Forward Dawg Matching, Apostolico-Crochemore, Not So Naive, …

Các thuật toán so sánh mẫu từ phải sang trái đều là các dạng của thuật

toán Boyer-Moore. Thuật toán BM là thuật toán tìm kiếm rất hiệu quả trên thực

tế nhƣng độ phức tạp tính toán lý thuyết lại là O(m*n). Chính vì vậy những cải

tiến của thuật toán này cho độ phức tạp tính toán lý thuyết tốt nhƣ: thuật toán

Apostolico-Giancarlo đánh dấu lại những ký tự đã so sánh rồi để khỏi bị so sánh

lặp lại, thuật toán Turbo-BM đánh giá chặt chẽ hơn các thông tin trƣớc để có thể

dịch đƣợc xa hơn và ít bị lặp, … Còn có một số cải tiến khác của thuật toán BM

không làm giảm độ phức tạp lý thuyết mà dựa trên kinh nghiệm để có tốc độ tìm

kiếm nhanh hơn trong thực tế. Ngoài ra, một số thuật toán kết hợp quá trình tìm

kiếm của BM vào hệ thống Automat mong đạt kết quả tốt hơn.

- 28 -


Các thuật toán so sánh mẫu theo thứ tự đặc biệt:

* Thuật toán Galil-Seiferas và Crochemore-Perrin chúng chia mẫu thành

hai đoạn, đầu tiên kiểm tra đoạn ở bên phải rồi mới kiểm tra đoạn bên trái với

chiều từ trái sang phải.

* Thuật toán Colussi và Galil-Giancarlo lại chia mẫu thành hai tập và tiến

hành tìm kiếm trên mỗi tập với một chiều khác nhau.

* Thuật toán Optimal Mismatch và Maximal Shift sắp xếp thứ tự mẫu dựa

vào mật độ của ký tự và khoảng dịch đƣợc.

* Thuật toán Skip Search, KMP Skip Search và Alpha Skip Search dựa sự

phân bố các ký tự để quyết đinh vị trí bắt đầu của mẫu trên văn bản.

Các thuật toán so sánh mẫu theo thứ tự bất kỳ: những thuật toán này

có thể tiến hành so sánh mẫu với cửa sổ theo một thứ thự ngẫu nhiên. Những

thuật toán này đều có cài đặt rất đơn giản và thƣờng sử dụng ý tƣởng ký tự

không khớp của thuật toán Boyer-Moore.

1.6. Khớp chuỗi với otomat hữu hạn

1.6.1. Otomat hữu hạn

Ôtômát hữu hạn FA là một mô hình tính toán của hệ thống với sự mô tả

bởi các input và output. Tại mỗi thời điểm, hệ thống có thể đƣợc xác định ở một

trong số hữu hạn các cấu hình nội bộ gọi là các trạng thái. Mỗi trạng thái của hệ

thống thể hiện sự tóm tắt các thông tin liên quan đến những input đã chuyển qua

và xác định các phép chuyển kế tiếp trên dãy input tiếp theo [5].

Trong khoa học máy tính, có nhiều hệ thống trạng thái hữu hạn, và lý

thuyết về ôtômát hữu hạn là một công cụ thiết kế hữu ích cho các hệ thống này.

Chẳng hạn, một hệ chuyển mạch nhƣ bộ điều khiển trong máy tính. Một chuyển

mạch thì bao gồm một số hữu hạn các cổng input, mỗi cổng có 2 giá trị 0 hoặc 1.

Các giá trị đầu vào này sẽ xác định 2 mức điện thế khác nhau ở cổng output.

- 29 -


Mỗi trạng thái của một mạng chuyển mạch với n cổng bất kỳ sẽ là một trƣờng

hợp trong 2n phép gán của 0 và 1 đối với các cổng khác nhau. Các chuyển mạch

thì đƣợc thiết kế theo cách này, vì thế chúng có thể đƣợc xem nhƣ hệ thống

trạng thái hữu hạn. Các chƣơng trình sử dụng thông thƣờng, chẳng hạn trình

sọan thảo văn bản hay bộ phân tích từ vựng trong trình biên dịch máy tính cũng

đƣợc thiết kế nhƣ các hệ thống trạng thái hữu hạn. Ví dụ bộ phân tích từ vựng sẽ

quét qua tất cả các dòng ký tự của chƣơng trình máy tính để tìm nhóm các chuỗi

ký tự tƣơng ứng với một tên biến, hằng số, từ khóa, …Trong quá trình xử lý

này, bộ phân tích từ vựng cần phải nhớ một số hữu hạn thông tin nhƣ các ký tự

bắt đầu hình thành những chuỗi từ khóa. Lý thuyết về ôtômát hữu hạn thƣờng

đƣợc dùng đến nhiều cho việc thiết kế các công cụ xử lý chuỗi hiệu quả.

Máy tính cũng có thể đƣợc xem nhƣ một hệ thống trạng thái hữu hạn.

Trạng thái hiện thời của bộ xử lý trung tâm, bộ nhớ trong và các thiết bị lƣu trữ

phụ ở mỗi thời điểm bất kỳ là một trong những số rất lớn và hữu hạn của số

trạng thái. Bộ não con ngƣời cũng là một hệ thống trạng thái hữu hạn, vì số các

tế bào thần kinh hay gọi là neurons là số có giới hạn, nhiều nhất có thể là 235

.

Lý do quan trọng nhất cho việc nghiên cứu các hệ thống trạng thái hữu

hạn là tính tự nhiên của khái niệm và khả năng ứng dụng đa dạng trong nhiều

lĩnh vực thực tế. Ôtômát hữu hạn đƣợc chia thành 2 loại: đơn định (DFA) và

không đơn định (NFA). Cả hai loại ôtômát hữu hạn đều có khả năng nhận dạng

chính xác tập chính quy. Ôtômát hữu hạn đơn định có khả năng nhận dạng ngôn

ngữ dễ dàng hơn ôtômát hữu hạn không đơn định, nhƣng thay vào đó thông

thƣờng kích thƣớc của nó lại lớn hơn so với ôtômát hữu hạn không đơn định

tƣơng đƣơng.

1.6.1.1. Ôtômát hữu hạn đơn định DFA

Một ôtômát hữu hạn đơn định DFA (Deterministic Finite Automata) gồm

một tập hữu hạn các trạng thái và một tập các phép chuyển từ trạng thái này tới

trạng thái khác trên các ký hiệu nhập đƣợc chọn từ một bộ chữ cái Σ nào đó.

- 30 -


Mỗi ký hiệu nhập có đúng một phép chuyển khỏi mỗi trạng thái (có thể chuyển

trở về chính nó). Một trạng thái, thƣờng ký hiệu là q0, gọi là trạng thái bắt đầu

(trạng thái ôtômát bắt đầu). Một số trạng thái đƣợc thiết kế nhƣ là các trạng thái

kết thúc hay trạng thái chấp nhận.

Một đồ thị có hƣớng, gọi là sơ đồ chuyển tƣơng ứng với một DFA nhƣ

sau: các đỉnh của đồ thị là các trạng thái của DFA; nếu có một đƣờng chuyển từ

trạng thái q đến trạng thái p trên input a thì có một cung nhãn a chuyển từ trạng

thái q đến trạng thái p trong sơ đồ chuyển. DFA chấp nhận một chuỗi x nếu nhƣ

tồn tại dãy các phép chuyển tƣơng ứng trên mỗi ký hiệu của x dẫn từ trạng thái

bắt đầu đến một trong những trạng thái kết thúc.

Ví dụ sơ đồ chuyển của một DFA đƣợc mô tả trong dƣới. Trạng thái khởi

đầu q0 đƣợc chỉ bằng mũi tên có nhãn "Start". Chỉ có duy nhất một trạng thái kết

thúc, cũng là q0 trong trƣờng hợp này, đƣợc chỉ ra bằng hai vòng tròn. Ôtômát

này chấp nhận tất cả các chuỗi số 0 và số 1 với số số 0 và số số 1 là số chẵn.

Hình 1.1. Sơ đồ chuyển của một DFA

Một cách hình thức ta định nghĩa ôtômát hữu hạn là bộ gồm năm thành

phần (Q, Σ, δ, q0, F), trong đó:

Q là tập hợp hữu hạn các trạng thái.

Σ là bộ chữ cái nhập hữu hạn.

δ là hàm chuyển ánh xạ từ Q × Σ → Q, tức là δ(q, a) là một trạng

thái đƣợc cho bởi phép chuyển từ trạng thái q trên ký hiệu nhập a.

- 31 -


q0 ∈ Q là trạng thái bắt đầu.

F ⊆ Q là tập các trạng thái kết thúc.

Ta vẽ DFA nhƣ là bộ điều khiển hữu hạn, với mỗi trạng thái thuộc Q,

DFA đọc một chuỗi các ký hiệu a từ Σ viết trên băng.

Hình 1.2. Mô tả một DFA

Trong một lần chuyển, DFA đang ở trạng thái q đọc ký hiệu nhập a trên

băng, chuyển sang trạng thái đƣợc xác định bởi hàm chuyển δ(q, a), rồi dịch đầu

đọc sang phải một ký tự. Nếu δ(q, a) chuyển đến một trong những trạng thái kết

thúc thì DFA chấp nhận chuỗi đƣợc viết trên băng input phía trƣớc đầu đọc,

nhƣng không bao gồm ký tự tại vị trí đầu đọc vừa dịch chuyển đến. Trong

trƣờng hợp đầu đọc đã dịch đến cuối chuỗi trên băng, thì DFA mới chấp nhận

toàn bộ chuỗi trên băng.

Để có thể mô tả một cách hình thức hoạt động của một DFA trên chuỗi, ta

mở rộng hàm chuyển δ để áp dụng đối với một trạng thái trên chuỗi hơn là một

trạng thái trên từng ký hiệu. Ta định nghĩa hàm chuyển δ nhƣ một ánh xạ từ Q ×

Σ → Q với ý nghĩa δ(q, w) là trạng thái DFA chuyển đến từ trạng thái q trên

chuỗi w.

1. δ (q, ε) = q

2. δ (q, wa) = δ(δ (q, w), a), với mọi chuỗi w và ký hiệu nhập a.

Trong đó:

Q là tập các trạng thái. Ký hiệu q và p (có hoặc không có chỉ số) là

các trạng thái, q là trạng thái bắt đầu.

- 32 -


Σ là bộ chữ cái nhập. Ký hiệu a, b (có hoặc không có chỉ số) và các

chữ số là các ký hiệu nhập.

δ là hàm chuyển.

F là tập các trạng thái kết thúc.

w, x, y và z (có hoặc không có chỉ số) là các chuỗi ký hiệu nhập.

Một chuỗi w đƣợc chấp nhập bởi ôtômát hữu hạn M (Q, Σ, δ, q0, F) nếu

δ(q, w) = p với p ∈ F. Ngôn ngữ đƣợc chấp nhận bởi M, ký hiệu L(M) là tập

hợp: L(M) = { w | δ (q, w) ∈ F }

Ví dụ: theo khái niệm hình thức, ta có DFA đƣợc xác định bởi M (Q, Σ, δ,

q0, F) với Q = {q0, q1, q2, q3}, Σ = {0, 1}, F = {q0} và hàm chuyển δ nhƣ sau:

Bảng 1.1. Ví dụ hàm chuyển δ của DFA

Giả sử chuỗi w = 110101 đƣợc nhập vào M.

Ta có δ(q0, 1) = q1 và δ(q1, 1) = q0 ,vậy δ(q0, 11) = δ(δ(q0,1),1) =

δ(q1, 1) = q0.

Tiếp tục δ(q0, 0) = q2, vậy δ(q0, 110) = δ(δ(q0, 11), 0) = q2.

Tiếp tục ta có δ(q, 1101) = q3, δ(q0, 11010) = q1

Và cuối cùng δ(q0, 110101) = q0 ∈ F.

(Hay δ(q0, 110101) = δ(q1, 10101) = δ(q0, 0101) = δ(q2, 101) = δ(q3, 01) =

δ(q1, 1) =q0 ∈ F).

Vậy 110101 thuộc L(M). Ta có thể chứng minh rằng L(M) là tập mọi

chuỗi có số chẵn số 0 và số chẵn số 1.

Theo mô tả DFA nhƣ trên, ta thấy cũng có thể dùng bảng hàm chuyển để

mô tả các phép chuyển trạng thái của một ôtômát hữu hạn. Trong bảng hàm

- 33 -


chuyển, hàng chứa các trạng thái thuộc tập trạng thái của ôtômát và cột là các ký

hiệu thuộc bộ chữ cái nhập. Bảng hàm chuyển gợi ý cho chúng ta một cấu trúc

dữ liệu để mô tả cho một ôtômát hữu hạn, đồng thời cũng cho thấy có thể dễ

dàng mô phỏng hoạt động của DFA thông qua một chƣơng trình máy tính,

chẳng hạn dùng cấu trúc vòng lặp.

Một cách tổng quát, ta thấy tập Q của DFA thể hiện các trạng thái lƣu trữ

của ôtômát trong quá trình đoán nhận ngôn ngữ, và nhƣ vậy khả năng lƣu trữ

của ôtômát là hữu hạn. Mặt khác, hàm chuyển δ là hàm toàn phần và đơn trị, cho

nên các bƣớc chuyển của ôtômát luôn luôn đƣợc xác định một cách duy nhất.

Chính vì hai đặc điểm này mà DFA mô tả nhƣ trên đƣợc gọi là ôtômát hữu hạn

đơn định.

1.6.1.2. Ôtômát hữu hạn không đơn định NFA

Xét một dạng sửa đổi mô hình DFA để chấp nhận không, một hoặc nhiều

hơn một phép chuyển từ một trạng thái trên cùng một ký hiệu nhập. Mô hình

mới này gọi là ôtômát hữu hạn không đơn định (NFA - Nondeterministic Finite

Automata).

Một chuỗi ký hiệu nhập a1 a2 ... an đƣợc chấp nhận bởi một NFA nếu có

tồn tại một chuỗi các phép chuyển, tƣơng ứng với chuỗi nhập, từ trạng thái bắt

đầu đến trạng thái kết thúc. Chẳng hạn, chuỗi 01001 đƣợc chấp nhận bởi ôtômát

trong hình dƣới đây vì có chuỗi phép chuyển qua các trạng thái q0, q0, q0, q3, q4,

q4 có nhãn tƣơng ứng là 0,1, 0, 0, 1. NFA này chấp nhận tất cả các chuỗi có hai

số 0 liên tiếp hoặc hai số 1 liên tiếp.

- 34 -


Hình 1.3. Sơ đồ của một NFA

Có thể xem ôtômát hữu hạn đơn định là một trƣờng hợp đặc biệt của

NFA, trong đó mỗi trạng thái chỉ có duy nhất một phép chuyển trên mỗi ký hiệu

nhập. Vì thế trong DFA, với một chuỗi nhập w và trạng thái q, chỉ có đúng một

đƣờng đi nhãn w bắt đầu từ q. Để xác định chuỗi w có đƣợc chấp nhận bởi DFA

hay không chỉ cần kiểm tra đƣờng đi này. Nhƣng đối với NFA, có thể có nhiều

đƣờng đi có nhãn là w, và do đó tất cả phải đƣợc kiểm tra để thấy có hay không

có đƣờng đi tới trạng thái kết thúc.

Tƣơng tự nhƣ DFA, NFA cũng hoạt động với một bộ điều khiển hữu hạn

đọc trên băng nhập. Tuy nhiên, tại mỗi thời điểm, bộ điều khiển có thể chứa một

số bất kỳ trạng thái. Khi có sự lựa chọn trạng thái kế tiếp, chẳng hạn nhƣ từ

trạng thái q0 trên k hiệu nhập 0 ở hình trên, ta tƣởng tƣợng nhƣ có các bản sao

của ôtômát đang thực hiện đồng thời. Mỗi trạng thái kế tiếp mà ôtômát có thể

chuyển đến sẽ tƣơng ứng với một bản sao của ôtômát mà tại đó bộ điều khiển

đang chứa trạng thái đó.

Ví dụ với chuỗi 01001, ta có :

- 35 -


Hình 1.4. Di chuyển chuỗi

Một cách hình thức ta định nghĩa ôtômát hữu hạn không đơn định NFA là

một bộ 5 thành phần (Q, Σ, δ, q0, F) trong đó Q, Σ, q0 và F có ý nghĩa nhƣ trong

DFA, nhƣng δ là hàm chuyển ánh xạ từ Q × Σ → 2Q.

Khái niệm δ(q, a) là tập hợp tất cả các trạng thái p sao cho có phép chuyển

trên nhãn a từ trạng thái q tới p.

Để thuận tiện trong việc mô tả hoạt động ôtômát trên chuỗi, ta mở rộng

hàm chuyển δ ánh xạ từ Q × Σ* → 2

Q nhƣ sau:

1. δ(q, ε) = {q}

2. δ(q, wa) = { p | có một trạng thái r trong δ(q, w) mà p thuộc δ(r, a)}

= δ(δ(q, w), a)

3. δ(P, w) = ∪q ∈ P δ(q, w) , ∀P ⊆ Q.

Ngôn ngữ L(M), với M là ôtômát hữu hạn không đơn định NFA (Q, Σ, δ,

q , F) là tập hợp: L(M) = {w | δ(q0, w) có chứa một trạng thái trong F}

Ví dụ: Xét sơ đồ chuyển của hình 2.3. Theo khái niệm hình thức, ta có:

NFA M ({q0, q1, q2, q3, q4}, {0, 1}, δ, q0}) với hàm chuyển δ nhƣ sau:

Bảng 1.2. Ví dụ hàm chuyển trạng thái δ của NFA

Xét chuỗi nhập w = 01001

- 36 -


Ta có: δ (q0, 0) = {q0, q3}

δ (q0, 01) = δ(δ(q0, 0),1) = δ({q0, q3},1) = δ (q0, 1) ∪ δ (q3, 1) = {q0, q1}

Tƣơng tự , ta có thể tính :

δ (q0, 010) = {q0, q3}

δ (q0, 0100) = {q0, q3, q4}

và δ (q0, 01001) = {q0, q1, q4}

Do q4 ∈ F nên w ∈ L (M).

1.6.2. Otomat khớp chuỗi

1.6.2.1. Giới thiệu

So khớp chuỗi là thực hiện tìm kiếm và xác định chính xác vị trí xuất hiện

của đối tƣợng đƣợc chọn, còn gọi là mẫu trong văn bản. Văn bản và các mẫu là

các chuỗi ký tự, chúng là những chuỗi gồm hữu hạn các ký tự thuộc tập hữu hạn

các ký tự trong tập hữu hạn các ký tự chữ cái.

Ta hình thức hoá bài toán so khớp chuỗi nhƣ sau: coi văn bản là một

mảng T[1..n] có chiều dài n và khuôn mẫu là một mảng P[1..m] có chiều dài m;

các thành phần của T và P là các ký tự đƣợc rút từ một bảng chữ cái hữu hạn ∑.

Ví dụ, ta có thể có ∑ = {0,1} hoặc ∑ ={a,b,....,z}. Các mảng ký tự P và T thƣờng

đƣợc gọi là các chuỗi ký tự. Ta nói rằng một chuỗi w là tiền tố (hậu tố) của một

chuỗi x, ký hiệu là w ⊂ x (w ⊃ x), nếu x = wy (x = yw), với y là một chuỗi nào

đó. Để ngắn gọn, ta kí hiệu Pk để thể hiện tiền tố k - ký tự P[1..k] của khuôn mẫu

P[1..m].

Ta nói rằng khuôn mẫu P xảy ra với khoá chuyển s trong văn bảnT (hoặc,

theo tƣơng đƣơng, nói rằng khuôn mẫu P xảy ra bắt đầu tại vị trí s + i trong văn

bản T) nếu 0 ≤ s ≤ n-m và T[s + 1..s + m] = P[1..m] (nghĩa là, nếu T[s+j] = P[j],

với 1 ≤ j ≤ m). Bài toán so khớp chuỗi là bài toán tìm tất cả các khoá chuyển hợp

lệ với nó một khuôn mẫu P đã cho xảy ra trong một văn bản T đã cho.

Ví dụ: khuôn mẫu P = abaa xuất hiện một lần trong văn bản T =

- 37 -


abcabaabcabac, tại khoá chuyển s = 3. Với bài toán này, rõ ràng ta có một cách

làm đơn giản là tìm tất cả các khoá chuyển hợp lệ dùng một vòng lặp kiểm tra

điều kiện P[1..m] = T[s+1..s+m] với n - m + 1 giá trị có thể của s.

Procedure NAIVE-STRING-MATCHER(T,P)

Begin

for s := 0 to n - m do

if P[1..m] = T[s+1..s+m] then

write(‘khuôn mẫu xảy ra với khoá chuyển’, s +1)

End;

Hình1.5. Ví dụ so khớp chuỗi

Hình trên minh họa phép toán của bộ so khớp chuỗi đơn giản với khuôn

mẫu P = aab và văn bản T = acaabc; các vạch dọc nối các vùng tƣơng ứng với

tìm thấy so khớp (đƣợc tô bóng), và một vạch zích zắc nối ký tự không so khớp

đầu tiên tìm thấy, nếu có. Một trƣờng hợp xuất hiện của khuôn mẫu đƣợc tìm

thấy, tại khoá chuyển s = 2, trong hình (c).

Đánh giá: Thủ tục NAIVE-STRING-MATCHER có độ phức tạp O((n-

m+1)m) trong trƣờng hợp xấu nhất. Nhƣ sẽ thấy, NAIVE-STRING-MATCHER

không phải là một thủ tục tối ƣu cho bài toán này. Do đó việc sử dụng Otomat so

khớp chuỗi hiệu quả hơn vì chúng xét mỗi ký tự văn bản chính xác một lần.

Có một otomat so khớp chuỗi cho mọi khuôn mẫu P: otomat này phải

đƣợc khởi tạo từ khuôn mẫu trƣớc khi dùng nó để tìm trong chuỗi văn bản. Hình

1.6 minh họa sơ đồ chuyển tiếp trạng thái của otomat so khớp chấp nhận tất cả

các chuỗi kết thúc bởi chuỗi ababaca. Trạng thái 0 là trạng thái đầu, và trạng thái

7 là trạng thái chấp nhận duy nhất. Một cạnh có hƣớng từ trạng thái i đến trạng

thái j đƣợc gắn nhãn a biểu diễn δ(i, a) = j. Các cạnh sang phải hình thành “cột

- 38 -


sống” của otomat, đƣợc vẽ đậm trong hình, tƣơng ứng với các lần so khớp thành

công giữa khuôn mẫu và các ký tự đầu vào. Các cạnh sang phải tƣơng ứng các

lần so khớp thất bại. Có vài cạnh tƣơng ứng với các lần so khớp thất bại không

đƣợc nêu; theo quy ƣớc, nếu một trạng thái i không có cạnh đi ra đƣợc gắn nhãn

a với một a ∈ ∑, thì δ(i, a) = 0. Hình (b) là hàm chuyển tiếp tƣơng ứng δ, và

chuỗi khuôn mẫu P = ababaca. Các ô tƣơng ứng với các lần so khớp thành công

giữa khuôn mẫu và các ký tự đầu vào đƣợc nêu ở dạng tô bóng. Hình (c) minh

họa phép toán của otomat trên văn bản T = abababacaba. Dƣới mỗi ký tự văn

bản T[i] đƣợc gán một trạng thái mà otomat nằm trong đó, sau khi xử lý tiền tố

Ti. Một lần xuất hiện của khuôn mẫu đƣợc tìm thấy, kết thúc tại vị trí 9.

Hình 1.6. Ví dụ otomat so khớp chuỗi

1.6.2.2. Thuật toán xây dựng Otomat so khớp chuỗi

Trƣớc tiên ta xây dựng hàm chuyển tiếp δ từ một khuôn mẫu đã cho

- 39 -


P[1..m] nhƣ sau:

Procedure COMPUTE-TRANSITION-FUNCTION(P, ∑)

Begin

m : = length(P)

For q : = 0 to m do

For mỗi ký tự a ∈ ∑ do

Begin

k : = min(m+1, q+2);

repeat k : = k – 1

until (Pk là hậu tố của Pqa);

δ(q, a) : = k

End;

End;

Trong thủ tục trên, ta xét tất cả các trạng thái q và các ký tự a; giá trị δ(q,

a) là số k lớn nhất sao cho Pk là hậu tố của Pqa. Giá trị lớn nhất của k là min (m,

q+1), sau đó giảm k cho đến khi thỏa mãn. Thời gian thực hiện của hàm trên là

O(m3|∑|), với |∑| là số lƣợng kí tự trong ∑. Sau đây là thủ tục xây dựng otomat:

Procedure FINITE-AUTOMATON-MATCHER(T, δ, m)

Begin

n : = length(T)

q : = 0;

for i : = 1 to n do

Begin

q : = δ(q, T[i]);

if q = m then writeln(‘khuôn mẫu xảy ra với khoá chuyển:’,i - m);

End; End;

Đánh giá: tổng thời gian thực hiện để tìm tất cả các lần xuất hiện của một

khuôn mẫu có chiều dài m trong một văn bản có chiều dài n trên một bảng chữ

cái ∑ là O(n + m|∑|).

- 40 -


1.7. Kết luận chƣơng

Trên đây là một số kiến thức cơ bản về so khớp chuỗi, thông qua đó ta có

thể nắm bắt đƣợc các kiến thức nền tảng về so khớp chuỗi, các hƣớng tiếp cận,

các dạng so khớp và một số thuật toán so mẫu. Đây là những kiến thức cơ sở để

tiếp tục tìm hiểu, nghiên cứu về thuật toán KMP ở chƣơng tiếp theo. Các thuật

toán chính đã đƣợc giới thiệu, trong đó có các bài toán sử dụng may rủi. Lớp bài

toán may rủi có ý nghĩa lớn trong thực tế.

- 41 -


CHƢƠNG 2. THUẬT TOÁN SO KHỚP CHUỖI

KNUTH-MORRIS-PRATT

2.1. Thuật toán KMP

2.1.1. Giới thiệu thuật toán

Thuật toán đƣợc phát minh năm 1977 bởi hai giáo sƣ của đại học

Stanford, Hoa Kỳ (một trong số ít các trƣờng đại học xếp hàng số một về khoa

học máy tính trên thế giới cùng với MIT, CMU cũng của Hoa Kỳ và Cambridge

của Anh) Donal Knuth và Vaughan Ronald Pratt, Knuth (giải Turing năm 1971)

. Thuật toán này còn có tên là KMP lấy tên viết tắt của ba ngƣời phát minh ra

nó, chữ “M” là chỉ giáo sƣ J.H.Morris, một ngƣời cũng rất nổi tiếng trong khoa

học máy tính.

Ý tƣởng chính của phƣơng pháp này nhƣ sau: trong quá trình tìm kiếm vị

trí của mẫu P trong xâu gốc T, nếu tìm thấy một vị trí sai ta chuyển sang vị trí

tìm kiếm tiếp theo và quá trình tìm kiếm sau này sẽ đƣợc tận dụng thông tin từ

quá trình tìm kiếm trƣớc để không phải xét các trƣờng hợp không cần thiết [8].

Ví dụ: tìm mẫu w = “ABCDABD” trong xâu T = “ABC ABCDAB

ABCDABCDABDE”. Ở mỗi thời điểm, thuật toán luôn đƣợc xác định bằng hai

biến kiểu nguyên, m và i, đƣợc định nghĩa lần lƣợt là vị trí tƣơng ứng trên S bắt

đầu cho một phép so sánh với W, và chỉ số trên W xác định kí tự đang đƣợc so

sánh. Khi bắt đầu, thuật toán đƣợc xác định nhƣ sau:

m: 0

S: ABC ABCDAB ABCDABCDABDE

W: ABCDABD

i: 0

Chúng ta tiến hành so sánh các kí tự của W tƣơng ứng với các kí tự của S,

di chuyển lần lƣợt sang các chữ cái tiếp theo nếu chúng giống nhau. S[0] và

W[0] đều là „A‟. Ta tăng i:

- 42 -


m: 0


W: ABCDABD

i: _1

S[1] và W[1] đều là „B‟. Ta tiếp tục tăng i:

m: 0


W: ABCDABD

i: __2

S[2] và W[2] đều là „C‟. Ta tăng i lên 3:

m: 0


W: ABCDABD

i: ___3

Nhƣng, trong bƣớc thứ tƣ, ta thấy S[3] là một khoảng trống trong khi

W[3] = 'D', không phù hợp. Thay vì tiếp tục so sánh lại ở vị trí S[1], ta nhận thấy

rằng không có kí tự 'A' xuất hiện trong khoảng từ vị trí 0 đến vị trí 3 trên xâu S

ngoài trừ vị trí 0; do đó, nhờ vào quá trình so sánh các kí tự trƣớc đó, chúng ta

thấy rằng không có khả năng tìm thấy xâu dù có so sánh lại. Vì vậy, chúng ta di

chuyển đến kí tự tiếp theo, gán m = 4 và i = 0.

m: ____4


W: ABCDABD

i: 0

Tiếp tục quá trình so sánh nhƣ trên, ta xác định đƣợc xâu chung

"ABCDAB", với W[6] (S[10]), ta lại thấy không phù hợp. Nhƣng từ kết quả của

quá trình so sánh trƣớc, ta đã duyệt qua "AB", có khả năng sẽ là khởi đầu cho

- 43 -


một đoạn xâu khớp, vì vậy ta bắt đầu so sánh từ vị trí này. Nhƣ chúng ta đã thấy

các kí tự này đã trùng khớp với nhau kí tự trong phép so khớp trƣớc, chúng ta

không cần kiểm tra lại chúng một lần nữa; ta bắt đầu với m = 8, i = 2 và tiếp tục

quá trình so khớp.

m: ________8


W: ABCDABD

i: __2

Quá trình so khớp ngay lập tức thất bại, nhƣng trong W không xuất hiện

kí tự „ „,vì vậy, ta tăng m lên 11, và gán i = 0.

m: ___________11


W: ABCDABD

i: 0

Một lần nữa, hai xâu trùng khớp đoạn kí tự "ABCDAB" nhƣng ở kí tự

tiếp theo, 'C', không trùng với 'D' trong W. Giống nhƣ trƣớc, ta gán m = 15, và

gán i = 2, và tiếp tục so sánh.

m: _______________15


W: ABCDABD

i: __2

Lần này, chúng ta đã tìm đƣợc khớp tƣơng ứngvới vị trí bắt đầu là S[15].

Bảng so khớp một phần T giúp ta xác định đƣợc vị trí tiếp theo để so khớp

khi phép so khớp trƣớc đã thất bại. Mảng T đƣợc tổ chức để nếu chúng ta có một

phép so khớp bắt đầu từ S[m] thất bại khi so sánh S[m + i] với W[i], thì vị trí

của phép so khớp tiếp theo có chỉ số là m + i - T[i] trong S (T[i] là đại lƣợng xác

định số ô cần lùi khi có một phép so khớp thất bại). Mặc dù phép so khớp tiếp

theo sẽ bắt đầu ở chỉ số m + i - T[i], giống nhƣ ví dụ ở trên, chúng ta không cần

- 44 -


so sánh các kí tự T[i] sau nó, vì vậy chúng ta chỉ cần tiếp tục so sánh từ kí tự

W[T[i]]. Ta có T[0] = -1, cho thấy rằng nếu W[0] không khớp, ta không phải lùi

lại mà tiếp tục phép so sánh mới ở kí tự tiếp theo. Sau đây là đoạn mã giả mẫu

của thuật toán tìm kiếm KMP.

algorithm kmp_search:

input:

mảng kí tự, S (đoạn văn bản)

mảng kí tự, W (xâu đang tìm)

output:

một biến kiểu nguyên (vị trí (bắt đầu từ 0) trên S mà W được tìm thấy)

define variables:

biến nguyên, m ← 0

biến nguyên, i ← 0

mảng nguyên, T

while m + i nhỏ hơn độ dài của sâu S, do:

if W[i] = S[m + i],

let i ← i + 1

if i bằng độ dài W,

return m

otherwise,

if T[i] > -1,

let i ← T[i], m ← m + i - T[i]

else

let i ← 0, m ← m + 1

return độ dài của đoạn văn bản S

Với sự xuất hiện của mảng T, phần tìm kiếm của thuật toán Knuth–

Morris–Pratt có độ phức tạp O(k), trong đó k là độ dài của xâu S. Ngoại trừ các

thủ tục nhập xuất hàm ban đầu, tất cả các phép toán đều đƣợc thực hiên trong

vòng lặp while, chúng ta sẽ tính số câu lệnh đƣợc thực hiện trong vòng lặp; để

làm đƣợc việc này ta cần phải tìm hiểu về bản chất của mảng T. Theo định

nghĩa, mảng đƣợc tạo để: nếu một phép so khớp bắt đầu ở vị trí S[m] thất bại khi

- 45 -


so sánh S[m + i] với W[i], thì phép so khớp có thể thành công tiếp theo sẽ bắt

đầu ở vị trí S[m + (i - T[i])]. Cụ thể hơn, phép so khớp tiếp theo sẽ bắt đầu tại vị

trí có chỉ số cao hơn m, vì vậy T[i] < i.

Từ điều này, ta thấy rằng vòng lặp có thế thức hiện 2k lần. Với mỗi lần

lặp, nó thực hiện một trong hai nhánh của vòng lặp. Nhánh thứ nhất tăng i và

không thay đổi m, vì vậy chỉ số m + i của kí tự đang so sánh trên S tăng lên.

Nhánh thứ hai cộng thêm i - T[i] vào m, và nhƣ chúng ta đã biết, đây luôn là số

dƣơng. Vì vậy, vị trí m, vị trí bắt đầu của một phép so khớp tiềm năng tăng lên.

Vòng lặp dừng nếu m + i = k; vì vậy mỗi nhánh của vòng lặp có thể đƣợc sử

dụng trong tối đa k lần, do chúng lần lƣợt tăng giá trị của m + i hoặc m, và m ≤

m + i: nếu m = k, thì m + i ≥ k, vì vậy: do các phép toán chủ yếu tăng theo đơn

vị, chúng ta đã có m + i = k vào một thời điểm nào đó trƣớc, và vì vậy thuật toán

dừng. Do đó vòng lặp chủ yếu thực hiện 2k lần, độ phức tạp tính toán của thuật

toán tìm kiếm chỉ là O(k).

2.1.2. Bảng so sánh một phần

Mục đích của bảng là cho phép thuật toán so sánh mỗi kí tự của S không

quá một lần. Sự quan sát chìa khóa về bản chất của phƣơng pháp tìm kiếm tuyến

tính cho phép điều này xảy ra là trong quá trình so sánh các đoạn của chuỗi

chính với đoạn mở đầu của mẫu, chúng ta biết chính xác đƣợc những vị trí mà

đoạn mẫu có thế xuất hiện trƣớc vị trí hiện tại. Nói cách khác, chúng ta "tự tìm

kiếm" đoạn mẫu trƣớc và đƣa ra một danh sách các vị trí trƣớc đó mà bỏ qua các

kí tự vô vọng mà vẫn không mất đi các đoạn tiềm năng [8].

Với mỗi vị trí trên W, độ dài của đoạn dài nhất giống với "đoạn bắt đầu"

trên W tính đến (không bao gồm) vị trí đó, đây là khoảng cách chúng ra có thể

lùi lại để tiếp tục so khớp. Do vậy T[i] là giá trị của độ dài đoạn dài nhất kết thúc

bởi phần tử W[i - 1]. Ta sử dụng quy ƣớc rằng một chuỗi rỗng có độ dài là 0.

Với trƣờng hợp không trùng với mẫu ngay ở giá trị đầu tiên (không có khả năng

lùi lại), ta gán T[0] = -1.

- 46 -


Ví dụ: xét xâu W = "ABCDABD". Ta sẽ thấy thuật toán xây dựng bảng

có nhiều nét tƣơng đồng với thuật toán tìm kiếm chính. Ta gán T[0] = -1. Để

tính T[1], ta cần tìm ra một xâu con "A" đồng thời cũng là xâu con bắt đầu của

W. Vì vậy ta gán T[1] = 0. Tƣơng tự, T[2] = 0 và T[3] = 0.

Xét kí tự W[4] = 'A', kí tự này trùng với kí từ bắt đầu xâu W[0]. Nhƣng

do T[i] là độ dài xâu dài nhất trùng với xâu con bắt đầu trong W tính đến W[i –

1] nên T[4] = 0 và T[5] = 1. Tƣơng tự, kí tự W[5] trùng với kí tự W[1] nên T[6]

= 2. Vì vậy ta có bảng sau:

Bảng 2.1. Bảng so sánh một phần

i 0 1 2 3 4 5 6

W[i] A B C D A B D

T[i] -1 0 0 0 0 1 2

Một ví dụ khác phức tạp hơn, nhƣ trong bảng.

Bảng 2.2. Thí dụ khác

i 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3

W[i] P A R T I C I P A T E I N P A R A C H U T E

T[i] -1 0 0 0 0 0 0 0 1 2 0 0 0 0 0 0 1 2 3 0 0 0 0 0

Thuật toán tạo bảng:

algorithm kmp_table:

input:

mảng kí tự, W

mảng số nguyên, T

output:

mảng T

define variables:

biến kiểu nguyên, pos ← 2

biến kiểu nguyên, cnd ← 0

let T[0] ← -1, T[1] ← 0

while pos nhỏ hơn độ dài của W, ‘’’do’’’:

(trường hợp một: tiếp tục dãy con)

- 47 -


if W[pos - 1] = W[cnd],

let T[pos] ← cnd + 1, pos ← pos + 1, cnd ← cnd + 1

(trường hợp hai: không thỏa mãn, nhưng ta có thể quay ngược trở lại)

otherwise, if cnd > 0, let cnd ← T[cnd]

(trường hợp ba: hết phần tử. Chú ý rằng cnd = 0)

otherwise, let T[pos] ← 0, pos ← pos + 1

Độ phức tạp của thuật toán tạo bảng là O(n), với n là độ dài của W. Ngoại

trừ một số sắp xếp ban đầu, toàn bộ công việc đƣợc thực hiên trong vòng lặp

while, độ phức tạp của toàn bộ vòng lặp là O(n), với việc cùng lúc sử lý giá trị

của pos và pos - cnd. Trong trƣờng hợp thứ nhất, pos - cnd không thay đổi, khi

cả pos và cnd cùng tăng lên một đơn vị. Ở trƣờng hợp hai, cnd đƣợc thay thế bởi

T[cnd], nhƣ chúng ta đã biết ở trên, luôn luôn nhỏ hơn cnd, do đó tăng giá trị

của pos - cnd. Trong trƣờng hợp thứ ba, pos tăng và cnd thì không, nên cả giá trị

của pos và pos - cnd đều tăng. Mà pos ≥ pos - cnd, điều này có nghĩa là ở mỗi

bƣớc hoặc pos hoặc chặn dƣới pos đều tăng; mà thuật toán kết thúc khi pos = n,

nên nó phải kết thúc tối đa sau 2n vòng lặp, do pos - cnd bắt đầu với giá trị 1. Vì

vậy độ phức tạp của thuật toán xây dựng bảng là O(n).

2.1.3. Độ phức tạp của thuật toán KMP

Do độ phức tạp của hai phần trong thuật toán lần lƣợt là O(k) và O(n), nên

độ phức tạp của cả thuật toán là O(n + k).

Nhƣ đã thấy trong ví dụ ở trên, thuật toán mạnh hơn các thuật toán so

khớp chuỗi kém hơn vì nó có thể bỏ qua các kí tự đã duyệt. Ít ô phải quay trở lại

hơn, thuật toán sẽ nhanh hơn, và đƣợc thể hiện trong bảng T bởi sự hiện diện

của các số không. Một từ nhƣ "ABCDEFG" sẽ làm tốt với thuật toán này vì nó

không có sự lặp lại của những chữ bắt đầu, vì vậy mảng đơn giản chỉ toàn số

không với -1 ở đầu. Ngƣợc lại, với từ W = "AAAAAAA" nó hoạt động tồi tệ,

bởi vì bảng sẽ là:

Bảng 2.3. Trƣờng hợp mẫu xấu nhất với thuật toán KMP

- 48 -


i 0 1 2 3 4 5 6

W[i] A A A A A A A

T[i] -1 0 1 2 3 4 5

Đây là mẫu xấu nhất cho mảng T, và nó có thể dùng để so sánh với đoạn

nhƣ S = "AAAAAABAAAAAABAAAAAAA", trong trƣờng hợp này thuật

toán sẽ cố gắng ghép tất cả các chữ 'A' với 'B' trƣớc khi dừng lại; kết quả là số

lƣợng tối đa câu lệnh đƣợc sử dụng, tiến tới trên hai lần số kí tự của xâu S khi số

lần lặp của "AAAAAAB" tăng. Mặc dù quá trình xây dựng bảng rất nhanh so

với chữ này (nhƣng vô tác dụng), quá trình này chạy có một lần với chữ W,

trong khi quá trình tìm kiếm chạy rất nhiều lần. Nếu với mỗi lần, từ W đƣợc

dùng để tìm trên xâu nhƣ xâu S, độ phức tạp tổng thể sẽ rất lớn. Bằng cách so

sách, sự kết hợp này là trƣờng hợp tốt nhất với thuật toán so khớp chuỗi Boyer-

Moore.

2.2. Thuật toán KMP mờ

2.2.1. Otomat so mẫu

Do ý nghĩa của độ mờ là độ dài khúc đầu dài nhất của mẫu P đã xuất hiện

trên S nên otomat sẽ có tập trạng thái là tập số nguyên {0, 1,..., m}. Hoạt động

của otomat mờ so mẫu sẽ nhƣ sau [4]:

Khởi đầu con trỏ trên S là j = 0. Tại đó chƣa xuất hiện khúc đầu nào

của mẫu nên trạng thái khởi đầu của otomat là q0 = 0.

Duyệt S, mỗi lần một kí tự, bắt đầu từ S1. Giả sử trạng thái của

otomat là q thì khi đọc đƣợc kí tự Sj, trạng thái mới (ứng với vị trí j

trên S) sẽ là q‟ = (q,Sj) ( là hàm chuyển của otomat).

Tại vị trí j trên S, nếu trạng thái của otomat là q, có nghĩa khúc đầu

dài nhất xuất hiện trên S của P có độ dài q. Nếu q = m, báo hiệu

một lần xuất hiện mẫu, bắt đầu từ vị trí j -m+1.

Mô hình otomat mờ cần đƣợc xây dựng một cách thích hợp để đáp ứng

- 49 -


đƣợc yêu cầu sánh mẫu nhƣ trên.

Otomat mờ so mẫu là bộ A(P) = (A, Q, q0, , F) trong đó:

Bảng chữ vào A = AP {#}

Tập trạng thái Q = {0,1,...,m}

Trạng thái khởi đầu q0 = 0

Trạng thái kết thúc F = m.

Hàm chuyển : Q A Q (q,a) = TFuzz (q,a).

2.2.2. Thuật toán

Khi cài đặt thuật toán cần lƣu ý lựa chọn cấu trúc dữ liệu phù hợp để có

thể truy nhập nhanh chóng trong bảng TFuzz.

Gọi A[0..k] là mảng lƣu giữ bảng chữ A của otomat, trong đó k là số kí tự

phân biệt trong mẫu P. Màng đƣợc sắp theo chiều tăng của các kí tự và A[k] =

„#‟. Để thuận tiện khi truy nhập đến các chữ cái trong A, có thể sử dụng mảng

index xác định vị trí của chữ trong bảng [4]. Giá trị index [c] = i, nếu c = A [i];

và =k, nếu c {A[0], A[1], ...A[k-1]}. TFuzz là mảng [0..m, 0..k], trong đó

TFuzz [i, j] là độ mờ mới khi độ mờ i gặp kí tự x có index [ ] = j.

Khi đó chi tiết thuật toán tạo lập bảng TFuzz và tìm kiếm dựa vào bảng

TFuzz sẽ nhƣ sau:

2.2.2.1 Thuật toán tạo lập TFuzz

procedure initTFuzz()

var i, j, t: integer;

begin

for i: = 0 to m do

TFuzz [i,m]:=0;

for j: = 0 to k do TFuzz [0, j] := 0;

TFuzz [0, index [P1]]:=1;

- 50 -


for i: = 0 to m do

for t: = 0 to k-1 do

begin

if i = m then j:= next [i+1]

elsse j:=i+1;

while (j > 0) and (Pj A([t]) do j:=next [j];

TFuzz [i, index [A[t]]:= j;

end;

end;

- 51 -


2.2.2.2. Thuật toán tìm kiếm mẫu dựa vào bảng TFuzz

procedure FPM();

var j, counter: integer; fuz: array [1..50] of integer; {* độ mờ*}

begin

j :=1; counter :=0; fuz[0] = 0;

while (còn đọc được Sj) do

begin

fuz [j] = TFuzz [fuz[j-1], index [Sj]];

if fuz [j] = m then

begin

counter :=counter+1;

Ghi nhận vị trí j-m+1;

end;

end; {while}

Ghi nhận counter;

if counter = 0 then Ghi nhận vị trí 0;

end;

Ví dụ Với mẫu P = aababaab, A = {a, b, #}, AP = {a,b}.

Ta có bảng next nhƣ sau:

Bảng 2.4. Bảng next

i 1 2 3 4 5 6 7 8 9

next[i] 0 0 2 0 2 0 0 2 4

Bảng TFuzz đƣợc tính toán dựa trên mảng next cho kết quả nhƣ sau:

Bảng 2.5. Bảng TFuzz

A

Q a b #

0 1 0 0

1 2 0 0

2 0 3 0

3 4 0 0

4 2 5 0

5 6 0 0

6 7 0 0

- 52 -


7 2 8 0

8 4 0 0

Quá trình so mẫu trên dòng dữ liệu S = aabaababaababaababaab sẽ nhƣ sau:

j 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

S a a b a a b a b a a b a b a a b a b a a b

j 1 2 3 4 2 3 4 5 6 7 8 4 5 6 7 8 4 5 6 7 8

ghi nhận ghi nhận ghi nhận

11-8+1=4 168+1=9 21-8+1=14

Bảng 2.6. Minh họa thí dụ

2.2.3. So sánh KMP và thuật toán KMP mờ

Giả sử đã xuất hiện khúc đầu độ dài i-1 của P trên S, tính tới vị trí j, có

nghĩa đã có P(i - 1) = sufi - 1(S(j - 1)) hay độ mờ tại vị trí j - 1 là j-i = i - 1. Xét

ký tự Sj, có thể xảy ra hai khả năng:

Trƣờng hợp 1: Sj = Pi (hay độ mờ tại vị trí j là j = i). Tăng i, j lên

1. Với trƣờng hợp này tốc độ thao tác của thuật toán KMP nhƣ

trong tiếp cận mờ.

Trƣờng hợp 2: Sj Pi (hay độ mờ tại vị trí j là j i)

Hình 2.1. Dịch chuyển con trỏ trên mẫu

Trong KMP, con trỏ j trên S giữ nguyên, chỉ dịch chuyển con trỏ trên mẫu

(dùng lệnh i:= next[i]. Vì vậy phải mất thời gian dịch chuyển theo bảng next,

thậm chí nhiều lần. Ví dụ nhƣ:

?

next [i]

P

P

S

i

i j-i = i - 1

- 53 -


Với P = aababaab, sử dụng bảng next (trong ví dụ mục 2.3) để tìm sự xuất

hiện của mẫu trong dòng ký tự S nhƣ sau:

S = a a c ... j = 3

P = a a b a b a a b i = 3

dịch lần thứ nhất a a b a b a a b i = next[i] = 2

dịch lần thứ 2 a a b a b a a b i = next[i] = 0

Ta thấy có 2 lần dùng i:= next[i] và 2 lần so sánh Sj và Pi (i khác nhau).

Nói chung có thể xảy ra nhiều lần dùng next trong khi con trỏ trên S vẫn giữ

nguyên. Điều này làm chậm đáng kể so với tiếp cận mờ: mỗi lần nhận một ký tự

Sj là một lần điều chỉnh giá trị mờ theo otomat: j = TFuzz ( j-1, Sj). Lệnh này

thực hiện rất nhanh nếu TFuzz đƣợc biểu diễn dƣới dạng một mảng và đƣợc tính

toán cẩn thận trƣớc theo thông tin trên mẫu P.

Kết quả sau so sánh tốc độ thực hiện việc tìm sự xuất hiện mẫu P trong

tệp dữ liệu lớn S theo hai thuật toán KMP và tiếp cận mờ trên máy PC IBM tốc

độ 233MHz.

Bảng 2.7. Kết quả tìm sự xuất hiện mẫu P trong tệp S theo KMP và tiếp cận mờ

Mẫu P Kích thƣớc tệp S TKMP TFuzzy-KMP

1) aababcab 1400 KB 17% s 11% s

2) MDSVF6V 140.000 KB 35 s 30 s

3) bacabccaa 1200 KB 16% s 10% s

4) S068FAB50 140.000 KB 37 s 30 s

2.3. Thuật toán KMP - BM mờ

2.3.1. Ý tƣởng của thuật toán

Trong thuật toán Boyer - Moore (BM), các ký tự trên mẫu P đƣợc duyệt

từ phải sang trái, bắt đầu từ Pm. Tại thời điểm gặp ký tự không trùng khớp,

chẳng hạn Pi = a còn Sj = b, khi đó sẽ quyết định dịch con trỏ trên mẫu. Phép

dịch chuyển ứng với mỗi ký tự trên P, nếu sự không trùng khớp xảy ra ở đó,

- 54 -


đƣợc xác định trong bƣớc tiền xử lý mẫu P. Trong thuật toán “ký tự không

khớp” này của BM, có một trƣờng hợp cho phép dịch chuyển tốt nhất (xa nhất)

là khi ký tự b không xuất hiện trong mẫu P. Từ chi tiết này, kết hợp với kiểu

sánh mẫu nhƣ trong KMP, ta sẽ có một “thuật toán theo tiếp cận mờ tổng quát

kiểu KMP và BM”, trong đó độ mờ vẫn đƣợc tính toán dựa trên hàm TFuzz,

đồng thời sẽ có những bƣớc nhảy dài trên xâu đích, đem lại hiệu quả tìm kiếm

cao [4].

Ý tƣởng của thuật toán này là: gọi ptr là con trỏ trên xâu đích S (khởi đầu

ptr = 0 và độ mờ tại đó bằng 0 báo hiệu chƣa tìm thấy mẫu). Mỗi lần xét một

khối w gồm m + 1 ký tự liên tục trên S, bắt đầu từ vị trí ptr, ta gọi khối này là

“khối ký tự quan sát” và ký hiệu wi là ký tự thứ i trong w (với w1 = Sptr). Dựa

trên bảng TFuzz, tính độ mờ xuất hiện mẫu khi gặp ký tự w1 (hay chính là Sptr),

ký hiệu độ mờ này là n1, đồng thời xác định bƣớc nhảy tiếp theo để từ đó sẽ xét

khối ký tự w mới, ký hiệu bƣớc nhảy là n2. Nếu n1 là độ mờ tại Sptr thì có nghĩa

sufn1(S(ptr)) = P(n1). Xảy ra các khả năng sau:

Nếu n1 = m, chứng tỏ đã xuất hiện mẫu bắt đầu từ vị trí ptr - m + 1

trên S. Để không bỏ sót sự xuất hiện lồng nhau của mẫu, đặt n2 = 1.

Nếu n1 lớn hơn độ mờ tại vị trí đƣợc xét trƣớc vị trí ptr, có nghĩa

đang có hy vọng tìm thấy mẫu nên n2 = 1.

Trong các trƣờng hợp còn lại của n1, chỉ mới xuất hiện khúc đầu

P(n1) khớp với khúc cuối độ dài n1 của S(ptr). Nếu việc khớp mẫu

thành công với khối ký tự quan sát w, thì ký tự Pm sẽ khớp với ký

tự Sptr+m-n1 (hay w1+m-n1). Do đó, nếu Sptr+m-n1 không phải là một ký

tự xuất hiện trong P thì có thể thực hiện bƣớc nhảy xa để đọc w mới

bắt đầu từ vị trí ptr+m-n1+1 trên S mà vẫn đảm bảo không bỏ sót sự

xuất hiện nào của mẫu.

ptr

P(n1) ptr+m-n1

1+m-n1 m+1

S

- 55 -


Hình 2.2. Ý tƣởng chung của thuật toán KMP-BM mờ

2.4.2. Otomat mờ so mẫu

2.3.2.1. Giới thiệu

Cho P là xâu mẫu độ dài m trên bảng chữ A. Ap là bảng các ký tự xuất

hiện trong P. Otomat mờ so mẫu là A(P) = (Ak, Q, q0, F, ), trong đó:

Ak là bảng chữ vào, mỗi chữ là một xâu ký tự độ dài k trên A,

k=m+1

Q là tập hữu hạn các trạng thái, Q = {q=(n1,n2)| n1, n2 N, 0 n1

m, 1 n2 k}; n1 gọi là độ mờ tại vị trí đang xét; n2 gọi là bƣớc

nhảy tiếp theo vị trí đang xét

q0 là trạng thái khởi đầu, q0 = (0,1)

F là trạng thái kết thúc, F = (m,1)

Hàm chuyển : Q × Ak Qs; (q, w) q‟ = (q, w)

Với q = (n1, n2) thì q‟ = (n1‟, n2‟) đƣợc xác định nhƣ sau:

1. Nếu n2 > 1 thì đặt n1 = 0

2. Tính n1‟ = TFuzz (n1, w1)

3. Nếu n1‟ = m hoặc n1‟ > n1 thì n2‟ = 1, ngƣợc lại (n1‟ < m và n1‟

n1) thì xét: Nếu w1+m-n1‟ Ap thì n2‟ = 1, ngƣợc lại n2‟=1+m-n1‟

2.3.2.2. Hoạt động của otomat mờ so mẫu

Cho mẫu P độ dài m và xâu đích S độ dài n trên bảng chữ A. A(P) là

otomat đƣợc xác định theo định nghĩa trên. Ta sẽ dùng otomat A(P) để đoán

nhận tất cả các vị trí xuất hiện mẫu P trong xâu S và tổng số lần xuất hiện mẫu.

- 56 -


Thuật toán cơ bản dựa trên otomat đƣợc mô tả nhƣ sau:

Ta dùng các ký hiệu:

j là con trỏ quan sát trên S

q.n1, q.n2 là hai thành phần của trạng thái q

w là khối ký tự quan sát bắt đầu từ vị trí j trên xâu đích S, giả sử đã

bổ sung thêm m ký tự # vào cuối S.

qold là trạng thái của otomat tại vị trí trƣớc khi đọc w

q là trạng thái otomat sau khi tác động w, q = (qold, w)

Counter là biến đếm số lần xuất hiện mẫu.

Bước 1: Khởi tạo

j: = 0; counter := 0; qold.n1 :=0; qold.n2 :=1;

Bước 2: While j n do

j: = j + qold.n2

Đọc khối ký tự quan sát w; {w1 Sj}

{Tính q = (qold, w)}

if qold.n2 > 1 then qold.n1:= 0; endif;

q.n1: = TFuzz (qold.n1, w1);

q.n2: = 1;

if q.n1= m then

Ghi nhận vị trí xuất hiện mẫu là j - m + 1;

Counter: = counter + 1;

else if q.n1 < m and q.n1 < qold.n1 then

if w1+m-q.n1 Ap then q.n2: = 1+m-q.n1; endif;

endif;

endif;

qold := q;

end while;

2.3.3. Thuật toán tìm kiếm

procedure GFSearching (); {tìm kiếm mẫu}

- 57 -


var apr: array [1..N] of integer;

counter, j, n1, n2, n1’, n2’: integer;

begin

j:= 0; n1:= 0; n2 := 1;

while j <= n do

begin j := j + n2;

if n2 > 1 then n1:= 0;

n1’ := TFuzz [n1, index [S[j]]];

n2’: = 1;

if n1’ = m then

begin counter := counter + 1;

apr[counter]:= j - m + 1;

end

else if n1’ < m and n1’ <= n1 then

begin if j + m - n1’ > n then return;

if index [S[j + m - n1’]] = k then n2’ : = 1 + m - n1’;

end;

n1:=n1’; n2: = n2’;

end;

end;

2.4. Kết luận chƣơng

Chƣơng này tập trung trình bày về thuật toán so khớp chuỗi KMP, thuật

toán KMP mờ, thuật toán KMP-BM mờ. Kết quả nghiên cứu của chƣơng này là

cơ sở để giải quyết bài toán tìm kiếm thông tin trên văn bản ở chƣơng sau.

- 58 -


CHƢƠNG 3. ỨNG DỤNG THUẬT TOÁN KMP TRONG TÌM

KIẾM THÔNG TIN TRÊN VĂN BẢN

3.1. Bài toán tìm kiếm mẫu trên văn bản

3.1.1. Tìm kiếm mẫu

Kiểu văn bản là dạng biểu diễn dữ liệu hay gặp nhất trong các hệ thống

thông tin. Tìm kiếm văn bản là vấn đề chủ yếu thuộc lĩnh vực quản lý văn bản.

Một dạng cơ bản và tổng quát hơn là tìm kiếm chuỗi hay đối sánh chuỗi. Khái

niệm “chuỗi” ở đây khá rộng, có thể là chuỗi văn bản gồm một dãy các chữ, số

và ký tự đặc biệt, có thể là chuỗi nhị phân hay chuỗi gen,… Tìm kiếm chuỗi là

bài toán tìm ra một mẫu với một số đặc tính nào đó trong chuỗi các ký hiệu cho

trƣớc, vì thế bài toán này còn đƣợc gọi là so xâu mẫu hay có thể gọi ngắn gọn là

so mẫu. Dạng đơn giản nhất là tìm sự xuất hiện một xâu cho trƣớc trong một

chuỗi (còn gọi là xâu đích).

Thời gian gần đây, vấn đề đối sánh chuỗi càng trở nên quan trọng và đƣợc

quan tâm nhiều do sự tăng trƣởng nhanh chóng của các hệ thống trích rút thông

tin và các hệ thống sinh- tin học. Một lý do nữa, bởi con ngƣời ngày nay không

chỉ đối mặt với một lƣợng thông tin khổng lồ mà còn đòi hỏi những yêu cầu tìm

kiếm ngày càng phức tạp. Các mẫu đƣa vào không chỉ đơn thuần là một xâu ký

tự mà còn có thể chứa các ký tự thay thế, các khoảng trống và các biểu thức

chính. Sự “tìm thấy” không đơn giản là xuất hiện chính xác mẫu mà còn cho

phép có “một ít sai khác” giữa mẫu và xuất hiện của nó trong văn bản. Từ đó,

bên cạnh vấn đề kinh điển là tìm kiếm chính xác, nảy sinh một hƣớng nghiên

cứu hết sức thú vị đó là tìm kiếm xấp xỉ.

Có thể phân các loại thuật toán so mẫu theo 2 hƣớng. Thứ nhất là các

thuật toán trực tuyến, trong đó chỉ mẫu đƣợc tiền xử lý (thƣờng sử dụng otomat

hoặc dựa trên các đặc tính kết hợp trên xâu), còn văn bản thì không. Thứ hai là

giải pháp tiền xử lý văn bản theo cách xây dựng một cấu trúc dữ liệu trên văn

- 59 -


bản (lập chỉ mục). Nhiều ứng dụng cần sử dụng giải pháp này mặc dù đã có

những thuật toán trực tuyến nhanh bởi chúng cần phải điều khiển một lƣợng văn

bản quá lớn nên không có thuật toán trực tuyến nào có thể thực hiện một cách

hiệu quả. Tìm kiếm trên chỉ mục thực ra cũng dựa trên tìm kiếm on-line.

Để giảm sự dƣ thừa trong lƣu trữ và truyền dữ liệu, một giải pháp đƣợc sử

dụng là nén dữ liệu. Quá trình nén làm cho các tệp chiếm ít không gian lƣu trữ

hơn, giảm đƣợc thời gian và chi phí truyền thông nhƣng lại làm mất đi phần lớn

cấu trúc của dữ liệu, dẫn đến khó khăn trong việc tìm kiếm và trích rút thông tin.

Cách đơn giản nhất song rất tốn thời gian (và khó khả thi với những văn bản quá

lớn) là giải nén toàn bộ rồi tiến hành tìm kiếm bằng một thuật toán so mẫu kinh

điển. Hiện nay, đã có nhiều giải pháp tốt hơn theo hai hƣớng chính là: so mẫu

nén và so mẫu trên miền nén. So mẫu nén thực hiện nén mẫu trƣớc rồi đem đi

tìm kiếm trên văn bản nén, còn so mẫu trên miền nén sử dụng giải pháp nén

từng phần của văn bản. Nén dữ liệu text thực chất là một quá trình mã hoá,

chuyển các thông báo nguồn (trong bảng chữ nguồn A) thành các bản mã (trong

bản chữ mã B) và ngƣợc lại là quá trình giải mã. Vì vậy thuật toán tìm kiếm trên

văn bản nén có thể áp dụng đối với văn bản mã hoá dạng khối ký tự. Tuy nhiên,

do yêu cầu bảo mật, đối với những văn bản mã hoá, cần có những giải thuật tìm

kiếm đảm bảo không bị rò rỉ thông tin ngay trong quá trình tìm kiếm.

3.1.2. Tìm kiếm thông tin

3.1.2.1 Giới thiệu

Mục đích của tìm kiếm là trả lại cho ngƣời dùng một tập các thông tin

thỏa mãn nhu cầu của họ. Ta định nghĩa rằng thông tin cần thiết là câu truy vấn

và các thông tin đƣợc chọn là tài liệu. Mỗi cách tiếp cận trong tìm kiếm thông

tin bao gồm 2 thành phần chính: một là các kỹ thuật để biểu diễn thông tin (câu

truy vấn, tài liệu) và hai là phƣơng pháp so sánh các cách biểu diễn này. Mục

đích là để thực hiện tự động qui trình kiểm tra các tài liệu bằng cách tính toán độ

tƣơng quan giữa các câu truy vấn và tài liệu. Qui trình tự động này thành công

- 60 -


khi nó trả về các kết quả giống với các kết quả đƣợc con ngƣời tạo ra khi so

sánh câu truy vấn với các tài liệu.

Hình 3.1. Mô hình biểu diễn và so sánh thông tin

Gọi miền xác định của hàm biểu diễn câu truy vấn q là Q, tập hợp các câu

truy vấn có thể có; và miền giá trị của nó là R, không gian thống nhất biểu diễn

thông tin. Gọi miền xác định của hàm biểu diễn tài liệu d là D, tập hợp các tài

liệu; và miền giá trị của nó là R. Miền xác định của hàm so sánh c là R × R và

miền giá trị của nó là [0,1], tập các số thực từ 0 đến 1. Trong một hệ thống tìm

kiếm lý tƣởng:

c(q(query), d(doc)) = j(query, doc) , ∀query ∈ Q, ∀doc ∈ D

Với j: Q × D [0,1] biểu diễn việc xử lý của ngƣời dùng về mối quan

hệ của thông tin trên câu truy vấn và thông tin trong tài liệu.

Có nhiều cách đo lƣờng khác nhau cho việc đánh giá mức độ xử lý trả về

kết quả của một hệ thống tìm kiếm thông tin. Các cách đo lƣờng đều đòi hỏi một

tập tài liệu và một câu truy vấn trên tập tài liệu đó, giả sử rằng mỗi tài liệu có thể

liên quan hoặc không liên quan đến câu truy vấn.

Độ chính xác (Precision): đƣợc đo bởi tỉ lệ của tài liệu trả về chính xác

trên tổng các tài liệu nhận đƣợc:

- 61 -


Độ bao phủ (Recall): đƣợc đo bởi tỉ lệ tài liệu trả về chính xác trên tổng

các tài liệu có liên quan:

Kết quả sai (Fall-out): đƣợc đo bởi tỉ lệ các tài liệu không có liên quan tả

về trên tổng các tài liệu không liên quan

3.1.2.2 Các mô hình tìm kiếm thông tin thường sử dụng

Mô hình so khớp: là một mô hình mà chúng ta có thể xem mỗi câu truy

vấn là một biểu thức logic các mục từ, trong đó gồm các mục từ kết hợp với các

toán tử logic (AND, OR, và NOT). Mô hình sẽ xem mỗi tài liệu là một tập hợp

các mục từ. Mỗi mục từ sẽ chứa một danh sách các tài liệu có chứa nó, danh

sách này gọi là posting, việc so khớp sẽ duyệt qua danh sách posting để kiểm tra

các tài liệu có chứa mục từ hay không.

Phương pháp tính điểm: Mô hình so khớp chỉ trả về giá trị chân lý là có

hoặc không có trong tài liệu tìm kiếm, kết quả trả về không có thứ hạng. Điều

này đã dẫn đến kết quả tìm kiếm không đƣợc nhƣ mong muốn của ngƣời dùng.

Để cải tiến mô hình này, ngƣời ta áp dụng cách tính điểm cho kết quả trả về, dựa

trên trọng số của mục từ trên tài liệu.

Tần suất xuất hiện của mục từ t trên tài liệu d đƣợc ký hiệu là tft,d. Tần

suất nghịch đảo của tài liệu d trên tập N tài liệu ký hiệu là idft = log(N / dft), khi

đó trọng số mục từ t trên tài liệu d sẽ là tf-idf = tft,d x idft, điểm số của tài liệu d

sẽ là tổng điểm các mục từ trong câu truy vấn có mặt trong d:

Ví dụ với 1000 tài liệu có 100 tài liệu chứa mục từ “tin” và 150 tài liệu

chứa mục từ “học”, giả sử tài liệu thứ nhất d có 3 lần xuất hiện mục từ “tin” và 4

- 62 -


lần xuất hiện mục từ “học”, khi đó điểm số của câu truy vấn q=”tin học” trên tài

liệu d sẽ là:

Score(q,d) = tftin,d - idftin + tfhọc,d - idfhọc = tftin,d × log (N/dftin) + tfhọc,d × log(N/dfhọc)

= 3 × log (1000/100) + 4 × log (1000/150) ~ 6.23

Mô hình không gian vec-tơ: Mô hình so khớp và cả phƣơng pháp tính

điểm số ở trên chƣa xét vai trò của các mục từ trong câu truy vấn. Ví dụ hai tài

liệu chứa câu “Mary is quicker than John” và “John is quicker than Mary”, số

lƣợng các mục từ nhƣ nhau nhƣng vai trò khác nhau hoàn toàn. Để giải quyết

vấn đề này ngƣời ta đƣa ra mô hình không gian vec-tơ, mô hình này sẽ biểu diễn

tài liệu d nhƣ một vec-tơ tần suất các mục từ V(d) .Với hai tài liệu trên thì tuy có

các mục từ giống nhau, nhƣng biểu diễn vec-tơ của chúng thì lại khác nhau, khi

đó chúng ta có thể tính mức tƣơng quan giữa hai tài liệu:

Đối với truy vấn q chúng ta cũng xem đây là một vec-tơ V(q) biểu diễn

tần suất các mục từ truy vấn. Mức độ tƣơng quan giữa hai vector đƣợc tính theo

hàm cosin của góc giữa chúng:

Hình 3.2. Mô hình không gian vec tơ

Ví dụ, với truy vấn best car insurance trên tập dữ liệu với N=1.000.000 tài

liệu với tần số xuất hiện của 4 mục từ auto, best, car, insurance lần lƣợt là 5.000,

- 63 -


50.000, 10.000, 1.000. Chúng ta có bảng tính điểm số sau:

- 64 -


Bảng 3.1. Tính điểm số

Nhƣ vậy, điểm số Score (q,d) = 0 + 0 + 0.82 + 2.46 = 3.28

3.2. Mã nguồn mở Lucene

3.2.1. Giới thiệu

Năm 1998, Doug Cutting – từng là nhân viên của Excite, Yahoo, và đang

làm việc tại Apache Software Foundation - đã bắt đầu tiến hành xây dựng thƣ

viện tìm kiếm thông tin mã nguồn mở Lucene với mục tiêu phát triển nó thành

một thƣ viện tìm kiếm tài liệu hoàn chỉnh, cho phép các nhà phát triển ứng dụng

dễ dàng tích hợp chức năng tìm kiếm vào hệ thống của mình [10].

Lucene là một thƣ viện tìm kiếm thông tin có khả năng xử lý và khả năng

mở rộng ở mức cao, cho phép chúng ta có thể tích hợp vào các ứng dụng.

Lucene là một dự án mã nguồn mở và nguyên thuỷ đƣợc phát triển bằng ngôn

ngữ Java, ngày nay Lucene đƣợc phát triển bằng nhiều ngôn ngữ khác nhau nhƣ

Delphi, Perl, C#, C++, Python, Ruby và PHP…

Thƣ viện này cung cấp các hàm cơ bản hỗ trợ cho việc đánh chỉ mục và

tìm kiếm. Để có thể sử dụng Lucene, cần phải có sẵn dữ liệu. Dữ liệu có thể là

tập hợp các tập tin dạng PDF, Word hay là các trang web HTML; hoặc là dữ liệu

lƣu trong các hệ quản trị CSDL nhƣ MS SQL Server hay MySQL. Dùng

Lucene, có thể tiến hành đánh chỉ mục trên dữ liệu hiện có để sau này có thể

thực hiện thao tác tìm kiếm toàn văn trên dữ liệu đó.

- 65 -


Hình 3.3. Mô hình đánh chỉ mục của Lucene

Thành phần Tạo chỉ mục: bao gồm các phần chức năng xử lý tạo chỉ mục,

từ văn bản đầu vào để cho ra kết quả là một tập chỉ mục. Lucene chỉ hỗ trợ trên

văn bản sau khi đƣợc tách nội dung ở dạng ký tự thuần, nó cho phép lập chỉ mục

trên từng trƣờng thông tin của văn bản và cho phép thiết lập hệ số cho từng

trƣờng thông tin để nâng cao vai trò lúc tìm kiếm.

Directory: cho phép định nghĩa vùng nhớ, xác định nơi lƣu trữ trên

bộ nhớ ngoài và bộ nhớ trên RAM trong quá trình tạo chỉ mục.

Document và Field: định nghĩa tài liệu và các trƣờng thông tin của

tài liệu sử dụng cho lập chỉ mục, nó cũng sử dụng cho việc lấy kết

quả trả về cho thành phần Tìm kiếm.

Analyzer: thực hiện chức năng xử lý và tách văn bản để lấy nội

dung, chuẩn hóa, loại bỏ mục từ không cần thiết,… để chuẩn bị cho

việc lập chỉ mục

IndexWriter: là phần chính trong thành phần Tạo chỉ mục, nó thực

hiện việc tạo mới hoặc mở chỉ mục, sau đó thực hiện thêm mới

hoặc cập nhật nội dung của chỉ mục.

- 66 -


3.2.2. Các bƣớc sử dụng Lucene

1. Mô tả đối tƣợng cần đánh chỉ mục: Lucene coi mỗi đối tƣợng cần

đánh chỉ mục là một Document. Mỗi Document có thể có nhiều

Field, mỗi Field tƣơng ứng một thuộc tính của đối tƣợng cần đánh

chỉ mục. Ví dụ, muốn tìm kiếm các trang web ở dạng HTML. Nhƣ

vậy đối tƣợng cần đánh chỉ mục là trang HTML; các thuộc tính có

thể là nơi lƣu trữ (host), đƣờng dẫn, tiêu đề, metadata và nội dung

của chính trang web. Với mỗi Field, bạn có thể chọn giữa đánh chỉ

mục hay không đánh chỉ mục. Nếu chọn đánh chỉ mục, bạn có thể

tìm kiếm trên Field đó. Các Field không đánh chỉ mục thƣờng là

các Field không quan trọng trong quá trình tìm kiếm và phục vụ

chủ yếu cho nhu cầu trình bày kết quả trả về.

2. Đánh chỉ mục: Thực hiện xây dựng các hàm công cụ để chuyển đổi

dữ liệu ban đầu thành dữ liệu mô tả trong Document. Ví dụ, nếu dữ

liệu ban đầu của là tập tin PDF hay Word, thì phải có các hàm để

đọc hiểu các định dạng này và chuyển về dạng chuỗi văn bản tƣơng

ứng. Thao tác đánh chỉ mục khá phức tạp. Trƣớc hết dữ liệu văn

bản sẽ đƣợc phân tích thành các từ khóa, đồng thời loại bỏ các từ

không dùng đến (stop words, trong tiếng Anh các từ nhƣ a, an, the

là các stop words), sau đó các từ khóa sẽ đƣợc dùng để tạo inverted

index (chỉ mục nghịch đảo) và lƣu thành các phân đoạn dạng thuận

tiện cho việc tìm kiếm sau này. Chỉ mục nghịch đảo dùng để chỉ

cách lƣu trữ danh sách các tài liệu mà có chứa từ cho trƣớc. Gọi là

nghịch đảo bởi vì thông thƣờng, với mỗi tài liệu cho trƣớc, ngƣời ta

lƣu trữ danh sách các từ có trong tài liệu đó. Ví dụ, với từ khóa

Lucene, ta sẽ lƣu trữ danh sách các trang web A, B, C có chứa từ

khóa này. Sau này khi ngƣời dùng gõ vào từ khóa Lucene, danh

- 67 -


sách này có thể giúp định vị nhanh chóng các trang web có chứa

nó. Nếu dùng chỉ mục thông thƣờng, phải quét qua hết các trang

web có trong cơ sở dữ liệu mới tìm ra. Cách này rất tốn thời gian

khi số lƣợng dữ liệu lớn.

3. Tìm kiếm: Sau khi dữ liệu đã đƣợc đánh chỉ mục, có thể thực hiện

tìm kiếm trên chúng. Tìm kiếm toàn vẹn cho phép bạn có thể tìm

kiếm theo danh sách các từ khóa cùng với các toán tử luận lí.

Lucene không phải là một ứng dụng hay một máy tìm kiếm hoàn chỉnh để

ngƣời dùng có thể sử dụng ngay, đây chỉ là một thƣ viện, nó cung cấp các thành

phần quan trọng nhất của một máy tìm kiếm đó là tạo chỉ mục và truy vấn.

Chính vì chỉ cung cấp các thành phần quan trọng trong việc tạo chỉ mục nên

ngƣời dùng rất linh hoạt trong việc ứng dụng vào sản phẩm của mình, cũng nhƣ

có một số cải tiến cho phù hợp hơn.

3.3. Ứng dụng tìm kiếm thông tin trên văn bản

Ứng dụng bao gồm hai thành phần:

1. Thành phần tạo chỉ mục: Bao gồm chức năng chính nhƣ chỉ định

dữ liệu để lập chỉ mục, thực hiện phân tích tài liệu, tạo chỉ mục và

lƣu trữ xuống tập chỉ mục, cập nhập chỉ mục trong trƣờng hợp bổ

sung hay thay đổi nội dung chỉ mục.

2. Thành phần tìm kiếm: Áp dụng thuật toán KMP để thực hiện tìm

kiếm, hiển thị danh sách kết quả và có liên kết đến tài liệu gốc.

- 68 -


Hình 3.4. Mô hình ứng dụng tìm kiếm thông tin văn bản

3.4. Cài đặt chƣơng trình thử nghiệm

3.4.1. Giải pháp, công nghệ sử dụng

Công nghệ, công cụ: Ứng dụng đƣợc xây dựng trên bộ công cụ

Microsoft Visual Studio 2010, trên nền tảng .Net Framework 4.0.

Sử dụng thƣ viện mã nguồn mở Lucene để thực hiện đọc, phân tích

và lập chỉ mục các tài liệu đƣợc lƣu trữ.

Thuật toán sử dụng: Sử dụng thuật toán KMP để thực hiện việc so

mẫu.

3.4.2. Nội dung chƣơng trình

Chƣơng trình sử dụng thƣ viện IFilter để đọc và phân tích các file của

Microsoft Office và trích xuất văn bản từ các file đó. IFilter là một thƣ viện có

sẵn trong window (từ window 2000 trở lên).

Hàm thực hiện đọc, phân tích và lập chỉ mục cho các file văn bản

public static string Parse(string filename)

{

IFilter filter = null;

try {

StringBuilder plainTextResult = new StringBuilder();

filter = loadIFilter(filename);

- 69 -


STAT_CHUNK ps = new STAT_CHUNK();

IFILTER_INIT mFlags = 0;

uint i = 0;

filter.Init( mFlags, 0, null, ref i);

int resultChunk = 0;

resultChunk = filter.GetChunk(out ps);

while (resultChunk == 0)

{

if (ps.flags == CHUNKSTATE.CHUNK_TEXT)

{

uint sizeBuffer = 60000;

int resultText = 0;

while (resultText == Constants.FILTER_S_LAST_TEXT || resultText == 0)

{

sizeBuffer = 60000;

System.Text.StringBuilder sbBuffer =

new System.Text.StringBuilder((int)sizeBuffer);

resultText = filter.GetText(ref sizeBuffer, sbBuffer);

if (sizeBuffer > 0 && sbBuffer.Length > 0)

{

string chunk = sbBuffer.ToString(0, (int)sizeBuffer);

plainTextResult.Append(chunk);

}

}

}

resultChunk = filter.GetChunk(out ps);

}

return plainTextResult.ToString();

}

finally

{

if (filter != null)

Marshal.ReleaseComObject(filter);

- 70 -


}

- Hàm tạo bảng so sánh:

public static int[] BuildTable(string p)

{

int[] result = new int[p.Length];

result[0] = 0;

for (int i = 1; i < p.Length - 1; i++)

{

// The substring from p[1] to p[i]

string s = p.Substring(0, i + 1);

var prefixes = Enumerable.Range(1, s.Length - 1)

.Select(a => s.Substring(0, a)).ToList();

var suffixes = Enumerable.Range(1, s.Length - 1)

.Select(a => s.Substring(a, s.Length - a)).ToList();

var common = prefixes.Intersect(suffixes).FirstOrDefault();

result[i] = (common == null) ? 0 : common.Length;

}

return result;

}

}

- Hàm tìm kiếm

private static int SearchKMP(int[] x, string s)

{

int n = s.Length;

int l = x.Length;

int find = 0;

Char[] charPattern = pattern.ToCharArray();

for (int i = 0; i < n; )

{

- 71 -


string a = s.Substring(i, l);

if (a.CompareTo(pattern).Equals(0))

{

return i; // Found match, return match position of the first letter

}

// move position by BuildTable

Char[] charSubstring = a.ToCharArray();

int count = 0;

for (int j = 0; j < l; j++)

{

if (charPattern[j] == charSubstring[j])

{

count++;// count of matched chars

continue;

}

else

{

i += count - x[j]; // move forward steps = matched count - table value

break;

}

}

}

return -999; // not found

}

3.4.3. Kết quả thực nghiệm

- 72 -


3.4.3.1. Giao diện chính của chương trình

Hình 3.5. Giao diện chính của chƣơng trình

Lựa chọn thƣ mục có chứa các file (doc, xls, ppt, html, txt) cần tìm

kiếm.

Nhất nút “Tải dữ liệu” để thực hiện việc lập chỉ mục cho các file

văn bản trong thƣ mục.

Nhập từ khóa cần tìm kiếm trong các văn bản.

Chƣơng trình sẽ thực hiện đọc nội dung của các file văn bản có

trong thƣ mục. Sau đó thực hiện so khớp từ khóa cần tìm trong nội

dung của các văn bản (Tìm kiếm toàn văn) theo thuật toán KMP.

Chƣơng trình sẽ đƣa ra danh sách các file mà nội dung có chứa từ

khóa tìm kiếm. Khi chọn vào một trong những file kết quả thì

chƣơng trình sẽ thực hiện mở file đó lên để xem nội dung.

3.4.3.2. Kết quả thử nghiệm của chương trình khi tìm kiếm với từ khóa “Văn

bản”

- 73 -


Hình 3.6. Kết quả tìm kiếm của chƣơng trình

3.5. Kết luận chƣơng 3

Chƣơng này trình bày về bài toán tìm kiếm mẫu, tìm kiếm thông tin trên

văn bản. Áp dụng thuật toán KMP để xây dựng chƣơng trình thử nghiệm đơn

giản dựa trên ngôn ngữ lập trình C# trên nền hệ điều hành Window và tiến hành

chạy thử nghiệm chƣơng trình với một số cụm từ khóa tìm kiếm trên các file văn

bản lƣu trữ.

- 74 -


KẾT LUẬN

Đánh giá kết quả đề tài:

Trong quá trình nghiên cứu và thực hiện, luận văn đã đạt đƣợc nhƣng kết

quả nhƣ sau:

Giới thiệu một số khái niệm cơ bản so khớp chuỗi, các hƣớng tiếp

cận, các dạng so khớp và một số thuật toán so mẫu.

Trình bày về thuật toán KMP, thuật toán KMP mờ và thuật toán

KMP-BM mờ.

Cài đặt thuật toán KMP bằng ngôn ngữ lập trình C# chạy trên nền

hệ điều hành Window và sau đó thử nghiệm tìm kiếm với một số

cụm từ khóa trên các file văn bản đƣợc lƣu trữ.

Hạn chế:

Chƣơng trình thử nghiệm còn đơn giản. Chƣơng trình chỉ thực hiện

đƣợc các thuật toán tìm kiếm trên một số định dạng cơ bản: doc,

ppt, xls, html, txt. Chƣa hỗ trợ tìm kiếm trên một số định dạng: pdf,

docx, xlsx, ppts.

Chƣơng trình mới dừng lại tìm kiếm trong máy cục bộ, chƣa hỗ trợ

tìm kiếm thông qua mạng LAN và Internet.

Hƣớng phát triển trong tƣơng lai:

Với những kết quả đã đạt đƣợc, tác giả đề xuất một số công việc tiếp theo

trong thời gian tới nhƣ sau:

Tiếp tục xử lý những vấn đề còn tồn tại trong chƣơng trình thử

nghiệm đã cài đặt nhƣ: Vấn đề dữ liệu vào, xây dựng giao diện

chƣơng trình thân thiện và dễ sử dụng hơn.

- 75 -


Tiếp tục nghiên cứu để ứng dụng, phát triển chƣơng trình hỗ trợ tìm

kiếm qua mạng Lan và tìm kiếm trên Internet thông qua Website.

- 76 -


TÀI LIỆU THAM KHẢO

Tiếng Việt

[1] Đặng Huy Ruận (2011), Lý thuyết thuật toán, NXB. Đại học Quốc

gia Hà Nội.

[2] Robert Sedgewick (1994), Cẩm nang thuật toán, Tập 1: Các thuật

toán thông dụng, NXB Khoa học và Kỹ thuật.

[3] Nguyễn Hữu Điển (2006), Một số vấn đề về thuật toán, NXB. Giáo

dục.

[4] Vũ Thành Nam, Phan Trung Huy, Nguyễn Thị Thanh Huyền (2005),

“Mã tích đàn hồi và tìm kiếm trên văn bản mã hoá sử dụng thuật

toán so mẫu theo tiếp cận mờ”, Báo cáo khoa học tại Hội nghị Ứng

dụng toán học toàn quốc lần 2, Hà Nội, 12/2005.

[5] Phan Thị Tƣơi (1986), Trình biên dịch 1986 (Chƣơng 3 : Bộ phân

tích từ vựng), Nhà xuất bản Giáo dục.

Tiếng Anh

[6] Thomas H. Cormen (2009), Introduction to Algorithms, MIT Press.

[7] Christian Charras, Thierry Lecroq (2000), Handbook of Exact

Stringmatching Algorithms.

[8] Donald Knuth, James H. Morris, Jr, Vaughan Pratt (1977), “Fast

pattern matching in strings”, Siam J.Comput, Vol 6, No. 2, Nune

1977.

[9] Aho A.V.(1992), Algorithms for finding patterns in strings, Chapter

5 of Jan Van Leeuwen (ed.), Handbook of Theoretical Computer

Science "Algorithms and Complexity", The MIT Press, pp. 255-300.

[10] Erik Hatcher, Michael McCandless (2008), Otis Gospodnetic:

“Lucene in Action”, Apache Jakarta Project Management

Committee.

Nghiên Cứu Thuật Toán Knuth Morris Pratt Và Ứng Dụng

Documents

Transcript of Nghiên Cứu Thuật Toán Knuth Morris Pratt Và Ứng Dụng