Announcements NP-Complete Problems Decidable vs. Undecidable Problems Review

Review Outline at

Online Survey The Spring term course/instructor opinion survey will be available during the period Monday, April 17th through Friday, April 28th from 6am to 11:59pm each day: LB

Final Exam Schedule CS1311 Sections L/M/N Tuesday/Thursday 10:00 A.M. Exam Scheduled for 8:00 Friday May 5, 2000 Physics L1 LB

Final Exam Schedule CS1311 Sections E/F Tuesday/Thursday 2:00 P.M. Exam Scheduled for 2:50 Wednesday May 3, 2000 Physics L1 LB

NP-Complete Problems

Problems that Cross the Line What if a problem has: –An exponential upper bound –A polynomial lower bound We have only found exponential algorithms, so it appears to be intractable. But... we can’t prove that an exponential solution is needed, we can’t prove that a polynomial algorithm cannot be developed, so we can’t say the problem is intractable...

NP-Complete Problems The upper bound suggests the problem is intractable The lower bound suggests the problem is tractable The lower bound is linear: O(N) They are all reducible to each other –If we find a reasonable algorithm (or prove intractability) for one, then we can do it for all of them!

Example NP-Complete Problems Path-Finding (Traveling salesman) Map coloring Scheduling and Matching (bin packing) 2-D arrangement problems Planning problems (pert planning) Clique

Traveling Salesman

5-Clique

Map Coloring

Class Scheduling Problem With N teachers with certain hour restrictions M classes to be scheduled, can we: –Schedule all the classes –Make sure that no two teachers teach the same class at the same time –No teacher is scheduled to teach two classes at once

Certificates Returning true: in order to show that the schedule can be made, we only have to show one schedule that works –This is called a certificate. Returning false: in order to show that the schedule cannot be made, we must test all schedules.

Oracles If we could make the ‘right decision’ at all decision points, then we can determine whether a solution is possible very quickly! –If the found solution is valid, then True –If the found solution is invalid, then False If we could find the certificates quickly, NP- complete problems would become tractable – O(N) This (magic) process that can always make the right guess is called an Oracle.

Determinism vs. Nondeterminism Nondeterministic algorithms produce an answer by a series of “correct guesses” Deterministic algorithms (like those that a computer executes) make decisions based on information.

NP-Complete “NP-Complete” comes from: – Nondeterministic Polynomial – Complete - “Solve one, Solve them all” There are more NP-Complete problems than provably intractable problems.

Proving NP-Completeness Show that the problem is in NP. (i.e. Show that a certificate can be verified in polynomial time.) Assume it is not NP complete Show how to convert an existing NPC problem into the problem that we are trying to show is NP Complete (in polynomial time). If we can do it we’ve done the proof! Why? If we can turn an exisiting NP-complete problem into our problem in polynomial time...  LB

Become Famous! To get famous in a hurry, for any NP- Complete problem: –Raise the lower bound (via a stronger proof) –Lower the upper bound (via a better algorithm) They’ll be naming buildings after you before you are dead!

Questions?

Decidable vs. Undecidable Problems

Decidable Problems We now have three categories: –Tractable problems –NP-Complete problems –Intractable problems All of the above have algorithmic solutions, even if impractical.

Undecidable Problems No algorithmic solution exists –Regardless of cost –These problems aren’t computable –No answer can be obtained in finite amount of time

The Unbounded Tiling Problem What if we took the tiling puzzle and removed the bounds: –For a given number (T) of different kinds of tiles –Can we arrive at an arrangement that will fill any size area? By removing the bounds, this problem becomes undecidable.

The Halting Problem Given an algorithm A and an input I, will the algorithm reach a stopping place? loop exitif (x = 1) if (even(x)) then x <- x div 2 else x <- 3 * x + 1 endloop In general, we cannot solve this problem in finite time.

Partially and Highly Undecidable Most undecidable problems have finite certificates. These are partially decidable. Some undecidable problems do not have finite certificates even with an oracle. These are called highly undecidable.

A Hierarchy of Problems For a given problem, is there or will there ever be an algorithmic solution? ProblemIn Theory In Application Highly Undecidable NO NO Partially Undecidable NO NO Intractable YES NO Tractable YES YES

Questions?

Review Problems What is the Big O? i <- N j <- 1 loop exitif(i <= 0) loop exitif(j > M) j <- j + 1 endloop i < i - 1 endloop

Review problems Circle and Identify the 3 parts of recursion: Function Fact returnsa Num(N iot in Num) if(N = 0) then Fact returns 1 else Fact returns N * Fact(N - 1) endif endfunction // Fact

Review problems Circle and Identify the 3 parts of recursion: Function Fact returnsa Num(N iot in Num) if(N = 0) then Fact returns 1 else Fact returns N * Fact(N - 1) endif endfunction // Fact Check for termination Call self Move one step closer

Review Problems Recall that a leaf is a node in a binary tree with no children. Write a module that when passed a pointer to a binary tree will return the number of leaves. The module should use recursion

Leaves Function Leaves returnsa Num (current iot Ptr toa TNode) if(current = NIL) then Leaves returns 0 elseif(current^.left = NIL AND current^.right = NIL) then Leaves returns 1 else Leaves returns Leaves(current^.right) + Leaves(current^.left) endif endfunction // Leaves

Review Problems How many “time chunks” will be required to run this algorithm on 2 processors? S1 S4 S2 S5 S8 S3 S6 S9 S7 IIIIII

