7תרגול מס' : Memoization

Quicksort תרגילים מתקדמים ברקורסיה

1

סדרת פיבונצ'י

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

על שמו קרויה סדרת המספרים הבאה )בניגוד לדעה הרווחת הוא לא •המציא אותה, רק השתמש בה(:

סדרה זו מופיעה בטבע בצורות מפתיעות:•

http://en.wikipedia.org/wiki/Fibonacci_number

2

בסדרה:nחישוב המספר ה-public class Fib {

public static int fib(int n){int ans;if (n==0)

ans = 0;else if (n==1)

ans = 1;else

ans = fib(n-1)+fib(n-2);return ans;

}

public static void main(String[] args){int n = 20;System.out.println("fib ("+n+") = "+fib(n));

}}

רקורסית זנב?!לא 3

MemoizationMemoization(without ‘r’)(without ‘r’)

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

fib(5)

fib(3)

fib(1)fib(2)

fib(1) fib(0)

fib(4)

fib(3)

fib(1)fib(2)

fib(1) fib(0)

fib(2)

fib(1) fib(0)

4

:ניתן לחסוך את החישובים המיותרים ע"י שמירת תוצאות של חישובים שבוצעו

כך שחישוב יתבצע פעם אחת לכל היותר. lookup tables שמירה של תוצאות ביניים ב

לכל ערך שנרצה לחשב, נבדוק תחילה האם ערך זה חושב, כלומר, האם יש עבורו ערך . lookup tableמתאים ב

אם כן, נשתמש בערך זה. אחרת, נבצע את החישוב ונשמור את התוצאה בכניסה המתאימה בטבלה.

. כלומר, לכל קלט אפשרי יש כניסה מתאימה בטבלה.inputהערכים נשמרים בטבלה לפי ה

5

דוגמא

לשמירת memoization נשתמש בטכניקת ה Fibבכדי ליעל את תוצאות החישובים שבוצעו.

-י בסדרת פיבונאצ'י, אשר nנראה תוכנית המחשבת את האיבר ה השומרת תוצאות של חישובים memoizationמשתמשת בטכניקת ה

רקורסיביים.

הינה מערך חד מימדי, כך שתא בעל lookup tableבמקרה זה ה אינדקס במערך, מכיל את הערך . באם ערך זה עדיין לא חושב,

.--11יכיל תא זה את הערך יכיל תא זה את הערך

6

}public class FibMemoוהפתרון:public static void main(String[] args){

int n = 20;System.out.println("fibMemo("+n+") =

"+fibMemo(n));}public static int fibMemo(int n){

int[] lookupTable = new int[n+1];for (int i=0; i < lookupTable.length ; i=i+1)

lookupTable[i] = -1; //EMPTYreturn fibMemo(lookupTable, n);

}public static int fibMemo(int[] lookupTable, int n){

if (n==0) lookupTable[n]= 0;if (n==1) lookupTable[n]= 1;if (lookupTable[n]==-1)//EMPTY lookupTable[n] = fibMemo(lookupTable,n-1) +

fibMemo(lookupTable,n-2);return lookupTable[n];

}}

7

Divide-and-ConquerDivide-and-Conquer

מבוססת על רעיון דומה לפתרון רקורסיבי של בעיות:Divide-and-Conquerטכניקת ה

