1

התאמת מחרוזות תווים

מציאת מחרוזת תווים בטקסט מסוים.

משתמשים בזה הרבה במעבד •תמלילים.

חיפוש אחר תבנית מסוימת •DNAברצפים של

T[1...n]טקסט –

P[1...m]תבנית –

m<nכאשר

2

לקוחים P ו- Tמניחים כי אברי מאלפבית סופי.

מופיעה עם pנאמר כי התבנית Sהיסט

אם: T בטקסט

0<s<n-m -ו T[s+1,…,s+m]=p[1…m]

:דוגמה

T טקסט

P תבנית

a ab a b b b c a b b a c

a b bS=3

3

בעיית התאמת המחרוזות היא הבעיה של מציאת כל ההיסטים התקפים שבהם מופיעה תבנית

.T בטקסט נתון pנתונה

:סימונים

- קבוצת כל המחרוזות בעלות אורך סופי שאפשר ליצור מתווים

.הלקוחים מן האלפבית |x| אורך של מחרוזת -x.

xy שרשור של מחרוזת -x למחרוזת y מחרוזת הבנויה מתווי(x ואחריהם

(.yתווי

*

4

:מינוחים

:רישא

w<x מחרוזת w היא רישא של y אם קיימת מחרוזת xמחרוזת

.x=wyשעבורה

.|w|<|x|מכך נובע

:סיפא

w >x מחרוזת w היא סיפא של y אם קיימת מחרוזת xמחרוזת

.x=ywשעבורה

.|w|<|x|מכך נובע

*

*

5

:הערה

הם טרנזטיביים. >, >היחסים

:למה

הן מחרוזות המקיימות x,y,zנניח

x > z -ו y > z אם .|x|<|y| אזי x > y אם |x|<|y| אזי y > x ,

.x=y אזי |x|=|y|אם

:נקצר את הסימונים

Pk יהיה הרישא בת k התווים p[1...k] של התבנית p[1...m].

(Pm=P=p[1...m].)

k זה הרישא בת Tkבאופן דומה .Tתווים של הטקסט

6

:הגדרת הבעיה בצורה אלגנטית

בתחוםsמציאת כל ההיסטים

0<s<n-m שעבורם p > Ts+m.

:אלגוריתם נאיבי להתאמת מחרוזותNAÏVE-STRING-MATCHER)T,P(

1. n=length[T]

2. m=length[P]

3. For s=0 to n-m

3.1 if p[1…m] = T[s+1…s+m]

3.1.1 print “pattern with shift” s

)o))n-m+1(mסיבוכיות

7

אנו נגיע למקרה הגרוע כאשר הטקסט

3.1 והתבנית כי בשלב הוא יבדוק את כל התווים בתבנית.

)כאן הוא יצליח למצוא(.

האלגוריתם לא יעיל מאחר והוא מתעלם מן המידע על הטקסט

בעת sשנרכש עבור ערך אחד של אחרים.sשהוא בוחר ערכי

:דוגמה

P=aaab-ו s=0 הוא היסט תקף אזי אינו יכול 1,2,3אף אחד מההסטים

ואנו b=T[4]להיות תקף מאחר ו- באלגוריתם לא מנצלים זאת.

nama

8

:(RK)אלגוריתם רבין –קארפ

מסתכלים על הטקסט כמספרים ולא כאותיות.

,א"בd=| | כל מילה מייצגת ,.dמספר בבסיס

.d מייצג ספרה בבסיס כל תו מ-

מייצגים מספרים מילים עם תווי .dבבסיס 3 2 1 0 :דוגמה

={a,b,c,e}

bbcaebc 1120312

10בבסיס ...43*42+0*41+3*2+1:

9

P[1…m]מספר - m ספרתי בבסיס d.

P=p[m]+p[m-1]*d+p[m-2]*d2 +…+p[1]*dm-1

צריך לחלק את הטקסט למספרים באורך התבנית.

m)המספר ה- ts נגדיר s<n-m>0לכל sספרתי שיישב אחרי היסט של

מקומות(.

ts= T[s+m]+t[s+m-1]*d +…+T[s+1]*dm-1

ts=p כנ"ל כך ש-sאנו מחפשים כל

כנ"ל s, לכל P: נחשב את רעיון בתוכו ונשווה בניהם. tsנחשב את

10

:סיבוכיות

)P: 1+2+…+m-1=o)m2חישוב

)ts: o)m2חישוב

)o)n*m2 :סה"כsלכל

:שיפור האלגוריתם

חישוב עפ"י שיטת הורנר•

7514= 7*103+5*102+1*101+4*100 =)))7*10+5(*10+1(*10(+4

בצורה כללית:

P=))..)p[1]*d(+p[2](*d+…(*d+p[m]

11

:tsבדומה לכל

ts=))..)T[s+1]*d(+T[s+2](*d+…(*d

+T[s+m]

ts+1 ובין ts. נראה כי יש קשר בין 2)נרצה לשפר גם כאן(.

7*104+1*103+0*102+3*10+1

1*104+0*103+3*102+1*10+2

נראה כי:

t1= )t0-T[1]*dm-1(*d+T[m+1]

7 1 0 3 1 2 8 4 3

12

כנ"ל:sבדומה לכל

ts+1= )ts-T[s+1]*dm-1(*d+T[s+m+1]

.ts ע"י ts+1בכל פעם נחשב את

:אלגוריתם משופר

-dm ואת pנחשב מראש)פעם אחת( את

כנ"ל נחשב s ועבור כל t0 ,נחשב את 1. ts מ-ts+1את

:סיבוכיות

pחישוב

)dm-1 o)mחישוב

t0חישוב

)ts=o)1 מ-ts+1 חישוב

