Laboratorio di Algoritmi e Strutture Dati

Transcription

1 Laboratorio di Algoritmi e Strutture Dati Guido Fiorino guido.fiorino@unimib.it aa

2 Maximum in a sequence Given a sequence A 1,..., A N find the maximum. The maximum is in the first or in the second half of the sequence. If the sequence has one element we immediately have the answer. We can proceed recursively following a divide-and-conquer approach: Base case: if N = 1, then A 1 is the maximum; Recursion: 1 recursively compute the maximum of the sequence A 1,..., A N 2 ; 2 recursively compute the maximum of the sequence A N 2 +1,..., A N ; 3 the maximum of A 1,..., A N is the maximum between the two values. Exercise (method maximum) write a method int maximum(int[] a, int l, int r) that finds the maximum in the array a spanning from l to r.

3 3 Average of a sequence Given a sequence A 1,..., A N find the average. If we know the average of A 1,..., A N 2 and A N 2 +1,..., A N we can compute the average of the whole sequence by appropriately combining the two values. If the sequence has one element, then we immediately have the answer. We can proceed recursively following a divide-and-conquer approach: Base case: if N = 1, then A 1 is the average of the sequence; Recursion: 1 recursively compute the average of the sequence A 1,..., A N 2, let Av 1 be the value; 2 recursively compute the maximum of the sequence A N 2 +1,..., A N, let Av 2 be the value; 3 the average of A 1,..., A N is the Av 1 N 2 +Av 2 (N N 2 ) N Exercise (method avg) Write a method double avg(int[] a, int l, int r) that finds the average in the array a spanning from l to r.

4 4 Binary search Binary search is the alternative to the sequential search applicable to a sorted sequence A 1,..., A N, that is a sequence fulfilling the property: for every i = 1,..., N 1, A i A i+1 holds. Binary search can be described as a divide-and-conquer algorithm. Given a sorted sequence A 1,..., A N and X, proceed recursively as follows: Base case: if N = 0 (the given sequence is empty), then X is not in the sequence; Recursion: 1 if A N 2 = X, then X is in the sequence; 2 if A N 2 > X, then the answer is the result of recursively searching X in the sequence < A 1,..., A N 2 1, else the answer is the result of recursively searching X in the sequence < A N 2 +1,..., A N.

5 Binary search Exercise (method binsearch0) Write a Java method boolean binsearch0(int[] a, int X) that returns true if X occurs in the array a, false otherwise.