Review Problems S1 S4 S2 S5 S8 S3 S6 S9 S7 III

Review Problems Write a module to convert an unsorted linked list to a sorted linked list. Use data structure conversion as opposed to a sort algorithm such as Bubble Sort or Merge Sort

Review problems Algorithm Pain a,b,c iot Char a <- ‘b’ b <- ‘c’ c <- ‘a’ Agony(c,a,’b’) print(a,c,b) b <- funky(a,c) print(a,b,c) endalgorithm Procedure Agony(a iot in/out Char, b iot out Char, c iot in Char) t iot Char if(c = ‘c’) then c <- ‘d’ t <- b b <- a a <- t else b <- a a <- ‘b’ endif endprocedure Function funky returnsa Char (x,y isoftype in Char) if(x = y) then funky returns ‘a’ else finky returns ‘b’ endif endfunction

Review problems Write a vector class It should be generic and support (at least) the following methods in the public section AddToEnd AddAt(nth) Remove(nth) Size Get(nth)

class Vector(DT) public Procedure AddToEnd(din iot in DT) // PPP Procedure AddAt(nth iot in Num, din iot in DT) // PPP Procedure Remove(nth iot in Num) // PPP Function Size returnsa Num() // PPP Function Get returnsa DT(nth iot in Num) // PPP Procedure Initialize() // PPP

protected Node definesa record data iot DT next iot Ptr toa Node endrecord head isoftype Ptr toa Node count isoftype Num Procedure AddToEnd(din iot in DT) AddToEndHelper(head, din) endprocedure // AddToEnd

Procedure AddToEndHelper (cur iot in/out Ptr toa Node, din iot in DT) // PPP if(cur = NIL) then cur = new(Node) cur^.data <- din cur^.next <- NIL count <- count + 1 else AddToEndHelper(cur^.next, din) endif endprocedure // AddToEndHelper Procedure AddAt(nth iot in Num, din iot in DT) AddAtHelper(head, nth, din, 1) endprocedure // AddAt

Procedure AddAtHelper(cur iot in/out Ptr toa Node, nth iot in Num, din iot in DT,kount iot in Num) // PPP temp iot Ptr toa Node if(cur = NIL OR nth = kount) then temp <- new(Node) temp^.data <- din temp^.next <- cur cur <- temp count <- count + 1 else AddAtHelper(cur^.next, nth, din, kount + 1) endif endprocedure // AddAtHelper

Procedure Remove(nth iot in Num) RemoveHelper(head, nth, 1) endprocedure // Remove Procedure RemoveHelper(cur iot in/out Ptr toa Node, nth iot in Num, kount iot in Num) // PPP if(cur <> NIL) then if(nth = kount) then cur <- cur^.next count <- count - 1 else RemoveHelper(cur^.next, nth, kount + 1) endif endprocedure // RemoveHelper

Function Size returnsa Num() Size returns count endfunction // Size Function Get returnsa DT(nth iot in Num) Get returns GetHelper(head, nth, kount) endfunction Function GetHelper returnsa DT (cur iot in Ptr toa Node, nth, kount iot in Num) // Precon: User must not request item > Size ** // PP if(nth = kount) then GetHelper returns cur^.data else GetHelper returns GetHelper (cur^.next, nth, kount + 1) endif endfunction // GetHelper

Procedure Initialize() head <- NIL count <- 0 endprocedure // Initialize endclass // Vector

Review problems Use the generic Vector class you just wrote to write a baseball roster program. It should manage baseball player records consisting of –Name –Position It should support the following operations –Add a player –Remove a player –Add a player at position N –Print a roster (only if there are 9 players otherwise print an error message) Assume that the record is named Player Assume that you have modules called –Procedure GetPlayer(data isoftype out Player) –Procedure PrintPlayer(data isoftype in Player)

Procedure Menu(Choice iot out Num) print(“1-Add a player”) print(“2-Remove a player”) print(“3-Add a player at position N”) print(“4-Print a roster”) print(“5-Quit”) read(Choice) endprocedure // Menu Player definesa record Name iot String Position iot String endrecord // Player Procedure GetPlayer(data isoftype out Player) Procedure PrintPlayer(data isoftype in Player) TEAMSIZE is 9

Algorithm Roster uses Vector(DT) Team isoftype Vector(Player) // Make the Vector!!! Choice iot Num Loop Menu(Choice) exitif(Choice = 5) if(Choice = 1) then Add(Team) elseif(Choice = 2) then Remove(Team) elseif(Choice = 3) then AddAt(Team) elseif(Choice = 4) then PrntRoster(Team) endif endalgorithm // Roster

Procedure Add(Team iot in/out Vector(Player)) temp iot Player GetPlayer(temp) Team.AddToEnd(temp) endprocedure // Add procedure Remove(Team iot in/out Vector(Player)) i iot Num print(“Line number to remove?”) read(i) Team.Remove(i) endprocedure // Remove Procedure AddAt(Team iot in/out Vector(Player)) i iot Num temp iot Player print(“Enter at what line number”) GetPlayer(temp) Team.AddAt(i, temp) endprocedure // AddAt

Procedure PrntRoster(Team iot in/out Vector(Player))) i iot Num if(Team.Size() <> TEAMSIZE) print(“Wrong size team”) else i < 1 Loop exitif(i > TEAMSIZE) PrintPlayer(Team.Get(i)) i <- i + 1 endloop endif endprocedure // PrntRoster

Questions?