הוראת אינדוקציה ורקורסיה במדעי המחשב

הוראת אינדוקציה ורקורסיה במדעי המחשב

הסמינר המיוחד למורי תיכון מובילים במדעי המחשב

2012טכניון, חיפה, יולי

ראובן בר-יהודה

איך מפולת של אבני דומינו קשור לתכנון לולאות?

2

תשובה: אינדוקציה

3

תנאים מספיקים לנפילת שורת אבני הדומינו:

בסיס: הראשון נופל.

צעד: אם מישהו נופל, אז זה שאחריו נופל

...OK(1) OK(n-1) OK(n)

OK(1)

OK(n-1) OK(n)

תכונות אחרות...

4

תנאים מספיקים לחולי של שורת עכברים:

בסיס: הראשון חולה.

צעד: אם מישהו חולה, אז זה שאחריו חולה

Sick(1)

...Sick(1) Sick(n-1)Sick(n)

Sick(n-1)Sick(n)

צעדים אחרים

5

מה לגבי צעדי אינדוקציה אחרים, למשל:

צעד: המחלה מדבקת בקפיצות של שתיים

בסיס: הראשון חולה.

...

Sick(1), Sick(2)

Sick(n-2)Sick(n)

Sick(1) Sick(n-2) Sick(n)Sick(2)

אינדוקציה שלמה

6

תנאים מספיקים לנפילת שורת אבני הדומינו:

אם כל אלו שלפני נופלים

אז גם אני נופל

...( ) ( )i nOK i OK n

(1)OK ( )OK i

...( 1)OK n ( )OK n

אינדוקציה שלמה: דוגמא

7

קוביות שוקולד.n חיתוכים כדי להגיע ל-n-1טענה: דרושים בדיוק

חיתוכיםn = 1 0הוכחה: בסיס:

n = i + jצעד: נחתוך שרירותית לחלקים לא ריקים:

j < n חיתוכים j - 1

i < n חיתוכים i - 1

1חיתוכים

i-1 + j-1 + 1 = n - 1

אינדוקציה לא קווית

8

DOMINOS

דוגמאות על הלוח...

http://www.youtube.com/watch?v=8GWI0A9o_5E

תכנון לולאות עם מחשבה באינדוקציה

