CS 312, section 003

Final Exam Format

Its a two part exam. The first part has 15 fill-in-the-bubble questions. The second part has 5 short essay answer type questions. There are no point values listed on the exam. The first 15 questions are worth 2 points each. The second set of 5 questions are worth 12 points each. So that's 30 points on the fill-in-the-bubble and 60 points on the essay type questions.

]]> If I were studying for the exam, I would be sure I knew...

How to solve recurrence relations
How to do linear programming and what slack form looks like
How to design algorithms and what the tradeoffs are between the different classes of algorithms we studied.
How the graph-based algorithms we studied work.
The stuff on the study lists for the other exams.

Important typo on the final exam

On the final exam, the question that asks you to put a linear programming problem into "basic form" should read "slack form" (Its problem 18)

Linear programming problem (due 4/13)

Here is the problem to solve with your linear programming project. The project is due the last day of classes. There will be no late days. The project is to turn this problem into a linear programming problem and then solve it with your simplex solver. You are free to use any input format you like and you are free to just hard-code the input right into your program if you like. This is the only problem your program will be tested on (but we will look at your source code to make sure your program isn't just "wait 2 seconds then return the solution").

You are the operations director for a processing plant at a large mine. Your job is to devise a program, or plan, for the plant that maximizes profits while staying within the resource budget. The plant produces four major resources: copper, gold, silver and platinum.

In a given week, the mine produces 2,000 tons of ore that must be processed into some combination of the four major resources. A ton of ore contains 10 ounces of copper, 2 ounces of gold, 3 ounces of silver and 1 ounce of platinum. You many only extract one resource from each unit of ore processed.

Processing the ore requires power, water, labor and use of one of the three processing lines. Producing each of the resources requires different amounts of processing resources. One ounce of copper requires 30 kW hours, 1,000 gallons of water, 50 hours of labor and 4 hours of processing time on a processing line. One ounce of gold requires 15 kW hours, 6,000 gallons of water, 20 hours of labor and 6 hours of processing time on a processing line. One ounce of silver requires 19 kW hours, 4,100 gallons of water, 21 hours of labor and 19 hours of processing time on a processing line. One ounce of platinum requires 12 kW hours, 9,100 gallons of water, 10 hours of labor and 30 hours of processing time on a processing line.

There is only a limited amount of power, water, labor and processsing line time available. In a given week, you may use 1,000 kW hours of power, 1,000,000 gallons of water, 640 hours of laber and you can run the processing lines 24 hours a day for 7 days a week for a total of 504 hours.

Finally, each ounce of finished resource has an associated profit. An ounce of copper is worth $10.20, an ounce of gold is worth $422.30 dollars, an ounce of silver is worth $6.91 and an ounce of platinum is worth $853.00.

TSP is due today, Monday 4/4

Just a reminder that the due date for the TSP project was moved to today. Be sure to turn something in (not neccesarily today) even if it is incomplete.

Notes on linear programming (updated 4/4)

The notes were updated to include implementation notes on page 10 on 4/4.

We have developed a set of notes on linear programming. The notes are complete, although I wouldn't be surprised if they were expanded as we cover them in class. The latest version will always be available here.

We will cover this material in class a little on Wednesday, all day Friday and Monday. The last project is to code up simplex and solve a little optimization problem.

More resources for learning linear programming

[a LP flash tutorial, notes on linear programming] The flash tutorial is quite nice, copmlete and slow. The notes are from Sean Warnick. They are also quite good.

Solutions posted

The solutions to the TSP premature cycle detection and edge inclusion/exclusion homeworks have been posted.

Scheduling for presentations

April 6 Rob and Doyle and Chris Hathaway and
April 8 Kawika and Andrew Harris and Ben Booth and Brad

Notes about TSP Algorithms

What to put in each node? 
-	Reduced matrix
-	lower bound
-	included edges
-	excluded edges 
How to generate children? 
-	one child for from �here� to every destination 
o	probably not a good idea. Queue gets too big too fast. 
-	Pick �here� and generate a child for the n closest cities.  N children per node. 
-	Include or exclude an edge to generate 2 children 
How to traverse the graph? 
	- best first search using a pruning function. 
A bounding function
	- the matrix reduction algorithm from Wednesday.
Way to generate initial solutions 
-	pick the smallest edge from A to X then smallest from X to next city (other than A) and so forth.  Then return to A. 
-	pick a permutation of the city list and try that. 
-	Its probably worth doing more than 1 of these trials, but not worth doing all the permutations. You have to find the sweet spot.  Well, in your improvement you can find it if that�s what you want to do. 

The algorithm. 

class node 
   members 
matrix matrix, bound bound, vector solution, 
Boolean optimal
etc; 
methods
	reduce // reduce the matrix and increase the 
bound accordingly. 
		NextEdgeToIncludeAndExclude 
// pick an edge that maximizes exclude child�s bound or some other strategy. 
		excludeCityEdge (i,j) 
// excludes the edge from i to j, re-reduces the matrix and increases the bound as needed. 
Algorithm tsp-bb (matrix M)
: (vector v, int cost, bool optimal) 
priorityQueue of nodes pq; 

// set up my bssf. 
node bssf;  // best solution so far. 
(bssf.vector, bssf.bound) = 
min (several different solutions);
bssf.matrix = M; 
bssf.optimal = false; 

// build initial node. 
inode.matrix = M; 
inode.bound = 0; 
inode.reduce(); 
pq.push (inode);  

while (!pq.empty) {
	if (time has expired) 
then bssf.optimal = false; 
  break; 
 	curnode = pq.pop (); 
	(i,j) = curnode.NextCityEdgeToIncludeAndExclude(); 
	node include = new node(curnode); 
	node exclude = new node(curnode); 
	exclude.excludeCityEdge (i,j); 
	include.includeCityEdge (i,j); 
	if (include.isASolution() 
&& include.bound < bssf.bound)
		updateBSSF (include); // set optimal = true.  
		pq.prune();  
	// the order here matters, and you can use an else 
	// to simplify the code. 
if (include.bound < bssf.bound) 
pq.push (include); 
	if (exclude.bound < bssf.bound) 
	pq.push (exclude);  
}
// return the bssf. 
return bssf

Class node (int,int) NextCityEdgeToIncludeAndExclude () 
	// one strategy is to minimize bound on include-child.
	For each (i,j) such that M[i,j] = 0 
		M� = copy of array M 
		Set row i = infinity and column j = infinity
		Set M�[j,i] = infinity 
		Difference = Reduce (M�) � bound 
		// another method� 
		If M[k,m] = 0 then
			Difference = min (row m) + min (column k) 
							Excluding M[k,m]. 
//Just a sketch.  Have fun and design your // own. 
Let i,j = M[i,j] so that we get the include and exlcude bounds we want.
// make sure there are no premature cycles. 
Use an array called �to� that tracks where you go �to� from city i. 
Write a for-loop to see if city i is connected to itself in less than n steps where n = # of cities. 
If i,j causes a premature them replace M[i,j} with infinity, reduce and try again.

An Access Database with more TSP Examples

A kind student has created an access database with more TSP examples

Warning: some lines have a preceeding space on their row definition and others do not.

The plan for the rest of the semester

We will wrap up the TSP algorithm today. Wednesday (3/30) we will do the minimax algorithm and start linear programing if time permits. Friday (4/1) we will go into linear programing in earnest and stick with that through the last day of class.
Linear programing is not in the textbook. A handout will be made available before 4/1. Linear programing is an important topic because it gives you another way to think about optimization problems and ties together most of hte ideas from the whole course.
The last project is to code up the simplex method. In linear programming problems, half the "fun" is coming up with the formulation of the problem as a linear program. So this project will be a little different. We will give you a constraint satisfaction problem and you will formulate it as a linear program, convert it to slack form, implement the simplex method and use your implementation to solve the slack form of your linear program. That will simplify the project a little while focusing on the main ideas.

Putting the TSP Algorithm Together

This is the algorithm so far. We will continue fleshing out the details on Monday. What to put in each node? - Reduced matrix - lower bound - included edges - excluded edges How to generate children? - one child for from �here� to every destination o probably not a good idea. Queue gets too big too fast. - Pick �here� and generate a child for the n closest cities. N children per node. - Include or exclude an edge to generate 2 children How to traverse the graph? - best first search using a pruning function. A bounding function - the matrix reduction algorithm from Wednesday. Way to generate initial solutions - pick the smallest edge from A to X then smallest from X to next city (other than A) and so forth. Then return to A. - pick a permutation of the city list and try that. - Its probably worth doing more than 1 of these trials, but not worth doing all the permutations. You have to find the sweet spot. Well, in your improvement you can find it if that�s what you want to do. The algorithm. class node members matrix matrix, bound bound, vector solution, Boolean optimal etc; methods reduce // reduce the matrix and increase the bound accordingly. NextEdgeToIncludeAndExclude // pick an edge that maximizes exclude child�s bound or some other strategy. excludeCityEdge (i,j) // excludes the edge from i to j, re-reduces the matrix and increases the bound as needed. Algorithm tsp-bb (matrix M) : (vector v, int cost, bool optimal) priorityQueue of nodes pq; // set up my bssf. node bssf; // best solution so far. (bssf.vector, bssf.bound) = min (several different solutions); bssf.matrix = M; bssf.optimal = false; // build initial node. inode.matrix = M; inode.bound = 0; inode.reduce(); pq.push (inode); while (!pq.empty) { curnode = pq.pop (); (i,j) = curnode.NextCityEdgeToIncludeAndExclude(); node include = new node(curnode); node exclude = new node(curnode); exclude.excludeCityEdge (i,j); include.includeCityEdge (i,j); if (include.isASolution() && include.bound < bssf.bound) updateBSSF (include); pq.prune(); // the order here matters, and you can use an else // to simplify the code. if (include.bound < bssf.bound) pq.push (include); if (exclude.bound < bssf.bound) pq.push (exclude); } ]]>

Avoiding premature cycles (due 3/30)

Answer the following questions:

What is a premature cycle?
Are premature cycles possible in the include/exclude formulation of the problem? That's the algorithm that picks an edge to include and exclude resulting in two new nodes.
Sketch an algorithm and accompnying datastractures for detecting premature cycles as they are formed.
Make sure you can detect premature cycles and that you can detect completed cycles too.

]]> Solution

The other questions are pretty straightfoward, here's a premature cycle detection algorithm...

array to of int[n]. // an array that lives in each nod.e 

is edge (x,y) ok to add? 
int here;
here = y;  // note that I didn't modify the "to" array. 
for (i = 1 ; i < n; i++)   // since I started at y (rather than x) I only go up to n-1 in a solution. 
    here = to[here]; 
    if (here == x) then return false // not ok to add x,y. 
return true // it is ok to add x,y.