o(m+n)סה"כ:

13

:שיפור נוסף

.qעריכת כל החישובים מודולו

(q.)ראשוני-

מכאן- המספר הגדול ביותר שנעבוד ומספר הספרות של q-1אתו יהיה

.log qהמספר יהיה לכל היותר

בעיה:

p mod q = ts mod q

p = ts

פתרון:

p mod q = ts mod qכאשר נקבל .ts לעומת p נבדוק ישירות את

14

דוגמה:

P

mod 13

T

פגיעה תקפה פגיעה מדומה

3 1 4 1 5

7

2 3 5 9 0 2 3 1 4 1 5 2 6 7 3 9 9 2 1

8 9 3 11 0 1 7 8 4 5 10 11 7 9 11

15

:האלגוריתם

Rabin-Karp-Matcher)T,P,d,q(

1. n= length[T]

2. m= length[P]

3. h= dm-1mod q

4. p= 0

5. t0= 0

6. For i=1 to m

6.1 p=)d*p+P[i](mod q

6.2 t0=)d*t0+T[i](mod q

7. For s=0 to n-m

7.1 if p=ts

7.1.1 if p[1…m] = T[s+1…s+m]

7.1.1.1 print “ pattern shift” s

16

7.2 if s<n-m

7.2.1 ts+1=)d)ts-T[s+1]*h(+

T[s+m+1](mod q

:סיבוכיות

O)m+n+m*)v+ ( חישובים מעבר על המערך

ראשונים

בדיקה ממשית עבור פגיעה

V .מספר ההיסטים התקפים -

- תוחלת מספר הפגיעות יהיה שווה ל-tsהמקריות)הסיכוי ש-

P mod q-1 ניתן לאמוד ב/q.)

יהיה גדול מספיק אז יתנהג qאם •כמו קבוע.

q

n

q

n

q

n

17

גדול q קטן ו-vכלומר עבור .)o)m+nהסיבוכיות תהיה

18

אלגוריתם קנות' מוריס-פראט (kmp)

האלגוריתם מוצא התאמה מדויקת .)o)n+mבזמן

השיטה באלגוריתם זה חישוב של התבנית.פונקצית הרישא

פונקצית הרישא של התבנית אוצרת ידע אודות התאמת התבנית

להיסטים של עצמה. במידע זה ניתן להשתמש כדי להימנע

מבדיקה מיותרת של היסטים חסרי תועלת כפי שעושה האלגוריתם

הנאיבי.

19

:דוגמה

T

P

אנו רואים כי התו האחרון של התבנית לא הותאם לתו של

הטקסט.

אם נעבד את התבנית נוכל לראות כי יש הסטים שלא יהיו תקפים ולא

נצטרך אפילו לבדוק אותם. .s=2 ו-s=1למשל נמנע מההיסטים

a b c a b c a b c c a b b

a b c a b c c

20

את החישובים המקדימים של התבנית ננסח באופן פורמלי כדלקמן:

, פונקצית p[1…m] בהינתן תבנית היא pהרישא עבור התבנית

הפונקציה

:{1,2,…,m} {0,1,…,m-1}

המקיימת:

[q] = max{k|k<q וגם pk pq}

הוא אורכה של הרישא [q]כלומר שהיא הסיפא pהארוכה ביותר של

.pqממש של

21

:דוגמה

I

P[i]

[i]

Compute-prefix)p(1. [1] = 0

2. K=0

3. For q=2 to m

3.1 while k<0 and p[k+1]p[q]

3.1.1 k= [k]

3.2 if p[k+1]=p[q]

3.2.1 k=k+1

3.3 [q] = k

4. Return

1 2 3 4 5 6 7 8 9 10

a b a b a b a b c a

0 0 1 2 3 4 5 6 0 1

22

נראה דוגמה איך עובד אלגוריתם התאמת המחרוזות:

i

P[i]

[i]

T 1 2 3 4 5 6 7 8 9 10 … 16 … 23

התאמה התאמה

s=16-10=6 s=23-10=13

)הסבר בכיתה(.

1 2 3 4 5 6 7 8 9 10

a b b a b b a a b b

0 0 0 1 2 3 4 1 2 3

a b b a b b a b b a b b a a b b a b b a a b b

23

KMP Matcher)T,P(1. = compute-prefix)P(

2. q = 0

3. For i=1 to n

3.1 while q<0 and p[q+1] T[i]

3.1.1 q = [q]

3.2 if p[q+1] = T[i]

3.2.1 q = q+1

3.3 if q=m

3.3.1 print “pattern shift” i-m

3.3.2 q= [q]

24

:סיבוכיות

דורשת הפונקציה לחישוב o)m(.

מספר הפעולות הוא מספר הפניות .q ול-Kל-

q מקבל m-1.ערכים

מקודם לכל for , kבכל לולאת .1היותר ב-

הוא יכול לרדת בלולאה מספר , אבל כיוון שהעלייה 0פעמים עד

איטית, לא תהינה ירידות משמעותיות רבות.

q<kכל הזמן נשמר אי השוויון וסה"כ m אינו עולה על Kולכן

.)o)mהזמן הוא

25

פונקצית ההתאמה)בין התבנית לטקסט( עובדת באופן דומה ולכן

.)o)nסיבוכיות הזמן שלה היא