WEEK 1 CLASS NOTES AARON G. CASS

Transcription

1 WEEK 1 LSS NOTES RON G. SS Sc 250, Spring 2009 aron G. ass epartment of omputer Science Union ollege ELERITY PROLEM celebrity is a person known by all, but who knows nobody. In the celebrity problem, we are given a set of people and asked to find a celebrity within that group. We are allowed to ask questions of the form oes know?. Theorem 1 (Uniqueness of elebrity). In a set S of n people, there can be only one celebrity. Proof. ssume for contradiction that there are two celebrities 1 and 2. y definition of celebrity, everyone knows a celebrity. Therefore α S { 1 }, α knows 1. ecause 2 S { 1 }, 2 knows 1. ut celebrities don t know anyone. Therefore, 2 is not a celebrity. This contradicts our assumption that 2 was a celebrity. Therefore the assumption is false. Therefore, we cannot have two celebrities. POSSILE LGORITHMS FOR THE ELERITY PROLEM The first algorithm is based on a brute-force approach. We essentially look at each pair of people to see if they know each other. If we find a person that knows nobody but is known by all the others, that person is a celebrity: ELERITY(S) Input: set S of n people Output: a celebrity, or no celebrity if there is no celebrity 1: for each S do 2: for each S {} do 3: if knows then 4: break out of inner loop 5: else 6: 7: for each α in S do 8: if α does not know then 9: return no celebrity 10: return This algorithm runs in O(n 2 ) time. an we do better? Yes, we can. The following algorithm is based on the observation that by asking a single question, we can eliminate a person as a possible celebrity. So, if I ask oes know? and the answer is no, then cannot be a celebrity, because a celebrity must be known by everybody else. On the other hand, if the answer is yes, then cannot be a celebrity because a celebrity knows nobody. Therefore, with a single question oes know?, we learn something no matter what the answer to the question is. This leads to this algorithm: ELERITY(S) Input: set S of n people Output: a celebrity, or no celebrity if there is no celebrity 1: andidates = S 2: while andidates > 0 do 3: choose and, such that andidates and andidates 4: if knows then 7 pril 2009 aron G. ass 1

2 5: andidates = andidates {} 6: else 7: andidates = andidates {} 8: Let be the only remaining element of andidates 9: for each α in S {} do 10: if α does not know or knows α then 11: return no celebrity 12: return The first loop here runs n 1 times because every time around the loop we eliminate a possibility (and we stop when there is one possibility left). The second loop runs for n 1 times also because we let α take on S 1 different values. Therefore the overall running time is in O(n). WHT IS N LGORITHM? Problem lgorithm Input "omputer" Output n algorithm is a description of an unambiguous sequence of operations that take any valid input and produce correct output: unambiguous The description must be clear to the reader. sequence of operations The description must make clear what order the operations should be carried out in. This could be a step-by-step description, but can also include things like loops, procedure calls, etc... any valid input If the algorithm does not produce correct output for all inputs, it is not a correct algorithm. correct output Of course, the algorithm should describe how to produce correct output. EULIEN TRVELLING SLESPERSON (ETSP) Problem: Find a minimal-length tour (cycle) of a set of points in the plane. Input: Set S of n points in the plane ((x, y) pairs) Output: Permutation P of points from S such that tour P 1, P 2, P 3,..., P n, P 1 has total cost no more than any other tour of the points in S. NEREST NEIGHOR ETSP The first algorithmic idea that comes to mind for solving ETSP is one where we 1) pick a starting point and then 2) keep finding the next closest point to continue our path: NERESTNEIGHORETSP(S) Input: set S of n (x, y) points Output: permutation of S representing the best tour of S 1: pick and visit a point p o S 2: i 0 7 pril 2009 aron G. ass 2