Divideחלק את הבעיה המקורית לתתי בעיות קטנות )שניים או יותר( - Conquerפתור כל תת בעיה –

צרף את תתי הפתרונות לפתרון לבעיה המקורית. 

ישנם אלגוריתמים רבים המתוכננים לפי עיקרון זה, עליהם נמנים האלגוריתמים הבאים: חיפוש בינארי

MergesortQuicksort

8

(Quick Sortמיון מהיר )( שנבחר pivotחלוקת המערך לשני חלקים לפי ציר )

מחדש בכל שלב של הרקורסיה ומיון רקורסיבי של כל צד

הציר שנבחר הינו הערכה )ניחוש( של החציון של המספרים במערך

תזכורת: חציון הוא מדד למיקום המרכז של קבוצת נתונים מספריים. לדוגמא: החציון של קבוצת

8 הוא 16, 8, 19, 7, 22, 2, 1המספרים

נבחר בקוד שלנו את האיבר הראשון כציר.

9

- דוגמא (Quicksortמיון מהיר )

6 15 1 9 3 12 21 17 4

4 3 1 15 21 17 9 12

1 3 12 9 17 21

9

1 3 4 6 9 12 15 17 21

213

10

Quicksort Example• Example:• http://www.cise.ufl.edu/~ddd/cis3020/summer-97/lectures/lec17/sld001

.htm• www.cs.auckland.ac.nz/software/AlgAnim/Java/q_sort/tqs_new.html

• Video:• http://www.youtube.com/watch?v=2HjspVV0jK4• http://www.youtube.com/watch?v=o2dm4X-t8L0&• http://www.youtube.com/watch?v=FSyr8o8jjwM

11

מיון מהיר – הקוד

import java.util.Scanner;

public class QuickSort {public static void main(String[] args){

Scanner sc = new Scanner(System.in);System.out.println("Enter number of elements to

sort:");int n = sc.nextInt();int[] arr = new int[n];// Initializes arr with random numbers // in [0..10*N)initRandomArray(arr); System.out.println("The input array:");printArray(arr);quicksort(arr);System.out.println("The sorted array:");printArray(arr);

} //…. continued 12

מיון מהיר – הקוד )המשך(

public static void swap(int[] arr, int i, int j){ // swap arr[i] and arr[j] int temp = arr[i];arr[i] = arr[j];arr[j] = temp;

}

public static void initRandomArray(int[] arr){// shuffle the array arrint n = arr.length;for (int i = 0; i < n; i++) {

arr[i] = (int) (Math.random() * 10 * n); }

}public static void printArray (int[] arr) {

for (int i=0; i<arr.length; i=i+1)System.out.print (arr[i]+" ");

System.out.println();} 13

מיון מהיר – הקוד )המשך(

public static void quicksort(int[] arr){quicksort(arr, 0, arr.length-1);

}

public static void quicksort(int[] arr, int start, int end){if (start<end){

int i = partition(arr, start, end);quicksort(arr, start, i-1);quicksort(arr, i+1, end);

}}

14

מיון מהיר – הקוד )המשך(

public static int partition(int[] arr, int start, int end){int pivot = arr[start];int i = start;int j = end;while(i<j){

while(i<end && arr[i] <= pivot)i=i+1;

while(arr[j] > pivot) j=j-1;

if (i<j) swap(arr,i,j);

}

swap(arr,start,j);return j;

}

15

2דוגמה , נרצה להחזיר מערך של ≥n 0בהינתן מספר מספר •

2n המחרוזות באורך n .המורכבות מאפסים ואחדים בבסיס 2n-1סדר המחרוזת הוא סדר המניה מאפס ל

2.

: n=0 הפלט עבור •–}”“{

:n=1הפלט עבור •– “{0”,”1}”

: n=2הפלט •–“{00”,”01”,”10”,11}”

: n=3הפלט עבור •–“{000”,”001”,”010”,011 ,”

“100”,”101”,”110”,111}”16

השלם את הפונקציה

public static String[] binaryNums(int n){String[] answer;if (n==0){

answer = new String[1];answer[0]="";

}else{

//// Your code here//

}return answer;

}

1717

הרעיון של הרקורסיה

n=3

n=2

n=1

n=0 “”

18

n=0

“0” + “” “1” + “”

n=3

n=2

n=1

“”

00 1

19

רעיון של הרקורסיה

n=0

n=3

n=2

n=1

“”

0 1

110100 10

20

רעיון של הרקורסיה

n=0

n=3

n=2

n=1

“”

0 1

110100 10

011001000 010 111101100 110

21

רעיון של הרקורסיה

הקוד public static String[] binaryNums(int n){

String[] answer;if (n==0){

answer = new String[1];answer[0]="";

}else{

String[] prev = binaryNums(n-1);answer = new String[2*prev.length];for (int i =0;i<prev.length; i = i+1){

answer[i]= "0" + prev[i];answer[prev.length + i] = "1“+ prev[i];

}}return answer;

}

2222

הדפסת הפרמוטציות של מחרוזת

פרמוטציה של מחרוזת מוגדרת כמחרוזת המכילה את אותן •אותיות, ייתכן שבשינוי סדר. נניח בדוגמה זו שכל האותיות

שונות זו מזו.

: הםbcdהמחרוזת למשל הפרמוטציות עבור •– “bcd" – “bdc" – “cbd“– “cdb”– “dbc“– “dcb”

23

הרעיון של הרקורסיה

24

abcd,””

bcd, “a”

abcd,””

bcd, “a”

cd, “a” + “b”cd, “a” + “b”

abcdd, “a” + “b” + “c”

““, “a” + “b” + “c” +”d”

output:

i=0

i=0

i=0

i=0i=1i האינדקס =

שלפיו מחלקים את

המחרוזת

הרעיון של הרקורסיה

25

abcd,””

bcd, “a”

abcd,””

bcd, “a”

cd, “a” + “b”cd, “a” + “b”

abcdd, “a” + “b” + “c”

““, “a” + “b” + “c” +”d”

output:

i=0

i=0

i=0

i=1

i=1

הרעיון של הרקורסיה

26

abcd,””

bcd, “a”

cd, “a” + “b”

d, “a” + “b” + “c”

abcd,””

bcd, “a”

cd, “a” + “b”

““, “a” + “b” + “c” +”d”

abcd

c, “a” + “b” + “d”

“”, “a” + “b” + “d” + “c”

abdcoutput:

output:

i=0

i=0

i=1i=2

הרעיון של הרקורסיה

27

abcd,””

bcd, “a”

cd, “a” + “b”

d, “a” + “b” + “c”

abcd,””

bcd, “a”

cd, “a” + “b”

““, “a” + “b” + “c” +”d”

abcd

c, “a” + “b” + “d”

“”, “a” + “b” + “d” + “c”

abdc

bd, “a” + “c”bd, “a” + “c”

d, “a” + “c” + “b”

“”, “a” + “c” + “b” + “d”

acbd

output:

output:

output:

i=0

i=1

i=1

i=1

הרעיון של הרקורסיה

abcd,””

bcd, “a”

cd, “a” + “b”

d, “a” + “b” + “c”

abcd,””

bcd, “a”

cd, “a” + “b”

““, “a” + “b” + “c” +”d”

abcd

c, “a” + “b” + “d”

“”, “a” + “b” + “d” + “c”

abdc

bd, “a” + “c”bd, “a” + “c”

d, “a” + “c” + “b”

“”, “a” + “c” + “b” + “d”

acbd

output:

output:

output:bc, “a” + “d”

. . .

. . .

i=3

28

: הדפסת 3קוד של דוגמה הפרמוטציות של מחרוזת

public static void perms(String s){ // We call the method perm(s,"") which prints // the empty string followed by each permutation // of s the empty string.

perms(s,"");}

29

/** Function prints all the permutation of a string. * Note: assume the string is a set (no duplicate * chars) */

// Prints string acc followed by all permutations of // string s1 public static void perms(String s1, String acc){ if (s1.length()==0) System.out.println(acc); else for (int i=0; i<s1.length(); i=i+1) perms(delete(s1, i), acc +s1.charAt(i));}

: הדפסת 3קוד של דוגמה הפרמוטציות של מחרוזת

30

deleteפונק' עזר:

// This function returns the string s with the i-th // character removedpublic static String delete(String s, int i){

// Assumes that i is a position in the stringreturn s.substring(0,i) +

s.substring(i+1,s.length());}

31

- 4דוגמה הרכבת סכום נתון ממשקולות

בהינתן מערך משקולות אי-שליליים ומשקל נוסף )משקל סכום(, נרצה לבדוק האם ניתן להרכיב מהמשקולות

משקל השווה למשקל הסכום הנתון.

דוגמא לקלט:•weights={1,7,9,3} Sum = 12 כי ניתן לחבר את trueבמקרה זה הפונקציה תחזיר

.12 ולקבל את הסכום 3 ו 9המשקולות דוגמא לקלט: •

weights={1,7,9,3} Sum = 15 כי לא ניתן לחבר falseבמקרה זה הפונקציה תחזיר

.15משקולות לקבלת הסכום

32

תיאור פתרון נתבונן באיבר הראשון במערך. ייתכן שהוא ייבחר

לקבוצת המשקולות שתרכיב את הפתרון ויתכן שלא. אם הוא לא ייבחר (להיות כלול בסכום המהווה את

משקל המטרה) – אזי נותר לפתור בעיה קטנה יותר והיא האם ניתן להרכיב את הסכום מבין המשקולות

שנותרו במערך. אם הוא ייבחר – אזי נותר לפתור בעיה קטנה יותר

והיא האם ניתן להרכיב את הסכום שנותר מבין .המשקולות שנותרו במערך

.וכנ"ל לגבי יתר האיברים בצורה רקורסיבית

33

תיאור פתרון - המשך

פתרון זה קל להציג כפונקציה רקורסיבית ,•boolean calcWeights(int[] weights, int i, int sum )

הפונקציה מחזירה ערך אמת האם ניתן להרכיב את •הסכום מבין קבוצת המשקולות שבתת המערך.

הפרמטרים: •weightsמערך המשקולות – sumהסכום שיש להרכיב מהמשקולות – i .פרמטר נוסף הנחוץ עבור הרקורסיה – i הוא אינדקס

ויסמן את האיבר הנוכחי במערך עליו weightsבמערך מתבצעת הקריאה הרקורסיבית.

34

50:

50: [20,30]

40: [20,30]

40: [30]

40: []

10: []

20: [30]

20: []

-10[]

i=1

i=3

[10,20,30]

i=0

i=2

35

50:

50: [20,30]

i=1

30: [30]

0: []

50: [30]

i=350: []

i=2

20: []

30: []

[10,20,30]

40: [20,30]

i=0

האם צריך לחשבענף ?ימני

36

calcWeights: 4קוד דוגמה

הארגומנטi נחוץ עבור הרקורסיה – אך אינו באמת חלק מהקלט של הבעיה. בקריאה הראשונה ל

calcWeights לכן נוסיף פונקצית 0 ערכו הוא .מעטפת עם חתימה פשוטה יותר.

// An envelope function, without i argument// A simpler signaturepublic static boolean calcWeights(int[] weights, int sum) { return calcWeights(weights , 0, sum); }

37

פתרון )המשך(public static boolean calcWeights(int[] weights,

int i, int sum) {

boolean res = false;

if (sum == 0)

res = true;

else if (i >= weights.length)

res = false;

else

res = calcWeights(weights,i+1,sum-weights[i]) || calcWeights(weights, i + 1, sum);

return res;

}

38

דוגמה אחרונה void subsetsSum(int[] weights, int sum)הפונקציה •

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

.sum שסכומם weights של איברי המערך הקבוצות

, הפונקציה תדפיס:sum=10 ו weights={1,2,3,4,5} עבור דוגמא•

• 1 2 3 4• 1 4 5• 2 3 5

39

דוגמה אחרונה. הרכבת סכום נתון ממשקולותשאלה זו דומה מאוד לשאלת •

נסו להשלים את הפונקציות לבד.

public static void subsetsSum)int[] weights, int sum({subsetsSum)________השלימו את החסר___(;}

public static void subsetsSum) ({

השלימו את החסר

}

40

דוגמה אחרונה: פתרון

public static void subsetsSum(int[] weights, int sum){subsetsSum(weights, sum,0,””);

}

public static void subsetsSum(int[] weights, int sum, int index, String acc){

if(sum == 0)System.out.println(acc);

else if (sum > 0 & index < weights.length){subsetsSum(weights,sum-weights[index],

index+1,acc + weights[index] + ' ');subsetsSum(weights,sum,index+1,acc);

}}

4141