מבוא למדעי המחשב תרגול מספר 11

הנושאים להיום סיבוכיות זמן ומקום של אלגוריתמים. למה צריך ללמוד את זה? 100% יופיע במבחן מדד ליעילות של אלגוריתמים

סיבוכיות זמן - מוטיבציה מעוניינים במדד למהירות האלגוריתם פשוט אוניברסאלי הצעה: נקמפל, נריץ על קלט מסוים ונמדוד זמן ריצה תלוי מערכת => יש לנתח ולספור פעולות תלוי "גודל" קלט => יש להתייחס כפונקציה של "גודל קלט" ייתכן קלט "נוח" => יש להתייחס לקלט "הגרוע ביותר" קלטים קטנים לא מעניינם => מספיק התנהגות אסימפטוטית זמן ביצוע פעולות שונה => ניתן להסתפק בקירוב עד כדי קבוע

סיבוכיות זמן – הגדרת t(n) נסמן ב- t(n) את מספר הפעולות המקסימאלי שמבצע אלגוריתם, כתלות ב- n – "גודל הקלט". "פעולה" – פעולה אלמנטארית, מתבצעת בזמן קבוע קטן למה סופרים פעולות ולא זמן ריצה? n – "גודל הקלט", תלוי בעיה (כמות מספרים, אורך מחרוזת וכו') מספר פעולות מקסימאלי – לקלט הכי גרוע בגודל n למה מקסימאלי? כעת בהינתן האלגוריתם, נחשב את t(n)

סיבוכיות זמן – פישוט t(n) t(n) מסובכת, למשל t(n)=3n2-10n+nlog3n-2log2n נחפש קירוב פשוט f(n) אשר "מתנהגת בערך כמו t(n)" f’(n)=3n2 מתנהגת כמו t(n) אסימפטוטית f’(n)/t(n) שואף ל-1 כאשר n שופת לאינסוף f(n)=n2 מתנהגת כמו t(n) אסימפטוטית עד כדי קבוע f(n)/t(n) שואף ל-3 כאשר n שופת לאינסוף f(n)=n2 נקראת סיבוכיות זמן של האלגוריתם

סיבוכיות זמן – הגדרה סיבוכיות (זמן): קירוב אסימפטוטי (עד כדי קבוע) לכמות הפעולות שהאלגוריתם מבצע לקלט הכי גרוע בגודל נתון ישנם בשלושה מדדים (קירובים) לסיבוכיות: חסם עליון - O ("או") חסם תחתון - Ω ("אומגה") חסם הדוק - θ ("תטה")

הגדרות (תזכורת) סימון קיים c>0 וקיים N שלם כך שלכל n>N: משמעות t(n) = O(f(n)) t(n) ≤ c·f(n) חסם אסימפטוטי עליון t(n) = Ω(f(n)) t(n) ≥ c·f(n) חסם אסימפטוטי תחתון t(n) = Θ(f(n)) t(n)=O(f(n)) t(n)=Ω(f(n)) וגם חסם אסימפטוטי הדוק

אינטואיציה להגדרות t(n) = Ω(f(n)) t(n) = O(f(n)) t(n) = Θ(f(n)) c1*f(n) t(n) t(n) = O(f(n)) N2 c2*f(n) t(n) t(n) = Ω(f(n)) N1 c1*f(n) t(n) t(n) = Θ(f(n)) N2 c2*f(n)

דוגמא נתון אלגוריתם ש"זמן הריצה" (כמות הפעולות) שלו כתלות בקלט n מתואר ע"י פונקציית הסיבוכיות הבאה: f(n) = 4n3 מה מהבאים נכון? f(n) = 4n3 + 2n2 t(n) = 4n3 + 2n2 + 7 O Ω Θ O(1) Ω(1) Θ(1) O(logn) Ω(logn) Θ(logn) O(n2) Ω(n2) Θ(n2) O(n3) Ω(n3) Θ(n3) O(n3logn) Ω(n3logn) Θ(n3logn) O(n4) Ω(n4) Θ(n4) O(2n) Ω(2n) Θ(2n)

"כלל אצבע" בסיסי כאשר מחברים כמה איברים, מי שמשפיע הוא זה ששואף לאינסוף הכי מהר (בסיבוכיות הכי גרועה) נסו להוכיח פורמאלית: עבור פולינום מדרגה k: t(n) = aknk + ak-1nk-1 +. . . + a1n + a0 = Θ(nk) באופן דומה : t(n) = an2n + an-12n-1 +. . . + a0 = Θ(2n) ומה לגבי ביטויים מעורבים? t(n) = n + log(n) = Θ(n) t(n) = 2n + n3 = Θ(2n)

היררכיה של מחלקות סיבוכיות

"כללי אצבע" לקביעת סיבוכיות זמן של אלגוריתם "כללי אצבע" לקביעת סיבוכיות זמן של אלגוריתם מהי סיבוכיות הזמן של קטעי הקוד הבאים כתלות ב- n? int i=0; while(i<n) i+=1; int i=1; while(i<n) i*=2; int i=2; while(i<n) i=i*i; Θ(n) Θ(log (n)) Θ(log log (n)) 2 2 2 log2n=log2c*logcn סיבוכיות ליניארית סיבוכיות לוגריתמית

"כללי אצבע" לקביעת סיבוכיות זמן של אלגוריתם "כללי אצבע" לקביעת סיבוכיות זמן של אלגוריתם מה קורה כשיש יותר מלולאה אחת? int i=0,j; while(i<n) i+=1; for(j=0 ; j<n ; j++) x=8; int i=0,j; while(i<n) { i+=1; for(j=0 ; j<n ; j++) x=8; } לולאות "בטור" Θ(n)+ Θ(n)= Θ(n) לולאות מקוננות Θ(n)* Θ(n)= Θ(n2) שימו לב שהלולאות בדוגמאות הנ"ל הן בלתי תלויות! נראה בהמשך דוגמאות שהלולאות כן תלויות.

"כללי אצבע" לקביעת סיבוכיות זמן של אלגוריתם "כללי אצבע" לקביעת סיבוכיות זמן של אלגוריתם עוד דוגמא לקינון לולאות דרך פונקציות: באופן כללי, כאשר מחשבים סיבוכיות של פונקציה, יש להתחשב בסיבוכיות כל הפונקציות הנקראות ממנה! void f1(int x) { int i; for(i=0; i<x; i++) printf("…"); } void f2(int n) { while(n--) { f1(n); O(n2)

לכל הפונקציות הבאות אותה סיבוכיות - Θ(n) אבחנות נוספות (1) לכל הפונקציות הבאות אותה סיבוכיות - Θ(n) for(i=0 ; i<n ; i++) printf("…"); for(i=0 ; i<2n ; i++) printf("…"); for(i=0 ; i<4000n ; i++) printf("…");

אבחנות נוספות (2) מה הסיבוכיות כתלות ב- N? Θ(N) #define N 100 for(i=0 ; i<N ; i++) printf("…"); scanf("%d", &n); for(i=0 ; i<n ; i++) printf("…"); מה הסיבוכיות כתלות ב- N? Θ(N) הסבר: נכון ש- N הוא קבוע, אבל אנחנו שואלים: "איך משתנה זמן הריצה כתלות ב- N?" ערכו האמיתי של N כלל לא משנה. מה הסיבוכיות כתלות ב- n? Θ(n)

תרגיל 1 Θ(n2) Θ(n2) מה סיבוכיות הזמן של הפונקציה הבאה כתלות ב- n? int f1(int a[], int b[], int n) { int i, j;   for(i=0; i < n; i++) for(j = 0; j < n; j++) if(a[i] == b[j]) return i; return –1; } int f1(int a[], int b[], int n) { int i, j;   for(i=0; i < n; i++) for(j = 0; j < i ; j++) if(a[i] == b[j]) return i; return –1; } אותה שאלה, כאשר מחליפים את n ב- i ? Θ(n2) Θ(n2)

שימו לב כי לא משנה מהו הבסיס! תרגיל 2 מה סיבוכיות הזמן של הפונקציה הבאה כתלות ב- n? void f2(int n) { while( n > 1) if(n % 2) n /= 2; else n += 1; } Θ(logn) שימו לב כי לא משנה מהו הבסיס!

תרגיל 3 Θ(nlogn) מה סיבוכיות הזמן של הפונקציה הבאה כתלות ב- n? void f3 (int n) { int i, m=1;   for(i = 0; i < n; i++) m *= n; while( m > 6) m /= 3; } Θ(nlogn)

תרגיל 4 Θ(n2) מה סיבוכיות הזמן של הפונקציה הבאה כתלות ב- n? void f4 (int n) { int i, j, k, count;   k = 1; for(i = 0; i < n; i++) { k *= 3; for(j = k; j; j /= 2) count++; } Θ(n2)

סיבוכיות כתלות ביותר מפרמטר אחד הכול אותו הדבר, רק אם לא ניתן לפשט – אז לא מפשטים! לדוגמה: t(n) = n+3n = O(n) אך: t(m,n) = m+3n = O(m+n) מה סיבוכיות הזמן של הפונקציה הבאה כתלות ב- n ו-M? #define M 100 void f5 (int n) { while(n--) for(i=0; i<pow(M,n); i*=2) printf("..."); } Θ(n2logM)

סיבוכיות זיכרון (מקום) מספר תאי הזכרון (למשל בתים) המקסימלי שאלגוריתם צורך בו זמנית מתחילת ריצתו ועד סופו. void f1(int n) { int x,y,z; . . . } void f2(int n) { int A[N]; . . . } Θ(1) Θ(N) Θ(n) void f3(int n) { int *p=(int*)malloc(n*sizeof(int)); . . . }

סיבוכיות זיכרון (2) אותו העיקרון, אם הבדל אחד: זיכרון (שלא כמו זמן) ניתן לשחרר! (למשל, משתנים לוקאליים) לכן, מחפשים את הצריכה המקסימאלית בו-זמנית על פני הריצה כלומר: סיבוכיות מקום היא קירוב אסימפטוטי (עד כדי קבוע) לכמות המקסימאלית של תאי הזיכרון האלמנטאריים שהאלגוריתם צורך בו-זמנית לקלט הכי גרוע בגודל נתון

סיבוכיות זיכרון (3) כמה זכרון דורשת התוכנית הבאה כתלות ב- N? זיכרו שבסוף בלוק כל הזכרון שהוקצה בבלוק משוחרר. הקצאת הזכרון נראית כך: void f1(void) { int A[N] . . . } int main() { int i; for(i=0 ; i<N ; i++) f1(); return 0; N התקדמות התוכנית כמות זכרון Θ(N)