3 3: while there are unvisited points do 4: i i + 1 5: select p i closest unvisited point to p i 1 6: visit p i 7: return p o, p 1, p 2,..., p n 1 This algorithm is easy to understand, efficient (O(n 2 )), and easy to implement. Unfortunately, it does not work. To show this, we only need to look at one counter-example: Note that the algorithm does not say where to start, so as the adversary we can choose where to start such that we get an incorrect answer. In this example, if we start at the point in the upper-left corner, the algorithm produces the tour shown on the left. However, the tour shown on the right is clearly better. Here s another case where the algorithm fails. gain, we choose to start in the middle because that makes things worse Note that, again, the algorithm does not specify what to do when two points are equidistant from our current point. In this example, we choose to break the tie in the way that causes the most back-tracking. learly, the optimal solution to this instance of the problem should be to start at one end (say, the left) and visit each point from one end to the other (say, from left to right). The solution our algorithm gives is much worse than this. STRTING T THE LEFT, MOIFIE NEREST NEIGHOR ETSP ased on the previous example, we had the idea that maybe we should start at the left-most point so that we avoid the trouble. However, that also doesn t work, as shown in this example, which is the same as the previous example, except 1) it s turned on it s side and 2) an extra point is added to force the algorithm to start near the middle: 7 pril 2009 aron G. ass 3

4 LOSEST PIR ETSP In the Nearest Neighbor algorithm, we always have a single partial path. We start with a single node and then add to the path at one end. Here s an algorithm that instead tries to choose short edges for the tour, but it does not keep a single partial path at all times: LOSESTPIRETSP(S) Input: set S of n (x, y) points Output: best tour of S 1: n S 2: for i 1 to n 1 do 3: d infty 4: for each pair (x, y), where x and y are endpoints from different partial paths do 5: if dist(x, y) d then 6: x m x 7: y m y 8: d dist(x, y) 7 pril 2009 aron G. ass 4

5 9: connect x m and y m by an edge 10: connect endpoints by an edge to complete tour 11: return the tour The inner for loop finds the pair of points that s closest to each other, as long as the two points are endpoints of partial paths. If we didn t restrict ourselves to endpoints, we could create a branching tour (which isn t really a tour). Unfortunately, this algorithm doesn t work either. Here are some counterexamples: In this example, we consider four points, three in a line and one above that line, as shown in the top of the figure. The optimal solution is shown at the bottom of the figure, with length: Our algorithm produces the tour in the middle, with length In this example, we have eight points close to each other on an arc, with another point far away from those points. ecause the points on the far left are further apart than the ones a little bit to their right, the ones to the right are connected first. y the time we have connected the eight points on the left, the furthest left points are the end-points of their partial path. Therefore, the far away point must be connected to those points, even though a shorter tour can be had by connecting it to the closer points. 7 pril 2009 aron G. ass 5

6 In this example, the six points are in a simple grid, with the rows closer together than the columns. ecause the rows are closer, the three vertical edges are created first. Then, we have a choice for the fourth edge. However, once the fourth edge is added, the fifth one must be the one diagonally opposite it (the other possible edges do not connect points that are end-points of different partial paths). learly, the solution our algorithm arrives at (the top figure) is worse than the optional solution (on the bottom). NP-OMPLETE PROLEMS The NP-omplete problems are a set of problems for which there is no known polynomial time algorithm. version of ETSP is one such problem, so no known polytime algorithm is known for ETSP. It s possible there is a polynomial time algorithm, but most people think that it doesn t work. So, right now, the best known algorithm for ETSP is one where each permutation is computed to choose the best one. While this algorithm runs in O(n!) time, this is the best known algorithm at this time. GRPH PROLEMS ETSP is a special version of the general travelling salesperson problem defined for weighted, undirected graphs: Given a weighted undirected graph, find the tour of the nodes in the graph with minimal total edge weight. In order to understand this, we must understand what a graph is. Here we will introduce the basic terminology of graphs please see ppendix of your text [1] for more. graph G = (V, E) is a set of vertices V and a set of edges E that connect them. Each edge e in E is a pair of vertices (x, y), where x V and y V we say that the vertices x and y are connected by the edge (x, y). We usually draw graphs by creating a labelled circle for each vertex and drawing a line connecting two circles if the two corresponding vertices are connected in the graph. For example, G = (V, E), where V = {,,, } and E = {(, ), (, ), (, ), (, )} is drawn like so: 7 pril 2009 aron G. ass 6

