View
251
Download
16
Embed Size (px)
Citation preview
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)