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

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

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

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

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

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

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

9. 8 אינטואיציה להגדרות N1N1 c 1 *t(n) f(n) f(n) = O(t(n)) N2N2 c 2 *g(n) f(n) f(n) = Ω (g(n)) N1N1 c 1 *h(n) f(n) f(n) = Θ (h(n)) N2N2 c 2 *h(n)

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

11. 10 כמה כללים בסיסיים מסקנה (נסו להוכיח פורמאלית): עבור פולינום מדרגה k: f(n) = a k n k + a k-1 n k-1 +... + a 1 n + a 0 = Θ(n k ) באופן דומה ניתן להראות: f(n) = a n 2 n + a n-1 2 n-1 +... + a 0 = Θ(2 n ) ומה לגבי ביטויים מעורבים? תרגיל: נוכיח כיf(n) = n + log(n) = Θ(n) בבית: f(n) = 2 n + n 3 = Θ(2 n )

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

13. 12 "כללי אצבע" לקביעת סיבוכיות זמן של אלגוריתם 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) מהי סיבוכיות הזמן של קטעי הקוד הבאים כתלות ב- n? Θ (log (n)) Θ (log log (n)) כן, צריך לדעת לבצע פיתוחים כאלו ! 222 log 2 n=log 2 c*log c n

14. 13 "כללי אצבע" לקביעת סיבוכיות זמן של אלגוריתם 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)= Θ(n 2 ) שימו לב שהלולאות בדוגמאות הנ"ל הן בלתי תלויות! נראה בהמשך דוגמאות שהלולאות כן תלויות.

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

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

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

18. 17 אבחנות נוספות (3) for(i=0 ; i<100 ; i++) printf("…"); מה הסיבוכיות כתלות ב- N? Θ(1) #define N 100 for(i=0 ; i<N ; i++) printf("…"); מה הסיבוכיות כתלות ב- N? Θ(N)

19. 18 תרגיל 1 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; } מה סיבוכיות הזמן של הפונקציה הבאה כתלות ב- n? 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 ? Θ (n 2 )

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

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

22. 21 תרגיל 4 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++; } מה סיבוכיות הזמן של הפונקציה הבאה כתלות ב- n? Θ (n 2 )

23. 22 סיבוכיות כתלות ביותר מפרמטר אחד #define M 100 void f5 (int n) { while(n--) for(i=0; i<pow(M,n); i*=2) printf("..."); } מה סיבוכיות הזמן של הפונקציה הבאה כתלות ב- n ו-M? Θ (n 2 logM)

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

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