7 In this graph, we say that is connected to. We also say that is connected to because this is an undirected graph the edges do not have a defined direction. On the other hand, a directed graph has edges that are not symmetric, and are usually drawn with arrow-heads at the ends of the line segments that connect circles. For example, G = (V, E), where V = {,,, } and E = {(, ), (, ), (, ), (, ), (, )}, is shown below: Note that an edge connects to, but no edge connects to. lso note that both (, ) and (, ) exist in the edge set and are drawn as one edge with two arrowheads in the diagram. weighted graph is a set of vertices, a set of edges connecting vertices, and a weight function that maps pairs of vertices to real numbers. onsider the following weighted undirected graph: Formally, this graph is G = (V, E, ω), where V = {,,, }, E = {(, ), (, ), (, ), (, )}, and ω is defined as: 4 if x = and y = 8 if x = and y = ω(x, y) = 3.2 if x = and y = 5 if x = and y = otherwise Note that any of these graphs can have self-loops edges from a node to itself. REPRESENTTION OF GRPHS There are two common ways of representing graphs. In an adjacency matrix representation, an n-node graph is represented by an n n oolean matrix, where a cell (x, y) in the matrix has a value true if and only if there is an edge between the vertices x an y in the graph. For example, for the graph shown here: The adjacency matrix is: 7 pril 2009 aron G. ass 7

8 F T F F T F T T F T F T F T T F Note that for a weighted graph, you also need a matrix that gives the edge weights for each pair of vertices. The other common representation is to use adjacency lists, where for each vertex, we keep a linked-list of its adjacent vertices. So, the same graph shown above has the following adjacency list: Note that in both of these representations, edges in undirected graphs are represented by two directed edges in the representation. So, there is an entry in the adjacency list for vertex and also an entry in the adjacency list for vertex. lso note that adjacency lists use space efficiently for sparse graphs, little space is used because the representation does not represent non-edges. On the other hand, determining whether two vertices are connected can be done in constant time using an adjacency matrix, but requires a linear search if we use adjacency lists. RUNNING TIME NLYSIS In running time analysis, we count basic operations and then use big-o notation to classify the function that describes that count. For example, for problems with input size n, we might say that one algorithm solves it in O(n) time while another one solves it in O(n log n) time. From previous courses, we have an informal notion of big-o, but let s give a formal definition: EFINITION OF IG-O f(n) O(g(n)) n 0 0, c > 0 : n n 0 : f(n) c g(n) This defines a set of functions that are all related to g(n) in this way (though they may have different constants n 0 and c). Note that n 0 and c are constants in this definition. You can only say that f(n) O(g(n)) if you can find constants that make this true, no matter what values of n someone tries. asically, this says that, above some threshold, f(n) is bounded by a constant factor of g(n), no matter how big n gets. The definition does not say anything about how the functions compare below the threshold. Note also that the definition does not say specifically what constants n 0 and c make this true it only says that such constants exist. Here s a graphical representation of this definition. Note that in this diagram I m showing f(n) above c g(n) for n less than n 0. Remember, though, the definition does not say anything about f(n) below n 0. 7 pril 2009 aron G. ass 8

9 c g(n) f(n) n 0 When f(n) O(g(n)), you will hear people say: f is bounded above by g. f is bounded above by a constant factor of g. f grows no faster than g. EFINTION OF IG-Θ Here s the analogous definition of big-θ, which is used to talk about tight asymptotic bounds, where we know not just an upper bound, but also a lower bound: EFINITION OF IG-Ω f(n) Θ(g(n)) n 0 0, c 1 > 0, c 2 > 0 : n n 0 : c 1 g(n) f(n) c 2 g(n) Here s the analogous definition for big-ω, which we use for lower-bounds. f(n) Ω(g(n)) n 0 0, c > 0 : n n 0 : f(n) c g(n) REFERENES [1] Thomas H. ormen, harles E. Leiserson, Ronald L. Rivest, and lifford Stein. Introduction to lgorithms. The MIT Press, second edition, pril 2009 aron G. ass 9