DT228-2 Algorithm and Data Structures, Summer 2009

Transcription

1 DT- Algorithm and Data Structures, Summer 009 Exam Paper Solution Outline Question ( marks) (a) (9 marks)

2 Algorithms & Data Structures Solution Outline Summer 009 (b) (6 marks) class Queue { private: struct Node { int data; Node * next; }; Node * z; Node * head; Node * tail;

3 Algorithms & Data Structures Solution Outline Summer 009 public: Queue() { z = new Node; z->next = z; head = z; tail = NULL; } }; void display(); void enqueue(int x); int dequeue(); bool isempty(); (c) (6 marks) void Queue::enQueue( int x) { Node * temp; temp = new Node; temp->data = x; temp->next = z; if(tail == NULL) // case of empty list head = temp; else // case of list not empty tail->next = temp; } tail = temp; // new node is now at the tail

4 Algorithms & Data Structures Solution Outline Summer 009 (d) (6 marks) (e) (6 marks) Here I am looking for mention of an abstract C++ class which describes the ADT behaviour. Then this class could be inherited by any implementation class. This reduces coupling between client code and the ADT classes.

5 Algorithms & Data Structures Solution Outline Summer 009 Question ( marks) (a) 6 marks 0 6 i = j i = 0 (b) 6 marks BubbleSort( int a[], int n) Begin for i = to n- sorted = true for j = 0 to n--i if a[j] > a[j+] temp = a[j] a[j] = a[j+] a[j+] = temp sorted = false end for if sorted break from i loop end for End

6 Algorithms & Data Structures Solution Outline Summer (c) marks First transform the unordered array into a partially ordered array, namely a heap. Then start removing from heap value at a time and place value at end of previous heap

7 Algorithms & Data Structures Solution Outline Summer 009 And so on

8 Algorithms & Data Structures Solution Outline Summer 009 (d) marks i j 9 i j 9 i j 9 i j 9 i j 9 j i 9 9 i j i j i j j i (e) marks Clearly for an array of size n, the outside loop repeats n- times. To begin with the inside loop does n- comparisons, next time n- and so on. Finally on the last iteration of the outside loop, the inside loop does comparison. So on average the inside loop does ((n-) + ) / = n/ comparisons. Therefore, the overall number of computation steps is n * n/ = n / Complexity of bubble sort = O(n ) The complexity of both quick sort (on average) and heap sort (always) is given by O( much less than O(n ). However, the performance of quick sort in certain situations can deteriorate to O(n ). nlog n ) which is

9 Algorithms & Data Structures Solution Outline Summer 009 Question (a) marks Initial state of parent and distance arrays: Changes to distance and parent arrays as algorithm progresses: 9

10 Algorithms & Data Structures Solution Outline Summer 009 A Minimum Spanning Tree (b) 6 marks Mention the role of the heap in efficiently implementing a priority-queue. The values on the heap are graph vertices and so these are not compared with each other when doing heap operations. Instead they are used as indices into a distance array and the vertex with the smallest distance has the highest priority. Another array hpos[] is also required to locate the position of each vertex in the heap. This is important when a shorter edge is found to connect a vertex to the growing MST and priority of the vertex in the heap must be updated. (c) marks Need diagrams like the following (these are not for the current graph): 0

11 Algorithms & Data Structures Solution Outline Summer 009 (d) 6 marks MST_BestFirst(vertex s ) Begin // G = (V, E) for each v V dist[v] = parent[v] = 0 hpos[v] = 0 h = new Heap v = s // treat 0 as a special null vertex // indicates that v heap // priority queue (heap) initially empty // s will be the root of the MST while v 0 // should repeat V - times dist[v] = - // marks v as now in the MST for each u adj(v) // examine each neighbour u of v if wgt(v, u) < dist[u] dist[u] = wgt(v, u) parent[u] = v if u h h.insert( u) else h.siftup( hpos[u]) End end if end for v = pq.remove() end while return parent

12 Algorithms & Data Structures Solution Outline Summer 009 Question (a) 0 marks Such a problem is: given an array of positive integers, find out if any number occurs more than once in the array. Two simple algs here. (b) marks Suppose n is the size of the problem, e.g. the number elements in an array to be sorted or the number of vertices in a graph, then we say that the problem solution runs in polynomial time if there is a polynomial in n, p(n) say, which places an upper bound on the running time of the solution. i.e. running time of alg p(n) c n k c k n... c n c where p(n) = k k 0 for some k >= 0 and constants c k, c k-.. c 0 0. Here p(n) is a polynomial or order k. As n increases, p(n) will be dominated by the first term algorithms with k > turn out to be not very usable. e.g. Bubble sort runs in time cn for an array of size n where c is some constant. k c kn. In practice, Given a set of values S = {x, x, x, x n,}, find all possible subsets of S. There are n of these. So an algorithm to do this will involve at least n steps. This is an exponential function and grows much faster than any polynomial. (c) marks i) tractable and intractable marks A problem is tractable if it can be solved in polynomial time. If not, it is intractable. Intractable problems are solvable in principle, it s just that they are not in practice when the problem size increases. For example, bubble sort is tractable whereas finding all subsets of a finite set is not. ii) P marks P is the class of algorithms whose complexity is a polynomial function of the problems size. Examples include minimum spanning tree algorithms, finding an Eulerian cycle thru a graph and bubble sort. In fact most useful algorithms have degree or less. iii) NP marks NP means non-deterministic polynomial. Suppose a computer program could guess a solution to a problem and then could check if the guessed solution actually solved the problem and this check could be done in polynomial time, then the program is said to be in the class NP. Non-deterministic is another word for guessing. Most problem are in this class. NP includes P or P NP. Some well known problems in NP are: find a Hamiltonian circuit thru a graph find all subsets of a set travelling salesman problem knapsack problem find the most valuable subset of n items of positive integer weights and values which fit into a knapsack of a given positive integer capacity. partition problem give n positive integers, determine if it is possible to partition them into two disjoint subsets of which have equal sum. graph colouring for a given graph find the smallest number of colours that need to be assigned to the graphs vertices so that no two adjacent vertices share the same colour called the chromatic number of the graph.

13 Algorithms & Data Structures Solution Outline Summer 009 It is an open question in computer science whether problems in NP are in P also, i.e. NP = P? If so, there would be a polynomial time algorithm for finding a solution to each problem in NP. For example is there a polynomial time algorithm that solves travelling salesman problem? No one has been able to prove that there is or is not although it is widely believed that there is not. Believed that P NP. iv) NP-complete marks A problem X is NP-complete if it is in NP and if every other problem in NP both known and unknown can be transformed into X. So by finding a solution to X, we find one to all other problems in NP. The transformation should take polynomial time. The problems listed above in iii) are NP-complete. If any of them had polynomial time algorithm as a solution, then so would all the others. v) halting problem and decidability marks Alan Turing proposed the halting problem: Given a computer program (or algorithm) and input data for it, determine if that program will terminate or halt on that input or if it will continue indefinitely working on it. Turing proved that this problem is undecidable which means that there is no definite method or algorithm (or computer program) which can solve it. That is, there is no program which can accept as input another program and its input, both as input and then decide if the other program will halt when run on its input. Many other problems in computer science are undecidable, e.g. there is no algorithm which can look at a formula in logic (predicate calculus) and decide if it is provable.