1 / 30

Understanding Complexity: The Golden Ages and Sorting Algorithms

Explore the concept of "endless golden ages" in various fields and the complexities of permuted sorting. Delve into the impact of grade inflation, scale compression, and sorting problems. Gain insights into algorithm complexity classes and the workings of sorting procedures.

jeaniem
Download Presentation

Understanding Complexity: The Golden Ages and Sorting Algorithms

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 14: P = NP? David Evans http://www.cs.virginia.edu/~evans CS200: Computer Science University of Virginia Computer Science

  2. Menu • Golden Ages • Permuted Sorting • Complexity Classes CS 200 Spring 2002

  3. From Lecture 13: The Real Golden Rule? Why do fields like astrophysics, medicine, biology and computer science (?) have “endless golden ages”, but fields like • music (1775-1825) • rock n’ roll (1962-1973, or whatever was popular when you were 16) • philosophy (400BC-350BC?) • art (1875-1925?) • soccer (1950-1974) • baseball (1925-1950) • movies (1930-1940) have short golden ages? CS 200 Spring 2002

  4. Goal-den age Changed goalkeeper passback rule Average Goals per Game, FIFA World Cups

  5. Endless Golden Age and “Grade Inflation” • Average student gets twice as smart and well-prepared every 15 years • You had grade school teachers who went to college! • If average GPA in 1970 is 2.00 what should it be today (if Prof’s didn’t change grading standards)? CS 200 Spring 2002

  6. Grade Inflation or Scale Compression? 2.00 average GPA in 1970 (“gentleman’s C”?) * 2 better students 1970-1985 * 2 better students 1985-2000 * 2 admitting women (1971) * 1.54 population increase * 0.58 increase in enrollment Students 1970 11,000 Students 2002 18,848 (12,595 UG) Average GPA today should be: 14.3 CS200 has only the best of the best students, and only the best half of them stayed in the course after PS1, so the average grade in CS200 should be 14.3*2*2*2 = 114.3 CS 200 Spring 2002

  7. Permuted Sorting CS 200 Spring 2002

  8. Permuted Sorting • A (possibly) really dumb way to sort: • Find all possible orderings of the list (permutations) • Check each permutation in order, until you find one that is sorted • Example: sort (3 1 2) All permutations: (3 1 2) (3 2 1) (2 1 3) (2 3 1) (1 3 2) (1 2 3) is-sorted? is-sorted? is-sorted? is-sorted? is-sorted? is-sorted? CS 200 Spring 2002

  9. is-sorted? (define (is-sorted? cf lst) (or (null? lst) (= 1 (length lst)) (and (cf (car lst) (cadr lst)) (is-sorted? cf (cdr lst))))) Is or a procedure or a special form? CS 200 Spring 2002

  10. all-permutations (define (all-permutations lst) (flat-one (map (lambda (n) (if (= (length lst) 1) (list lst) ; The permutations of (a) are ((a)) (map (lambda (oneperm) (cons (nth lst n) oneperm)) (all-permutations (exceptnth lst n))))) (intsto (length lst))))) CS 200 Spring 2002

  11. permute-sort (define (permute-sort cf lst) (car (filter (lambda (lst) (is-sorted? cf lst)) (all-permutations lst)))) CS 200 Spring 2002

  12. > (time (permute-sort <= (rand-int-list 5))) cpu time: 10 real time: 10 gc time: 0 (4 14 14 45 51) > (time (permute-sort <= (rand-int-list 6))) cpu time: 40 real time: 40 gc time: 0 (6 29 39 40 54 69) > (time (permute-sort <= (rand-int-list 7))) cpu time: 261 real time: 260 gc time: 0 (6 7 35 47 79 82 84) > (time (permute-sort <= (rand-int-list 8))) cpu time: 3585 real time: 3586 gc time: 0 (4 10 40 50 50 58 69 84) > (time (permute-sort <= (rand-int-list 9))) Crashes! CS 200 Spring 2002

  13. (define (permute-sort cf lst) (car (filter (lambda (lst) (is-sorted? cf lst)) (all-permutations lst)))) How much work is permute-sort? • We evaluated is-sorted? once for each permutation of lst. • How much work is is-sorted?? (n) • How many permutations of the list are there? CS 200 Spring 2002

  14. Number of permutations (map (lambda (n) (if (= (length lst) 1) (list lst) (map (lambda (oneperm) (cons (nth lst n) oneperm)) (all-permutations (exceptnth lst n))))) (intsto (length lst))) • There are n = (length lst) values in the first map, for each possible first element • Then, we call all-permutations on the list without that element (length = n – 1) • There are n * n – 1 * (n – 1) – 1 * … * 1 permutations • Hence, there are n! lists to check: (n!) CS 200 Spring 2002

  15. Big-O Notation • O(x)– it is no more thanxwork (upper bound) • (x) – work scales as x (tight bound) • (x) – it is at leastxwork (lower bound) If we can find the same x where O(x) and (x) are true, then (x) also. CS 200 Spring 2002

  16. Procedures and Problems • So far we have been talking about procedures (how much work is permute-sort?) • We can also talk about problems: how much work is sorting? • A problem defines a desired output for a given input. A solution to a problem is a procedure for finding the correct output for all possible inputs. CS 200 Spring 2002

  17. The Sorting Problem • Input: a list and a comparison function • Output: a list such that the elements are the same elements as the input list, but in order so that the comparison function evaluates to true for any adjacent pair of elements CS 200 Spring 2002

  18. O, ,  for problems • The sorting problem is O(n log2n) since we know a procedure (quicksort) that solves it in (n log2n) • Does this mean the sorting problem is (n log2n)? No, we would need to prove there is no better procedure. For some comparison functions (e.g., (lambda (a b) #t)), there are faster procedures. For <=, this is true, but we haven’t proven it (and won’t in this class). CS 200 Spring 2002

  19. The Minimize Difference Problem • Input: two same-length lists, lsta and lstb; a difference function, diff, that operates on pairs of elements of the lists • Output: a list which is a permutation of lstb, such that the sum of diff applied to corresponding elements of lsta and the output list is the minimum possible for any permutation of lstb CS 200 Spring 2002

  20. Example > (minimize-difference (lambda (a b) (square (- a b))) (list 0 1 2 8) (list 6 4 5 3)) (3 4 5 6) CS 200 Spring 2002

  21. minimize-difference (define (minimize-difference diff lsta lstb) (cdr (find-most (lambda (p1 p2) (< (car p1) (car p2))) (make-difference-lists diff (all-permutations lstb) lsta)))) CS 200 Spring 2002

  22. (define (make-difference-lists diff plists tlist) (map (lambda (plist) (cons (sumlist (map (lambda (a b) (diff a b)) plist tlist)) plist)) plists)) Note: (map f lista listb) applies (f (car lista) (car listb)) … make-difference-lists (define (sumlist lst) (if (null? lst) 0 (+ (car lst) (sumlist (cdr lst))))) CS 200 Spring 2002

  23. How much work? • How much work is our minimize-differenceprocedure? There are n! lists to check, each takes n work: (n!) • If diff is a constant time ((1))procedure, and we don’t know anything else about it, how much work is the minimize difference problem? (n!) CS 200 Spring 2002

  24. How much work? • How much work is the minimize difference problem with – as the diff function? O(n!) we know we can to it with no more than n! work using minimize-difference But, is there a faster procedure to solve this problem? Yes! It is O(1): (define (minimize-sub-difference lsta lstb) lstb) CS 200 Spring 2002

  25. Have you seen anything like this? CS 200 Spring 2002

  26. Perfect Photomosaic Problem • Input: a set of tile images, a master image, a color difference function • Output: an ordering of a subset of the tile images that minimizes the total color difference function for each image tile and the corresponding square in the master image • How much work is finding a perfect photomosaic? n is the number of tiles (assumes same as number to cover master) O(n!) CS 200 Spring 2002

  27. Complexity Class P Class P: problems that can be solved in polynomial time O(nk) for some constant k. Easy problems like sorting, making a photomosaic using duplicate tiles, understanding the universe. CS 200 Spring 2002

  28. Complexity Class NP Class NP: problems that can be solved in nondeterministic polynomial time If we could try all possible solutions at once, we could identify the solution in polynomial time. Hard problems like minimize-difference, … (more examples Weds). Making the best photomosaic without using duplicate tiles (PS5) may be even harder! (Weds) CS 200 Spring 2002

  29. P = NP? • Is there a polynomial-time solution to the “hardest” problems in NP? • No one knows the answer! • The most famous unsolved problem in computer science and math • Listed first on Millennium Prize Problems • win $1M if you can solve it • (also an automatic A+ in this course) CS 200 Spring 2002

  30. Charge • PS4 Due Friday • Lab Hours: Mon 7-9pm, Thu 7-9pm • Wednesday: • What are the “hardest” problems in NP? • Friday: review for exam • Covers through lecture 13 (not today) CS 200 Spring 2002

More Related