sum מערך חד מימדי (ללא שימוש בסכום כתוב פונקציה שמחשבת (

9

1. function y = my_sum(x)

2. y = 0; % OK(0)

3. for n = 1:length(x) % OK(n-1)

4. y = y + x(n); % OK(n)

5. end

.טענת האינדוקציה

y = x(1)+x(2)+…+x(n) איטרציות:n לאחר

.n באינדוקציה על הוכחה

.0 איטרציות מכיל את ערך האתחול שהוא 0 לאחר n =0 בסיס:

y = x(1)+x(2)+…+x(n-1) איטרציות n-1 נניח שלאחר צעד:

וסיימנו.x(n) את y למוסיפים nבאיטרציה ה


מערך חד מימדי (ללא שימוש במכפלתכתוב פונקציה שמחשבת prod(

10

1. function y = my_prod(x)

2. y = 1; % OK(0)


4. y = y * x(n); % OK(n)

5. end


y = x(1)*x(2)*…*x(n) איטרציות:n לאחר


.1 איטרציות מכיל את ערך האתחול שהוא 0 לאחר n =0 בסיס:

y = x(1)*x(2)*…*x(n-1) איטרציות n-1 נניח שלאחר צעד:

וסיימנו.x(n) ב y אתמכפילים nבאיטרציה ה


מערך חד מימדי (ללא שימוש ב שלORכתוב פונקציה שמחשבת any(

11

1. function y = my_any(x)

2. y = false; % OK(0)


4. y = y || x(n); % OK(n)

5. end


y = x(1)x(2)…x(n) איטרציות:n לאחר


.false איטרציות מכיל את ערך האתחול שהוא 0 לאחר n =0 בסיס:

y = x(1)x(2)…x(n-1) איטרציות n-1 נניח שלאחר צעד:

וסיימנו.x(n) את yל"מוסיפים" nבאיטרציה ה

if y

return

end


all מערך חד מימדי (ללא שימוש ב שלANDכתוב פונקציה שמחשבת (

12

1. function y = my_all(x)

2. y = true; % OK(0)


4. y = y && x(n); % OK(n)

5. end


y = x(1)x(2)…x(n) איטרציות:n לאחר


.true איטרציות מכיל את ערך האתחול שהוא 0 לאחר n =0 בסיס:

y = x(1)x(2)…x(n-1) איטרציות n-1 נניח שלאחר צעד:

וסיימנו.x(n) ב yאת"מכפילים" nבאיטרציה ה

if ~y

return

end


מערך חד מימדי (ללא שימוש מקסימום שלכתוב פונקציה שמחשבת )maxב

13

1. function y = my_max(x)

2. y = - ; % OK(0)


4. if x(n) > y y = x(n); end % OK(n)

5. end


y = MAX{x(1),x(2),…,x(n)} איטרציות:n לאחר


.- איטרציות מכיל את ערך האתחול שהוא 0 לאחר n =0 בסיס: y = MAX{x(1),x(2),…,x(n-1)} איטרציות n-1 נניח שלאחר צעד:

וסיימנו.x(n) ב yאת"מחליפים, אם גדול יותר" nבאיטרציה ה


מערך חד מימדי (ללא שימוש במינימום שלכתוב פונקציה שמחשבת min(

14

1. function y = my_min(x)

2. y = + ; % OK(0)


4. if x(n) < y y = x(n); end % OK(n)

5. end


y = MIN{x(1),x(2),…,x(n)} איטרציות:n לאחר

.nהוכחה באינדוקציה על

.- איטרציות מכיל את ערך האתחול שהוא 0 לאחר n =0 בסיס: y = MIN{x(1),x(2),…,x(n-1)} איטרציות n-1 נניח שלאחר צעד:

וסיימנו.x(n) ב yאת"מחליפים, אם קטן יותר" nבאיטרציה ה

Sorting

512354277 101

5 12 35 42 77 101

1 2 3 4 5 6

1 2 3 4 5 6

sort-by_max.m

1. function a = sort_by_max( a )

2. % sort members of array in non decreasing order

3. for top = length(a):-1:1 % at this point all members above index “top” are in their proper location

4. i = index_of_max(a,top);

5. temp = a(i); a(i) = a(top); a(top) = temp; %swap a(i) with a(top)

6. end

7. end

8.

9. function i_max = index_of_max( a, n )

10. % find the index of the maximum member among a(1:n)

11. i_max = 1;

12. for i = 2:n % invariant: at this point a(i_max) = MAXIMUM{a(1), a(2)…a(i-1)}

13. if a(i) > a(i_max)

14. i_max = i;

15. end

16. end

17. end

16

חיפוש במערכים ממוינים

17

חיפוש בינארי

18

1.function m = bin_search (x, a) 2. % a is a non decreasing sorted array3. % find x in a and return in m its index.4. % if x is not there, m = -15. b = 1; t = length(a);6. while b <= t7. m = floor((b+t)/2);8. if a(m) == x9. return10. elseif a(m) > x11. t = m-1;12. else13. b = m+1;14. end15. end16. m = -1;

חיפוש בינארי: נכונות

19

1.function m = bin_search (x, a) 2. b = 1; t = length(a);3. while b <= t4. m = floor((b+t)/2);5. if a(m) == x6. return7. elseif a(m) > x8. t = m-1;9. else10. b = m+1;11. end12. end13. m = -1;

בכל איטרציהשמורות x לא נמצא ב a(1 : b-1) x לא נמצא ב a(t+1: end)

: באינדוקציה על מספר האיטרציות:הוכחה איטרציות- נכונות באופן ריק.0: בסיסצעד:a(m) > xאם

a(m:end)אז כל האיברים ב ולכן הוא לא שם,xגדולים ממש מ-

a(m) < xאם a(1:m)אז כל האיברים ב

ולכן הוא לא שם.xקטנים ממש מ-

)5 לא נמצא (שורה x: אם בסיוםb>t בה מתקיים 13אז נגיע לשורה

ומכאן נובע שהאיחוד שלa(t+1: end) ו a(1 : b-1)

a לא נמצא ב-x ולכן, לפי השמורות,aמכיל את כל איברי

b t

O(log(n))חיפוש בינארי: סיבוכיות זמן

20

1. function m = bin_search (x, a) 2. b = 1; t = length(a);3. while b <= t4. m = floor((b+t)/2);5. if a(m) == x6. return7. elseif a(m) > x8. t = m-1;9. else10. b = m+1;11. end12. end13. m = -1;

.2 נחצה ב-b:tבכל איטרציה האינטרוואל nאם אורכו בהתחלה היה

n/2אז לאחר איטרציה אחת הוא יהיה בערך n/4לאחר עוד איטרציה הוא יהיה בערך n/8לאחר עוד איטרציה הוא יהיה בערך

n/2k איטרציות הוא יקטן ל kולכן לאחר

הביטוי הנ"ל יהיה קטן מדי?kש: עבור איזה n/2k > 1ת: נפתור את אי השוויון:

2k > nאו: k = log2(n)וזה יקרה כאשר

מכאן מספר האיטרציות O(log (n)(ולכן סיבוכיות הזמן) הוא (

מיזוג מערכים ממוינים:

21

Merging two sorted arrays (Silvio Micali MIT)

20

13

7

2

12

11

9

1

output array

…

20

13

7

2

12

11

9

1

1output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9

20

13

12

11

output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9

20

13

12

11

11output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9

20

13

12

11

11

20

13

12

output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9

20

13

12

11

11

20

13

12

12output array

…


20

13

7

2

12

11

9

1

1

20

13

7

2

12

11

9

2

20

13

7

12

11

9

7

20

13

12

11

9

9

20

13

12

11

11

20

13

12

12

Time = Q(n) to merge a total of n elements (linear time).

output array

…


מיזוג1. function c = merge(a,b)2. % given non decreasing sorted arrays a,b3. % return in c the sorted merge of a and b4. n_a = length(a); n_b = length(b); 5. n_c = n_a + n_b; c = zeros(1,n_c);6. i_a = 1; i_b = 1;7. for i_c = 1 : n_c;8. if i_b > n_b 9. c(i_c) = a(i_a);10. i_a = i_a +1;11. elseif i_a > n_a12. c(i_c) = b(i_b);13. i_b = i_b +1;14. elseif a(i_a) < b(i_b)15. c(i_c) = a(i_a);16. i_a = i_a +1;17. else % a(i_a) >= b(i_b)18. c(i_c) = b(i_b);19. i_b = i_b +1;20. end21. end

35

נכונות

שמורות:

c(1:i_c-1)ממויין

c(1:i_c-1) מכיל את איברי a(1:i_a-1) b(1:i_b-1)

קטנים או שווים לכל האיברים ב c(1:i_c-1)כל האיברים ב a(i_a,end)

קטנים או שווים לכל האיברים ב c(1:i_c-1)כל האיברים ב b(i_b,end)

באינדוקציה על מספר האיטרציות

בסיס: נכון באופן ריק

צעד: ..36

a(1:i_a)-1

i_a n_a1 2 3 …

סיבוכיות לינארית

1. function c = merge(a,b)2. % time complexity3. % is O(length(a)+length(b))4. n_a = length(a); n_b = length(b); 5. n_c = n_a + n_b; c = zeros(1,n_c);6. i_a = 1; i_b = 1;7. for i_c = 1 : n_c;8. if i_b > n_b 9. c(i_c) = a(i_a);10. i_a = i_a +1;11. elseif i_a > n_a12. c(i_c) = b(i_b);13. i_b = i_b +1;14. elseif a(i_a) < b(i_b)15. c(i_c) = a(i_a);16. i_a = i_a +1;17. else % a(i_a) >= b(i_b)18. c(i_c) = b(i_b);19. i_b = i_b +1;20. end21. end

37

קבוע?

n_a + n_b פעמים

!קבוע

רקורסיה

רקורסיה

. מסתמכת על עצמה אם היא הגדרה רקורסיביתהגדרה היא •דוגמאות:

הוא מי שנולד לאם יהודי: "אדם יהודית ההלכהלפי ה•

יה". משמעות ההגדרה הרקורסיבית הינה שעל מנת לדעת יהודימו, דבורה, היא cאם אדם פלוני, משה, הוא יהודי יש לדעת אם א

מה, רות, היא cיהודייה. אך בהתאם להגדרה, דבורה יהודייה אם איהודייה. כדי לבדוק אם רות היא יהודייה צריך להשתמש שוב

בהגדרה הרקורסיבית, וכך הלאה. תנאי עצירה יהיה בתחילת קיומו של עמ"י.

רקורסיה לערך "רקורסיה": "ראו ערך הומוריסטית־מילוניתהגדרה •."

39

)WIKIהגדרה רקורסיבית (מתוך

http://he.wikipedia.org/wiki/%D7%94%D7%92%D7%93%D7%A8%D7%94_%D7%A8%D7%A7%D7%95%D7%A8%D7%A1%D7%99%D7%91%D7%99%D7%AA

http://he.wikipedia.org/wiki/%D7%94%D7%AA%D7%99%D7%99%D7%97%D7%A1%D7%95%D7%AA_%D7%A2%D7%A6%D7%9E%D7%99%D7%AA

http://he.wikipedia.org/wiki/%D7%94%D7%9C%D7%9B%D7%94

http://he.wikipedia.org/wiki/%D7%99%D7%94%D7%93%D7%95%D7%AA

http://he.wikipedia.org/wiki/%D7%9E%D7%99%D7%9C%D7%95%D7%9F

http://he.wikipedia.org/wiki/%D7%94%D7%95%D7%9E%D7%95%D7%A8

http://he.wikipedia.org/wiki/%D7%A8%D7%A7%D7%95%D7%A8%D7%A1%D7%99%D7%94

אינדוקציה

40

בסיס: הראשון נופל.

צעד: אם מישהו נופל, אז זה שאחריו נופל

...OK(1) OK(n-1) OK(n)

OK(1)

OK(n-1) OK(n)

רקורסיה

41

ליפולn-1 מבקש מדומינו nדומינו

ליפולn-2מבקש מדומינו n-1דומינו

...

ליפול1מבקש מדומינו 2דומינו

נופל ורק אז מפולת הדומינו מתחילה1

...האם את

?יהודיה

האם את

?יהודיה

האם את

?יהודיה

האם את

?יהודיה

האם את

?יהודיה

הש

מ

הור

בד

תרו

השר

שימו לב שיש עץ של דומינו שהרקורסיה הנ"ל חשפה בו רק את השרשרת

הרלוונטית.

42שרה

משהדבורה

רות

43

דוגמאות להגדרות ע"י נוסחת נסיגה

נוסחה "סגורה"an=f(n,<parameters>)

נוסחת נסיגהan=f(an-1,.., an-k)

הסדרה

an = a1 + (n-1)∙d a1

an = an-1 + d

סדרה חשבונית:3, 13, 23, 33, …

an=a1∙qn-1 a1

an = q∙an-1

סדרה הנדסית7, 14, 28, 56, …

אין נוסחה סגורה "יפה" a1 = 1

an = n∙an-1

עצרת1, 2, 6, 24, 120, …

an = (φn - (1 - φ)n) / 5φ = (1+5) / 2 ~= 1.6180כאשר

נקרא "יחס הזהב")φ(המספר

a1 = a2 = 1

an = an-1 + an-2

פיבונאצ'י1, 1, 2, 3, 5, 8, 13, …

44

רקורסיה בחישוב עצרת

:myfactr(5)נעקב אחרי הביצוע של •

n = 5

f= 5 *

myfactr(5)

n = 4

f= 4 *

myfactr(4)

n = 3

f= 3 *

myfactr(3)

n = 2

f= 2 *

myfactr(2)

n = 1

f= 1

myfactr(1)

function f=myfactr(n) if n==1, f=1; else f=n*myfactr(n-1); end

בסיס הרקורסיה

קריאה רקורסיבית

45

רקורסיה בחישוב עצרת

המשך ביצוע: "קפול" הרקורסיה.•

n = 5

f= 5 *

myfactr(5)

n = 4

f= 4 *

myfactr(4)

n = 3

f= 3 *

myfactr(3)

n = 2

f= 2 *

myfactr(2)

n = 1

f= 1

myfactr(1)

120

24

6

2

1

46

myfactr הפונקציה הוכחת נכונות של

עם קלט myfactrהפונקציה , nטענה: לכל מספר טבעי •n עוצרת כאשר הערך של המשתנהf הוא n!.

:nהוכחת נכונות ע"י אינדוקציה על הקלט •.1 תחזיר myfactr(1), בדיקה ישירה מראה כי n<2 עבור בסיס:–!. אזי:myfactr(n-1) = (n-1)צעד: נניח כי –

myfactr(n) = n∙myfactr(n-1) = n∙(n-1)! = n!

function f=myfactr(n) if n<2, f=1; else f=n*myfactr(n-1); end

הנחת האינדוקציה

Recursive Mona Liza

(מיקום, גודל)צייר_מונה

צייר_מלבן(מיקום, גודל)1.

אם הגודל קטן מדי, סיים.2.

צייר_פרצוף(מיקום, גודל)3.

(מיקום, גודל מוקטן)צייר_מונה4.

47

Recursive Mona Liza

48-25 -20 -15 -10 -5 0 5 10 15 20 250

5

10

15

20

25

30

35

40

1. function [] = mona(x,y,r) 2. hold on 3. plot(x+r*[0 2 2 -2 -2 0], y+r*[0 0 4 4 0 0])4. axis equal5. if r < 0.1 6. return;7. end8. face(x, y+3*r, r)

9. mona(x, y, 0.5*r)10.end

Face for mona

1. function [] = face(x,y,r)

2. cycle(x,y,r);

3. r0 = 0.3975*r;

4. cycle(x-r/2, y+r/3, r0);

5. segment(x,y-r/2,x,y+r/2);

6. cycle(x+r/2, y+r/3, r0);

7. arc_cycle(x,y,.8*r,1.25*pi,1.75*pi);

8. end

49

1. function []=segment(x1,y1,x2,y2)2. hold on3. plot([x1,x2],[y1,y2]);4. end

1. function []=arc_cycle(x0,y0,r,A,B)2. t = linspace(A,B,100);3. x = cos(t); y = sin(t);4. plot(r*x+x0, r*y+y0);5. end

1. function []=cycle(x0,y0,r)2. arc_cycle(x0,y0,r,0,2*pi);3. end

-10 -8 -6 -4 -2 0 2 4 6 8 10-10

-8

-6

-4

-2

0

2

4

6

8

10

מימוש אינדוקטיבי כנגד רקורסיבי

האיברים הראשונים במערך חד n שלסכום כתוב פונקציה שמחשבת מימדי

50

1. function y = my_sum(x, n)

2. y = 0;

3. for k = 1:n

4. y = y + x(k);

5. end

מימוש רקורסיבי

1. function y = my_sum(x, n)

2. if n==0 y = 0; return; end

3. y = my_sum(x, n-1) + x(n);

51

1. function y = my_prod(x, n)

2. y = 1;

3. for k = 1:n

4. y = y * x(k);

5. end

האיברים הראשונים במערך חד n שלמכפלת כתוב פונקציה שמחשבת מימדי


1. function y = my_prod(x, n)

2. if n==0 y = 1; return; end

3. y = my_prod(x, n-1) * x(n);


52

1. function y = my_any(x, n)

2. y = false;

3. for k = 1:n

4. y = y || x(k);

5. endif y

retuen

end


1. function y = my_any(x, n)

2. if n==0 y = false; return; end

3. y = my_any(x, n-1) || x(n); if x(n) y

=true; re

turn; end

y = my_any(x, n

-1) ;


האיברים הראשונים במערך חד n של ORכתוב פונקציה שמחשבת מימדי

53

1. function y = my_all(x, n)

2. y = true;

3. for k = 1:n

4. y = y && x(n);

5. endif ~y

retuen

end


1. function y = my_all(x, n)

2. if n==0 y = true; return; end

3. y = my_all(x, n-1) || x(n); if ~x(n) y

=false; return; e

nd

y = my_all(x

, n-1) ;


האיברים הראשונים במערך חד n של ANDכתוב פונקציה שמחשבת מימדי

55

-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

1.function [] = face(x,y,r) 2. hold on 3. axis equal4. cycle(x,y,r);5. if r < 10 6. return;7. end8. r0 = 0.4*r;

9. face(x-r/2, y+r/3, r0);10. segment(x,y-r/2,x,y+r/2);

11. face(x+r/2, y+r/3, r0);12. arc_cycle(x,y,.8*r,1.25*pi,1.75*pi);13.end

-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

56

Line =2x=0y=0r=100




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

57

Line =3x=0y=0r=100




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

58

Line =4x=0y=0r=100




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

59

Line =5x=0y=0r=100




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

60

Line =8x=0y=0r=100r0=40 40




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

61

Line =9x=0y=0r=100r0=40

-50 +33 40




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

62

Line =9x=0y=0r=100r0=40

-50 +33 40 Line =2x=-50y=33r=40




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

63

Line =9x=0y=0r=100r0=40

Line =3x=-50y=33r=40




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

64

Line =9x=0y=0r=100r0=40

Line =4x=-50y=33r=40




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

65

Line =9x=0y=0r=100r0=40

Line =5x=-50y=33r=40




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

66

Line =9x=0y=0r=100r0=40

Line =8x=-50y=33r=40

16




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

67

Line =9x=0y=0r=100r0=40

Line =9x=-50y=33r=40r0=16

-70 +47 16

16




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

68

Line =9x=0y=0r=100r0=40

Line =8x=-50y=33r=40r0=16

-70 +47 16 Line =2x=-70y=47




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

69

Line =9x=0y=0r=100r0=40

Line =8x=-50y=33r=40r0=16

Line =3x=-70y=47




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

70

Line =9x=0y=0r=100r0=40

Line =8x=-50y=33r=40r0=16

Line =4x=-70y=47




-100 -50 0 50 100

-80

-60

-40

-20

0

20

40

60

80

Recursive face

71

Line =9x=0y=0r=100r0=40

Line =8x=-50y=33r=40r0=16

Line =8x=-70y=47

3D recursive face

72

-1

0

1

-1-0.5

00.5

1

-1

-0.5

0

0.5

1

1.5

yx

z

3D recursive face

73

1. function [] = face3d(x,y,z,r) 2. hold on 3. axis equal; grid on4. ellipsoid(x,y,z,r,r,r);5. if r < 0.1 return; end6. r0 = 0.3*r;

7. face3d(x-r/2, y+r/3,z+0.9*r, r0); %left recursion8. face3d(x+r/2, y+r/3,z+0.9*r, r0); %right recursion9. ellipsoid(x,y,z+r,r/10,r/4,r/2); % nose10. ellipsoid(x,y-r/2,z+0.8*r,r/2,r/10,r/10); % mouth11. xlabel('x'); ylabel('y'); zlabel('z');12.end

-1

0

1

-1-0.5

00.5

1

-1

-0.5

0

0.5

1

1.5

yx

z

74

פתרונות רקורסיביים בזבזניים

פתרון רקורסיבי עלול להיות מאד לא יעיל מבחינת •סיבוכיות זמן (או מקום).

נדגים זאת על ידי פונקציה רקורסיבית פשוטה לחישוב •-י בסדרת פיבונאצ'י.nהאבר ה

-י היא על ידי שימוש בנוסחה nנעיר שהתכנית הכי יעילה לחישוב האבר ה •הסגורה

נוסחה רקורסיבית נוסחה סגורה

סדרת פיבונאצ'י1, 1, 2, 3, 5, 8, 13,…

a2 = a1 = 1

an = an-1 + an-2

an = (φn - (1 - φ)n) / 5φ = (1+5) / 2 ~= 1.6180כאשר

x2 – x – 1 = 0שהוא שורש של

75

rfib תכנית רקורסיבית לסדרת פיבונאצ'י :

-י בסדרת nלהלן פונקציה רקורסיבית לחישוב האבר ה •פיבונאצ'י על פי ההגדרה.

פונקציה זו מאד לא יעילה: (אקספוננציאלית)•

function f=rfib(n) if n<=2 f=1; else f=rfib(n-1)+rfib(n-2); end

n=6

f = +

76

function f=F(n) if n<=2 f=1; else f=F(n-1)+F(n-2); end

F(6)

F(5) F(4) n=5

f = +F(4) F(3) n=4

f = +F(3) F(2)

n=3

f = +F(2) F(1)

n=2

f = 1

1n=1

f = 1

12

2 n=2

f = 1

1

3

77

rfibהוכחת אקספוננציאליות של באינדוקציה

מספר הפעולות הנדרשות לביצוע Timenיהי

rfib(n) נוכיח . φn<Timen.באינדוקציה

Time1 = 3 > φ1, Time2 = 3 > φ2 בסיס:

.

כרוך בין היתר n הזמן לחשב עבור צעד: n-1 ועבור n-2בקריאה לפונקציה עבור

ולכן:

function f=rfib(n) if n <= 2 f=1; else f=rfib(n-1)+rfib(n-2); end

Timen > Timen-1 + Timen-2

> φn-1 + φn-2 % מהנחת האינדוקציה

> φn-2 (φ + 1)

= φn-2 φ2 %x2 – x – 1 = 0 שורש של φ = φn

78

rfib(n)< מספר העלים = Timen דרך נוספת:

f(2) f(1)

f(3)

f(2) f(1)

f(3) f(2)

f(4)

f(2) f(1)

f(3) f(2)

f(4)f(5)

f(6)

function f=rfib(n) if n<=2 f=1; else f=rfib(n-1)+rfib(n-2); end

f(7)

79

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

מספר הפעולות הוא לינארי.

.f האברים הראשונים בסדרת פיבונאצ'י בוקטור n חישוב זה שומר את כל

-י בפחות זכרון?nהאם ניתן לחשב את מספר פיבונאצ'י ה

function fib = myfib0(n)% Fibonacci number computationf = zeros(1,n); %memory allocationf(1)=1;f(2)=1; for k=3:n f(k)=f(k-1)+f(k-2);endfib=f(n);

80

תכנון דינאמי

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

מציגים תיאור רקורסיבי לדרך פתרון הבעיה.1.

מגלים כי זמן ריצת האלגוריתם הרקורסיבי (הפועל "מלמעלה למטה") הוא 2.

.אקספוננציאלי

מגלים כי מספר תת-הבעיות הקיימות הוא פולינומי, והסיבה לסיבוכיות 3.

האקספוננציאלית היא קריאות חוזרות לאלגוריתם עבור אותה תת-בעיה.

פותרים את הבעיה על ידי פתרון כל התת-בעיות – ממקרי הקצה שהפתרונות 4.

שלהם ידועים מראש "כלפי מעלה" – עד שמגיעים לבעיה המקורית.

http://he.wikipedia.org/wiki/%D7%96%D7%9E%D7%9F_%D7%A8%D7%99%D7%A6%D7%94_%D7%9E%D7%A2%D7%A8%D7%99%D7%9B%D7%99

מיון מיזוג

1. function b = msort(a)2. if length(a)<23. b = a;4. return5. end6. m = ceil(length(a)/2);7. b = merge(msort(a(1:m)),

msort(a(m+1:end)));

81

הדגמה (ויקיפדיה)

82

Analyzing merge sort (Silvio Micali MIT)

MERGE-SORT a(1:n)

1. If n < 2, done2. Recursively sort

a(1 : n/2) and a(n/2 + 1 : n)3. “Merge” the two sorted lists

T(n)

O(1)

2T(n/2)

O(n)

T(n) =O(1) if n < 2;

2T(n/2) + O(n) if n > 1.

Recurrence solving (Silvio Micali MIT)

Solve T(n) = 2T(n/2) + cn, where c > 0 is constant.

Recursion tree (Silvio Micali MIT)


T(n)



T(n/2) T(n/2)

cn



cn

T(n/4) T(n/4) T(n/4) T(n/4)

cn/2 cn/2



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

cn

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

cn

cn

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

cn

cn

cn

…

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

h = lg n

cn

cn

cn

Q(n)

…

#leaves = n

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

h = lg n

cn

cn

cn

Q(n)

Total = ?

…

#leaves = n

…



cn

cn/4 cn/4 cn/4 cn/4

cn/2 cn/2

Q(1)

…

h = lg n

cn

cn

cn

#leaves = n

O(n)

Total = O(n lg n)

…

96

תודהתודה תודה

הוראת אינדוקציה ורקורסיה במדעי המחשב

Documents