6 Binary search public static boolean binsearch0(int[] a, int X){ //empty sequence if (a.length == 0) return false; //X is found if (a[a.length/2] == X) return true; //search for X in the first middle if (a[a.length/2] > X){ int[] b = new int[a.length/2]; for(int i=0; i< b.length; i++) b[i]=a[i]; return binsearch0(b,x); else { //search for X in second middle int[] b = new int[a.length-a.length/2-1]; for(int i=0; i< b.length; i++) b[i]=a[i + a.length/2 + 1]; return binsearch0(b,x);

7 Binary search Exercise (method binsearch) Write a Java method boolean binsearch(int[] a, int X, int left, int right) that returns true if X occurs in the array a spanning from left to right, false otherwise.

8 Binary search //searches for X between a[left] to a[right] boolean binsearch(int[] a, int X, int left, int right){ //empty sequence if (left > right) return false; int middle = (left+right)/2; //X is found if (a[ middle ] == X) return true; //search for X in the first middle if (a[ middle ] > X) return binsearch(a, X, left, middle-1); else return binsearch(a, X, middle+1, right);

9 9 Searching in an unsorted sequence The searching in an unsorted sequence can be described by means of a divide-and-conquer approach. Given a sequence A 1,..., A N and X, proceed recursively as follows: Base case: if N = 0 (the given sequence is empty), then X is not in the sequence; Recursion: 1 if A N = X, then X is in the sequence; 2 2 proceed recursively, searching X in < A 1,..., A N 2 1. If X is found, then X is in the given sequence; 3 proceed recursively, searching X in < A N 2 +1,..., A N. If X is found, then X is in the given sequence. Exercise (method seqsearch) Write a Java method seqsearch that implements the divide-and-conquer approach to search a value in an unsorted sequence. The method seqsearch returns a boolean value. You are free to choose the formal parameters of seqsearch.

10 Palindromes A sequence A 1,..., A N that reads the same backward as forward is palindrome. This definition can be stated recursively as follows: a sequence A 1,..., A N is palindrome if A 1 = A N and A 2,..., A N 1 is palindrome. What about the base case? We have two base cases: the empty sequence and the sequence with one element. Definition (palindrome) A sequence A 1,..., A N is palindrome iff the sequence is empty (equivalently N = 0); the sequence contains one element (equivalently n = 1); A 1 = A n and the sequence A 2,..., A N 1 is palindrome.

11 Palindromes Exercise (method ispalindrome) Write a method boolean ispalindrome(char[] a, int l, int r) that returns true if the array a that spans between l and r is palindrome, false otherwise.

12 Reverse of an array The reverse of a sequence A 1,..., A N, denoted as rev( A 1,..., A N ), is the sequence A N,..., A 1. The definition emphasizes that function rev returns a particular permutation of a given sequence. Thus function rev maps sequences into sequences. Function rev has an easy recursive definition: { A1 if N = 1 rev( A 1,..., A N ) = rev( A 2,..., A n ), A 1 otherwise Exercise (method rev) Write a method int[] rev(int[]a,int i, int n) that returns the reverse of the array a that spans from i to n.

13 Filling a matrix Exercise (method fillmatrix) Use the divide-and-conquer approach to write a Java method fillmatrix that fills of binary digits a matrix M of 2 n rows and n columns, so that at M contains the binary representation of the first n integers. Example, with n = 3, M = You are free to decide the parameters and the returning value of fillmatrix. Possible signatures are int[][] fillmatrix(int c) that returns a matrix with 2 c rows and c columns void fillmatrix(int[][] M, int rmin, int rmax, int cmin, int cmax) that fills M spanning between the rows rmin and rmax and the columns cmin and cmax.

14 14 Maximum Contiguous Subsequence Sum Given a sequence containing (possibly negative) integers, A 1, A 2,..., A N, find the maximum value of j k=i A k. The maximum contiguous subsequence sum is zero if all the integers are negative. The problem can be solved by a divide-and-conquer algorithm. We divide the input in two halves: A 1,..., A N and A N +1,..., A N. 2 2 The maximum contiguous subsequence sum can occur: 1 entirely in the first half; 2 entirely in the second half; 3 begins in the first half but ends in the second half. Note that in this case the contiguous subsequence includes the last element of the first half and the first element of the second half. If we have the answers for each of the three possible cases we can provide the answer for the sequence A 1,..., A N comparing them and returning the greatest.

15 15 Maximum Contiguous Subsequence Sum Given the sequence A 1,..., A N, proceed recursively as follows: Base case: if N = 1 choose the largest between zero and A 1 ; Recursion: 1 recursively compute the maximum contiguous subsequence sum for contiguous subsequences entirely residing in the fist half; 2 recursively compute the maximum contiguous subsequence sum for contiguous subsequences entirely residing in the second half; 3 compute the maximum contiguous subsequence sum for contiguous subsequences that begins in the first half and ends in the second half; 4 the answer for A 1,..., A N is the maximum of the three values.

16 Maximum Contiguous Subsequence Sum To solve Point 3: 1 for each element in the first half, calculate the sum of the contiguous subsequence that ends at the rightmost item of the first half; 2 for each element in the second half, calculate the sum of the contiguous subsequence that starts at the leftmost item of the second half. The sum of maximum value found in each of previous points gives the maximum contiguous subsequence sum for a contiguous subsequence that spans between the two halves. Exercise (method mcss) Write a method int mcss(int[] a, int l, int r) that finds the maximum sum in the array a spanning from l to r by implementing the divide-and-conquer approach given above.

17 MergeSort Given a sequence A 1,..., A N, proceed recursively following the divide-and-conquer approach: Base case: if N = 1, then, the sequence is sorted, return A 1 ; Recursion: 1 recursively sort A 1,..., A N 2 ; 2 recursively sort A N 2 +1,..., A N ; 3 return the result of merging the two sorted subsequences obtained in the previous steps. The implementation of MergeSort depends on the implementation of Phase 3. There are different techniques to perform the merge. The aim is to save time.

18 MergeSort - Bitonic merge We are given an array A we copy A in an extra array E with the elements of the second sequence reversed E Then we merge in A starting from the leftmost cell: A 0 E A 0 2 E A E A E A E

19 MergeSort - Implementation of the bitonic merge //Bitonic merge. Ends with a[left..right] sorted static void merge(int[] a, int left, int m, int right){ int numberofcells = right-left+1, i, j; int[] extra = new int[numberofcells]; //copy a[left]..a[m] in extra[0]..extra[m-left] //in a future version we would like to save this copy for(i = left; i <= m ; i++){ extra[i-left] = a[i]; //copy a[right]..a[m+1] in extra[m+1-left]..extra[right-left] //note the reverse order for(j = right; j >= m+1; j--, i++) { extra[i-left] = a[j]; j = numberofcells-1; //index of last cell of extra i = 0; //index of first cell of extra for(int k = 0; k < numberofcells; k++){ if(extra[i]>extra[j]) { a[k+left]=extra[j--]; else { a[k+left] = extra[i++]; //end bitonicmerge

20 Bitonic merge - exercises Exercise (Variants of the bitonic merge) The code can be changed along this lines public class MergeSort{ //better solution: use extra as member of the class private static int[] extra; public static void sort(int[] a){ extra = new int[a.length]; sort(a, 0, a.length-1); //This method sorts a[left..right] static private void sort(int[] a, int left, int right){ /* write the recursive code for the mergesort */ // end merge // bitonic merge static void merge(int[] a, int left, int m, int right){ /* write here the new code for the bitonic merge */ //end bitonic merge //end class MergeSort

21 MergeSort - merge of two sources in a destination public class MergeSort{ private static int[] extra; /* merge s1[s1left..s1right] and s2[s2left..s2right] into dest starting from cell of index destleft */ static void merge(int[] dest, int destleft, int[] s1, int s1left, int s1right, int[] s2, int s2left, int s2right ) { int q = (s1right-s1left+1) + (s2right-s2left+1); //data to copy int destright = destleft + q -1; //index of the last data for(int i = destleft; i <= destright ; i++){ if (s1left>s1right){ // all data in s1 have been already copied in dest dest[i] = s2[s2left++]; else if (s2left>s2right){ // all data in s2 have been already copied in dest dest[i] = s1[s1left++]; else if (s1[ s1left ] < s2 [ s2left ]){ dest[i] = s1[ s1left++ ]; else dest[i] = s2[ s2left++ ]; //end merge Class continues in the next slide... 21

22 MergeSort - merge two sources in a destination public static void sort(int[] a){ extra = new int[a.length]; for(int i=0; i<a.length; i++) { extra[i] = a[i]; //Important: copy a in extra. Why? //sort the data in extra[0..a.length-1] and //put the result in array a sort(a, extra, 0, a.length-1); //now array a is sorted See next slide...

23 MergeSort - exchanging roles of source and destination //sort data in source and put the result in dest static private void sort(int[] dest, int[] source, int left, int right) { if (right - left > 0){ //the sequence has at least one element int m=(left + right)/2; //sort dest[left..m] and put the result in source[left..m] //note the exchange between source and dest! sort(source, dest, left, m); //sort dest[m+1..right] and put the result in source[m+1..right]; sort(source, dest, m+1, right); //merge source[left..m] and source[m+1..right] and put the result in //dest, starting from left, in practice the result goes in dest[left..right] merge(dest, left, source, left, m, source, m+1, right); //end if, note that the base case is implicit // end sort //end class

24 MergeSort - the copy of the source data in extra Exercise (Question) Can you explain why we have this code? for(int i=0; i<a.length; i++) { extra[i] = a[i]; //Important: copy a in extra. Why? Compare the previous version of MergeSort with the following one and remember that our aim is to save to copy data between extra and a as much as possible.

25 MergeSort - saving the copy public class MergeSort{ private static int[] extra; /* the role of the array a and the extra array as source of the data and destination of the merging is continuously exchanged; in this way we save the copy from a to extra that is performed in the bitonic merge */ public static void sort(int[] a){ extra = new int[a.length]; /* sort the data in extra[0..a.length-1] and put the result in a; */ sort(a, extra, 0, a.length-1); //end sort Class MergeSort continues in the next slide

26 MergeSort - saving the copy //sort data in source[left..right] and put the result in dest[left..right] static void sort(int[] dest, int[] source, int left, int right) { if (right-left == 0){ /* Note that we have an explicit base case. Compare with the previous version */ if (dest == extra) { /* dest == extra true means that source contains the data and the assignment is required. Note that this check is not present in the previous version. */ dest[right]=source[right]; return ; /* end base case */ Method static void sort(int[] dest, int[] source, int left, int right) continues in the next slide

27 MergeSort - saving the copy //recursive part //the sequence has at least one element int m=(left + right)/2; //sort dest[left..m] and put the result in source[left..m] sort(source, dest, left, m); //sort dest[m+1..right] and put the result in source[m+1..right]; sort(source, dest, m+1, right); //merge source[left..m] and source[m+1..right] and put the result in //dest, starting from left, in practice the result goes in dest[left..right] merge(dest, left, source, left, m, source, m+1, right); // end sort static void merge(int[] dest, int destleft, int[] s1, int s1left, int s1right, int[] s2, int s2left, int s2right ) { /* see the code given in a previous slide */ // end class MergeSort

28 28 Listing all permutations of a sequence There are N! permutations of a given a sequence A 1,..., A N, where all the elements are distinct, that is for every A i, A j of the sequence, A i A j if i j. We can describe the set of all permutations of A 1,..., A N by a recursive definition that follows a divide-and-conquer approach: Base case: if N = 1, then A 1 is the only permutation; Recursion: 1 For i = 1,..., N, recursively compute the set S i of permutations of the sequence A 1,..., A i 1, A i+1,... A N ; let V i the set obtained by inserting A i as first element of every sequence in S i, that is V i = { A i, B 1,... B N 1 B 1,... B N 1 S i ; 2 V = V 1 V N is the set of all permutations of A 1,..., A N.

29 Listing all permutations of a sequence Exercise Use the description given in the previous page to write a Java method int[][] listperms(int[] seq) returning a matrix containing the list of the permutations of seq. If you need, method listperms can have more than one formal parameter.

30 30 Listing all permutations of a sequence An alternative is: Base case: if N = 1, then A 1 is the only permutation; Recursion: 1 recursively compute the set S of permutations of the sequence A 2,... A N ; 2 for every sequence B 1,..., B N 1 in S, build the N new subsequences A 1, B 1,..., B N 1, B 1, A 1, B 2,..., B N 1,. B 1,..., B N 1, A 1. This is the set V of the permutations of A 1,..., A N, that is: V = { B 1,..., B j 1, A 1, B j,..., B N 1 B 1,..., B j 1, B j,..., B N 1 S and for j = 1,..., N 1

31 Listing all permutations of a sequence Exercise Use the description given in the previous page to write a Java method int[][] listpermstwo(int[] seq) returning a matrix containing the list of the permutations of seq. If you need, method listpermstwo can have more than one formal parameter.

32 Listing all permutations of a sequence A further alternative to describe the listing of the permutations of a sequence A 1,..., A N is by introducing a second sequence that we call the prefix. The following description is parametrized on two sequences of elements that we call Seq and Prefix. To obtain the list of the permutations of A 1,..., A N, we set Seq = A 1,..., A N and Prefix =. To make the description clearer, we emphasizes the formal parameters of the procedure:

33 33 Listing all permutations of a sequence ListPerm(Seq, Prefix) Base case: if Seq contains one element, then the sequence obtained by the elements in Prefix followed by the element in Seq is a permutation A 1,..., A N in the first call; Recursion: 1 For every element A in Seq Let Seq be the result of erasing from Seq the element A; Let Prefix = A, B 1,..., B u where B 1,..., B u is the sequence in Prefix; ListPerm(Seq, Prefix ), in other words, proceed recursively on Seq, Prefix. In the following, the method listperm provides a Java implementation of the procedure.

34 Listing all permutations of a sequence public static void listperm(int[] a, int[] prefix) { // base case if (a.length == 1) { System.out.print(a[0] + "; "); for (int i = 0; i < prefix.length; i++) { System.out.print(prefix[i] + "; "); System.out.println(); return; The method listperm(int[] a, int[] prefix) continues in the next slide...

35 Listing all permutations of a sequence // recursive step int[] seq1 = new int[a.length - 1]; //this is seq int[] prefix1 = new int[prefix.length + 1]; //this is prefix //build prefix : copy prefix in prefix for(int i = 1; i < prefix1.length; i++) { prefix1[i] = prefix[i-1]; for(int j = a.length - 1; j >= 0; j--) { //complete prefix : put an element of a as first element of prefix prefix1[0] = a[j]; //build seq for(int i = 0, k = 0; i < a.length; i++) { if (i!= j) { seq1[k] = a[i]; k++; perms(seq1, prefix1); //end listperm

36 36 Listing all permutations of a sequence Remark Our implementation strictly follows the description. A better implementation could be provided, possibly using some more formal parameters.

37 37 A collection of exercises on divide-and-conquer method 1 Use the technique divide-and-conquer to write a Java method int count10(int[] a, int left, int right) that returns the frequency of the sequence 1, 0 in the array a spanning from left to right; 2 use the technique divide-and-conquer to write a Java method int findbba(char[] a, int left, int right) that returns the frequency of the string BBA in the array a spanning from left to right; 3 use the technique divide-and-conquer, write a Java method int countooe(int[] a, int left, int right) that returns the number of times that in the array a spanning from left to right an even number is immediately preceded by two odd numbers; 4 use the technique divide-and-conquer, write a Java method int counttruetrue(boolean[] a, int left, int right) that returns the frequency of true, true in the array a spanning from left to right; 5 use the technique divide-and-conquer, write a Java method boolean evenvowels(char[] a, int left, int right) that returns true if in the array a spanning from left to right the number of vowels is even, false otherwise; 6 use the technique divide-and-conquer to write a Java method int count1001(int[] a, int left, int right) that returns the frequency of the sequence 1, 0, 0, 1 in the array a spanning from left to right.