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סיבוכיות הזמן שלה היא