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

1

מבוא למדעי המחשב

11תרגול מספר

2

הנושאים להיום

.סיבוכיות זמן ומקום של אלגוריתמים

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

3

סיבוכיות זמן - מוטיבציה

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

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

4

t(n)סיבוכיות זמן – הגדרת

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

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

כעת בהינתן האלגוריתם, נחשב אתf(n)

5

t(n)סיבוכיות זמן – פישוט

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

f(n)/t’(n)-כאשר 1 שואף ל nשואף לאינסוף t(n)=n2 מתנהגת כמו t(n) עד כדי קבוע אסימפטוטית

f(n)/t(n)-כאשר 3 שואף ל nשואף לאינסוף t(n)=n2 של האלגוריתםסיבוכיות זמן נקראת

6

סיבוכיות זמן – הגדרה(זמן):סיבוכיות

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

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

תמיד נשאף לחשב את החסם ההדוק, אך לעיתים נסתפק בחסם עליון

7

הגדרות (תזכורת)

N וקיים c>0קיים שלם כך שלכל

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)... כאשר

8

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

N1

c1*t(n)f(n)

f(n) = O(t(n))

N2

c2*g(n)

f(n)

f(n) = Ω(g(n))

N1

c1*h(n)f(n)

f(n) = Θ(h(n))

N2

c2*h(n)

9

דוגמא נתון אלגוריתם ש"זמן הריצה" (כמות הפעולות) שלו

מתואר ע"י פונקציית הסיבוכיות הבאה:nכתלות בקלט

f(n) = 4n3

?מה מהבאים נכון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)

f(n) = 4n3 + 2n2f(n) = 4n3 + 2n2 + 7

10

כמה כללים בסיסיים מסקנה (נסו להוכיח פורמאלית): עבור פולינום מדרגהk:

f(n) = aknk + ak-1nk-1 +. . . + a1n + a0 = Θ(nk):באופן דומה ניתן להראות

f(n) = an2n + an-12n-1 +. . . + a0 = Θ(2n)

?ומה לגבי ביטויים מעורבים:נוכיח כיתרגיל f(n) = n + log(n) = Θ(n)

f(n) = 2n + n3 = Θ(2n) בבית:

11

היררכיה של

מחלקות סיבוכיות

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))

כן, צריך לדעת לבצע פיתוחים כאלו

!

2 2 2

log2n=log2c*logcn

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)= Θ(n2)

שימו לב שהלולאות בדוגמאות הנ"ל הן בלתי תלויות! נראה בהמשך דוגמאות שהלולאות כן תלויות.

14

"כללי אצבע" לקביעת סיבוכיות זמן של

אלגוריתםעוד דוגמא לקינון לולאות דרך פונקציות:

void f1(int x) { int i; for(i=0; i<x; i++)

printf("…");}

void f2(int n) { while(n--) { f1(n);}

O(n2)

15

)1אבחנות נוספות (

for(i=0 ; i<n ; i++)printf("…");

Θ(n)לכל הפונקציות הבאות אותה סיבוכיות -

for(i=0 ; i<2n ; i++)printf("…");

for(i=0 ; i<4000n ; i++)printf("…");

16

)2אבחנות נוספות (

scanf("%d", &n);for(i=0 ; i<n ; i++)

printf("…");

מה הסיבוכיות כתלות ב- n?

Θ(n)

#define N 100for(i=0 ; i<N ; i++)

printf("…");

?Nמה הסיבוכיות כתלות ב-

Θ(N)

הוא קבוע, N: נכון ש- הסבר "איך אבל אנחנו שואלים:

?" Nמשתנה זמן הריצה כתלות ב- כלל לא משנה.N ערכו האמיתי של

17

)3אבחנות נוספות (

for(i=0 ; i<100 ; i++)printf("…");

מה הסיבוכיות כתלות ב- N?

Θ(1)

#define N 100for(i=0 ; i<N ; i++)

printf("…");

?Nמה הסיבוכיות כתלות ב-

Θ(N)

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;}

שאלה, אותה מחליפים כאשר

?i ב- nאת

Θ(n2

)Θ(n2

)

19

2תרגיל

void f2(int n) { while( n > 1) if(n % 2)

n /= 2; else n += 1;}

?nמה סיבוכיות הזמן של הפונקציה הבאה כתלות ב-

Θ(logn)

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)

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

Θ(n2

)

22

סיבוכיות כתלות ביותר מפרמטר אחד

#define M 100void f5 (int n) { while(n--) for(i=0; i<pow(M,n); i*=2)

printf("...");}

nמה סיבוכיות הזמן של הפונקציה הבאה כתלות ב- ?Mו-

Θ(n2logM)

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)

24

סיבוכיות זכרון (מקום) -כמה זכרון דורשת התוכנית הבאה כתלות בN?שהוקצה בבלוק משוחרר.זיכרו שבסוף בלוק כל הזכרון :הקצאת הזכרון נראית כך

void f1(void) { int A[N] . . .}

int main() { int i; for(i=0 ; i<N ; i++)

f1(); return 0;}

N

התקדמות התוכנית

כמות זכרון

Θ(N)