7תרגול מס' :

MemoizationQuicksort

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

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

MemoizationMemoization

דוגמא

6

והפתרון:public class FibMemo{

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

}public static int fib(int n) {

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

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

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

if (n==0)lookupTable[n]= 0;

if (n==1)lookupTable[n]= 1;

if (lookupTable[n]==-1)//EMPTYlookupTable[n] = fib (lookupTable,n-1) +

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

}} 7

MemoizationMemoization

כעת עץ הקריאות לפונקציה יראה כך:

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)

8

פתרון אחר:public class FibMemo{

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

}public static int fib(int n) {

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

lookupTable[i] = -1; // EMPTYif (n >= 1)

lookupTable[1]= 1;return fib(lookupTable, n);

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

if (lookupTable[n]==-1)// EMPTYlookupTable[n] = fib (lookupTable,n-1) +

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

}}

9

Divide-and-ConquerDivide-and-Conquer

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

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

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

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

10

(Quick Sortמיון מהיר )

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

צד.

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

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

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

למען פשטות, בקוד שלנו נבחר את האיבר הראשון כציר. 11

- דוגמא (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

12

Quicksort ExamplesApplets:•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

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

13

מיון מהיר – הקודpublic class QuickSort { //….

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

partitionמיון מהיר – 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) //scan

upwardsi = i+1;

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

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

}

swap(arr,start,j); //put pivot in placereturn j;

}15

16

דוגמאת ריצה של partition

6 15 1 9 3 12 21 17 46 4 1 9 3 12 21 17 15

start

pivot

endi ji

Swap!

i i jjjj

6 4 1 3 9 12 21 17 15

j i

3 4 1 6 9 12 21 17 15

pivot

מיון מהיר – פונקציות עזר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();} 17

מיון מהיר – הקוד )המשך(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 18

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

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

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

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

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

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

}”19

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

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

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

} else {//// Your code here//

}return answer;

}

2020

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

n=3

n=2

n=1

n=0 “”21

n=0

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

n=3

n=2

n=1

“”

00 1

22

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

n=0

n=3

n=2

n=1

“”

0 1

110100 10

23

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

n=0

n=3

n=2

n=1

“”

0 1

110100 10

011001000 010 111101100 110

24

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

הקוד 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;

}

2525

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

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

האותיות שונות זו מזו. הם:bcdהמחרוזת למשל הפרמוטציות עבור •

– “bcd" – “bdc" – “cbd“– “cdb”– “dbc“– “dcb”

26

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

27

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=1

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

28

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

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

29

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

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

30

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

31

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

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

32

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

// 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());}

33

deleteפונקציית עזר

הרכבת סכום נתון ממשקולות )תזכורת(

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

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

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

.12 ולקבל את הסכום 3 ו 9

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

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

34

תיאור פתרון

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

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

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

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

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

35

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

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

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

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

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

36

50[10,20,30]

20[10,20,30]

50[10,20,30]

20[10,20,30]

40[10,20,30]

30[10,20,30]

50[10,20,30]

0[10,20,30]

30[10,20,30]

10[10,20,30]

40[10,20,30]

-10[10,20,30]

20[10,20,30]

50[10,20,30]

40[10,20,30]

i=0

i=1

i=2

i=3

calcWeightsקוד

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

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

// A wrapper function, without i argument// A simpler signaturepublic static boolean calcWeights(int[] weights, int

sum) { return calcWeights(weights , 0, sum); }

38

(המשך)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;}

39

דוגמה אחרונה מקבלת 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

40

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

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

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

public static void subsetsSum) ({

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

}

41

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

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

}}

4242