search problems and search techniques suranga hettiarachchi computer science department university...

Search Problems and Search Techniques

Suranga Hettiarachchi

Computer Science Department

University of WyomingGraduate Student Symposium, Spring 2004

Outline

We will investigate problems where a path is the solution, and problems where the goal state is the solution.

We will use traditional search (depth-first, breadth-first, and A*) as well as newer techniques (evolutionary algorithms) to solve these problems.

Terminology

Search Space: The set of possible candidate solutions (all the problems except path problems).

State: snapshot of data at a particular time. A node/vertex is the representation of a state in a search tree

Operator: transition from one state to another by modifying the data. A directed edge/arrow is the representation of a state-to-state transition (i.e., an operator or action having been applied) in a search tree.

Search strategy: the order in which you will traverse the states in the search space by choosing the operator(s).

A solution: either a goal state or a path from the start state to the goal state

Pruning: Eliminating states along the search. Done when it’s determined that it’s pointless to search further on a certain path. Symbol ‘// ‘ represents pruning in this lecture.

Taxonomy of Problems

Path problems• Missionary/Cannibal• 8 Puzzle

Goal state problems1. Combination problems

1. 0/1 Knapsack [Optimization problem]2. Boolean Satisfiability [Decision problem]

2. Permutation problems1. N Queen [Decision problem]2. TSP [Optimization problem]

Path problems

Missionary/Cannibal

8 Puzzle

Note: Consider search space as all the states in the

search tree.

Missionary-Cannibal Problem

Three missionaries and three cannibals come to a river. There is a boat on their side of the river that can be used by either one or two persons. How should they use this boat to cross the river in such a way that cannibals never outnumber missionaries on either side of the river?

Characteristics of the Problem

Solution to this problem is a path in the search tree.

We know the start state and the goal state

Search space is not extremely large

Missionary-Cannibal Problem Representation

Represent a state with a 3 element structure.

|Search Space| = 4 X 4 X 2 = 32

Start State : {3, 3, L} Goal State : {0, 0, R}[numbers represent the number of missionaries and

cannibals on the left side of the river]

Side of the boat

Number of cannibals

Number of missionaries

{0,1,2,3} {0,1,2,3} {L, R}Possible values

Missionary-Cannibal ProblemSolution

{0,0,R}

goal

{1,1,L}{0,1,R}{0,3,L}

{0,2,R}{2,2,L}{1,1,R}{3,1,L}

{3,0,R}{3,2,L}{2,2,R}{3,3,L} start

Missionary-Cannibal ProblemSearch Strategy

Operators :Move 2 missionaries, if there is 2 or more

missionaries.Move 2 cannibals, if there is 2 or more cannibalsMove 1 missionary, if there is 1 or more

missionaries.Move 1 cannibal, if there is 1 or more cannibals.Move 1 missionary and 1 cannibal, if there is 1 or

more of both. Location of the boat always alternates between

Left and Right, and Boat does not move by itself.

Missionary-Cannibal ProblemPartial Search Tree

{3,3,L}

{1,3,R} {3,1,R} {2,3,R} {3,2,R} {2,2,R}

// //

Prune if there are more cannibals thanmissionaries, but do not prune if there areno missionaries

{3,3,L} {3,2,L} {3,2,L} {2,3,L} {3,3,L}

////

\\

prune repeating sates

{1,2,R} {3,0,R} {2,2,R} {2,2,L} {2,1,R}

\\\\\\

Missionary-Cannibal Problem – BFS Solutions

PATH 0 (3,3,L)(3,1,R)(3,2,L)(3,0,R)(3,1,L)(1,1,R)(2,2,L) (0,2,R)(0,3,L)(0,1,R)(1,1,L)(0,0,R)

PATH 1 (3,3,L)(3,1,R)(3,2,L)(3,0,R)(3,1,L)(1,1,R)(2,2,L) (0,2,R)(0,3,L)(0,1,R)(0,2,L)(0,0,R)

PATH 2 (3,3,L)(2,2,R)(3,2,L)(3,0,R)(3,1,L)(1,1,R)(2,2,L) (0,2,R)(0,3,L)(0,1,R)(1,1,L)(0,0,R)

PATH 3 (3,3,L)(2,2,R)(3,2,L)(3,0,R)(3,1,L)(1,1,R)(2,2,L) (0,2,R)(0,3,L)(0,1,R)(0,2,L)(0,0,R)

Application

Lessons Learned

Due to the simplicity of this problem, and the possibility of effective pruning, BFS is an acceptable search strategy.

BFS will give us the optimal solution path(s) for this problem.

Now let’s look at a harder problem.

Eight Puzzle Problem

Given a start state, how to get to the goal state?

(Start State) (Goal State) Represent the board in a 3X3 matrix and the

blank square with -1.

126

705

-134

-176

543

210

Characteristics of the Problem

The search space is reasonably large.

Best representation I could comeup with is a 3 X 3 matrix, so wecannot improve the representation for better performance.

There are two classes of states in this problem

A* algorithm is a better algorithm to solve this problem compared to DFS.

181440 181440

Two Classes of States

Eight Puzzle Problem

Represent the board in a 3X3 matrix or a 9 element vector.

Operators :Move blank upMove blank downMove blank leftMove blank rightSize of the Search Space = 9! = 362880

Structure of A* for 8-Puzzle

Idea : Avoid expanding nodes that will be expensive.

Heuristic function : estimates the cost of the path from the current state to the closest goal state.

Maintain a Queue with nodes in a sorted order by cost.

Lower cost nodes kept in the front of the queue, and higher cost nodes are kept at the end of the queue.

A* Terminology

f(n): evaluation function of A*, estimated total cost of the cheapest solution path through node n, as a measure of the merit of node n. f(n) = g(n) + h(n)

g(n): path cost from start node to node n.

h(n): estimated cost of path from n to the closest goal node.

Heuristic Functions

Algorithm 1h1(n) = total Manhattan distance (i.e.,

number of squares from the desired location of each tile).

Algorithm2h2(n) = Number of tiles out of place.Algorithm3h3(n) = 0 : uniform cost search, regular

BFS.

h3<=h2<=h1<=h*(true minimal cost)

Results of Three Algorithms

Algorithm 1 : h1(n)Number of moves to goal : 22Nodes expanded : 245Time taken to find the goal : 0.07 seconds [average over 3

runs]

Algorithm 2 : h2(n)Number of moves to goal : 22Nodes expanded : 6126Time taken to find the goal : 27.23 seconds [average over

3 runs]

Algorithm 3 : h3(n)Number of moves to goal : 22Nodes expanded : 155507Time taken to find the goal : 3141.04 seconds [average

over 2 runs]

0.07 27.23

3141.04

0

500

1000

1500

2000

2500

3000

3500

Time (Seconds)

h(1) h(2) h(3)

Heuristic Function

Difference In Times For The Three Heuristics

Time for Heuristic

Eight Puzzle ProblemSolution Using A* - Algorithm1

0 1 2

3 4 56 7 -1 cost = 22

0 1 2

3 4 -16 7 5 cost = 22

0 1 -1

3 4 26 7 5 cost = 22

0 -1 1

3 4 26 7 5 cost = 22

-1 0 1

3 4 26 7 5 cost = 22

3 0 1

-1 4 26 7 5 cost = 22

3 0 1

4 -1 26 7 5 cost = 22

3 0 1

4 7 26 -1 5 cost = 22

3 0 1

4 7 26 5 -1 cost = 22

3 0 1

4 7 -16 5 2 cost = 22

3 0 -1

4 7 16 5 2 cost = 22

3 -1 0

4 7 16 5 2 cost =22

3 7 0

4 -1 16 5 2 cost =22

3 7 0

4 5 16 -1 2 cost = 20

3 7 0

4 5 16 2 -1 cost = 20

3 7 0

4 5 -16 2 1 cost = 20

3 7 -1

4 5 06 2 1 cost = 20

3 -1 7

4 5 06 2 1 cost =20

-1 3 7

4 5 06 2 1 cost = 20

4 3 7

-1 5 06 2 1 cost = 20

4 3 7

5 -1 06 2 1 cost = 20

4 3 7

5 0 -16 2 1 cost = 18

4 3 -1

5 0 76 2 1 cost = 0

Lessons Learned

A* is actually a better algorithm to solve this problem, if a good h(n) is used.

When h(n) = 0 (algorithm 3), A* becomes BFS because it expands and explores all the nodes.

Better heuristic improves both the time and space requirements.

A* always finds the optimal path given an admissible heuristic.

Combination Problems

Boolean Satisfiability [Decision Problem]

1. 0/1 Knapsack [Optimization Problem]

Boolean Satisfiability Problem

As an example, given an expression F(X) in conjunctive normal form, with three Boolean variables, find the truth assignment for each variable Xi for all i=1 through 3 such that F(x) = True.

~Xi is the negation of Xi

Expression may look like: (AND (OR X1 X2 ~X3) (OR ~X1 X3 ))

Variation of SAT 3-SAT Problem

3-SAT has the same form as SAT presented earlier, but each clause has the form (OR X1 X2 ~X3). The goal is to find any assignment to the Boolean variables such that expression evaluates to true. There are N Boolean variables and M clauses in the expression.

Characteristics of the Problem

All the variations of SAT could be represented the same way.

Number of clauses in the problem does not affect the representation because the representation is based on the number of variables in the expression.

We may or may not be able to satisfy the expression.

Boolean Satisfiability Problem Representation

A bit vector with Six elements (for example)

So there are 26 possible candidate solutions, each element corresponds to a variable in the problem, so there are 2N possible candidate solutions in the general problem.

Start State vector, unknown elements

Candidate State each element contains 1 or 0

Operator: Assign truth value 1 or 0 to a variable

??????

110110

Boolean Satisfiability Problem Search Strategy

( )

( 1 ) ( 0 )

( 11 ) ( 10 ) ( 01 ) ( 00 )

( 111 ) ( 110 ) ( 1 01) ( 100 ) ( 011 ) ( 010 ) ( 001 ) ( 000 )

Leaf nodes represents a set of candidate solutions. Number of candidate solutions in the tree = , where k is the number of variables.

Boolean Satisfiability Problem Results Using DFS

Number of Variables = 100Number of Clauses = 400{AND (OR -48 43 76 ) (OR 99 -56 67 ) (OR -99 -19 -42 ) (OR 11 -43 -97 ) (OR -77 14 -86

) (OR 90 -65 57 ) (OR 49 -73 -33 ) (OR 14 -86 -77 ) (OR -34 37 -82 ) (OR -77 91 -57 )

(OR -4 -51 -26 ) (OR 65 -16 -2 ) (OR -73 9 1 ) (OR -8 55 -92 ) (OR -15 -50 -19 ) (OR 15 99 -59 ) (OR -74 -93 1 ) (OR 8 -20 33 ) (OR 66 -22 -88 ) (OR 57 33 90 ) ………………..

……………….. (OR 53 93 20 ) (OR -62 99 80 ) (OR 56 -38 46 ) (OR -72 -86 -75 ) (OR -21 94 -33 ) (OR -89 -6 67 ) (OR -53 -67 83 ) (OR -32 -86 -14 ) (OR -33 3 31 ) (OR 14 -2 97 ) (OR -13 19 28 ) (OR 51 -52 49 ) (OR 87 -87 65 ) (OR 90 -3 -67 ) (OR 96 88 -6 ) (OR 47 7 -29 ) (OR 88 31 -25 ) (OR 85 -14 -47 ) (OR 36 -4 -47 ) (OR 56 -88 33 ) (OR 18 -62 33 ) }

Best results achieved1 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 1 0 0 0 1 0 1 1 0 1 1 1 0 0 1

0 0 0 0 1 1 1 0 1 0 0 1 1 0 0 1 1 0 0 0 1 1 0 0 0 0 0 0 1 1 1 0 1 1 0 1 1 0 1 0 1 1 1 0 0 1 1 0 1 1 0 0 0 1 1 1 1 1 0 1 0 1 1 0 1 0 1 1 0

Number of Clauses Satisfied = 370 [3600 seconds]

Pruning Strategy for SAT

Any one of the states in our search tree may be a candidate solution, because just a single variable occurring in all of the clauses may satisfy the expression. Every state should be evaluated and decided upon whether to continue in that path or not.

Also, a clause that evaluates to false with any state of the search tree will not satisfy the expression hence we prune the search.

Lessons Learned

DFS is a better search strategy for this problem than BFS, because we are only looking for a single solution, which could be any of the states.

However, it didn’t solve this particular problem – the search space is too large.

Let’s look at an alternative approach.

EA Philosophy

Candidate Solutions in Traditional Search(Individual)

Populationfitnes

s

Search Space

EA Terminology

Representation: an individual, typically a candidate solution in traditional search.

Initial Population: set of individuals, a fixed population size

Evaluation Function: evaluate the fitness of an individual for survival in the environment.

Selection Procedure: who can produce offspring.

Reproduction: generation of offspring from selected parents. Apply variation operators like crossover and mutation.

Unlike DFS and BFS, EAs are not exhaustive search – they are sound but not complete.

Outline of an EA

Set up initial population of candidate solutions.

Evaluate initial population.Generate successive generations of

populations by:Parent selection;Generate children via:

Crossover (recombination);Mutation;

Evaluate fitness of children;Decide which individuals survive;

Repeat generations until termination criterion satisfied.

genetic operators

Boolean Satisfiability Problem

Assume a SAT with 100 variables and 400 clauses.An individual is a bit vector with 100 elements, each

element is a 1 or a 0.Initial Population contains 300 individuals with randomly

allocated bit values.Evaluation function is to count how many clauses are

True. Maximize the number of True clauses, because making all the clauses True will make F(x) = True.

Selection procedure: modified (μ,λ) method. Ex: generate k new individuals from each μi,so then chose the fittest μ individuals from λ.

Reproduction could be accomplished by performing 1-point or N-point crossover on two (or more) randomly chosen parents. Occasional mutation or flipping a randomly chosen bit with a very small probability may generate better individuals.

Results for 3-SAT from EA

Number of Variables = 100Number of Clauses = 400Partial Expression

{AND (OR -48 43 76 ) (OR 99 -56 67 ) (OR -99 -19 -42 ) (OR 11 -43 -97 ) (OR -77 14 -86 ) (OR 90 -65 57 ) (OR 49 -73 -33 ) (OR 14 -86 -77 ) (OR -34 37 -82 ) (OR -77 91 -57 )

(OR -4 -51 -26 ) (OR 65 -16 -2 ) (OR -73 9 1 ) (OR -8 55 -92 ) (OR -15 -50 -19 ) (OR 15 99 -59 ) (OR -74 -93 1 ) (OR 8 -20 33 ) (OR 66 -22 -88 ) (OR 57 33 90 ) ………………..

……………….. (OR 53 93 20 ) (OR -62 99 80 ) (OR 56 -38 46 ) (OR -72 -86 -75 ) (OR -21 94 -33 ) (OR -89 -6 67 ) (OR -53 -67 83 ) (OR -32 -86 -14 ) (OR -33 3 31 ) (OR 14 -2 97 ) (OR -13 19 28 ) (OR 51 -52 49 ) (OR 87 -87 65 ) (OR 90 -3 -67 ) (OR 96 88 -6 ) (OR 47 7 -29 ) (OR 88 31 -25 ) (OR 85 -14 -47 ) (OR 36 -4 -47 ) (OR 56 -88 33 ) (OR 18 -62 33 ) }

Variable assignment: 1 1 1 0 0 0 0 1 1 0 1 1 1 1 1 0 1 1 0 0 0 0 1 1 0 1 0 1 0 1 0 0 0 0 1 1 1 1 1 0 0 1 0 1 0 0 0 0 1 1 0 0 1 1 0 1 1 1 0 1 1 0 1 1 1 0 0 0 1 1 0 1 1 0 0 1 0 1 1 1 1 1 1 1 1 0 0 1 0 1 1 0 0 0 1 0 1 1 1 1

Fitness : 400 [240 seconds][ 15 Times better than DFS]

Satga.exe

Observation of 3-SAT from EA

Satisfiability Based on Clauses/Variable Ratio

0

0.2

0.4

0.6

0.8

1

1.2

2.5 3 3.5 4 4.1 4.2 4.3 4.5 4.6

Ratio

sa

tis

fie

d/n

ot

sa

tis

fie

d

solut ion

0/1 Knapsack Problem

There are N objects and each object has a weight and a value. There is a maximum amount of weight the knapsack can hold. Find the set of objects that maximize their value, while staying below the weight constraint of the knapsack.

Characteristics of the Problem

Based on the number of objects in the problem, search space could become extremely large.

We need to know which objects we pick and which objects we don’t pick to maximize the value while staying below the weight limit.

As an example, consider the following.

0/1 Knapsack Problem

Assume there are 3 items and the maximum weight the knapsack can hold is 50.

Number of candidate solutions in n item general problem

Candidate solutions in our example =

12010060Value302010WeightObject3

Object2

Object1

0/1 Knapsack Problem – Search Tree

( ) Start state

( 10, 60 ) ( 0,0 )

object 1

( 30, 160 ) ( 10, 60 ) ( 20, 100 ) ( 0, 0 )

( 60, 280 ) ( 30, 160 ) ( 40, 180 ) ( 10, 60 ) ( 50, 220 ) ( 20, 100 ) ( 30, 120 ) ( 0, 0 )

object 2

Goal State

We can prune the paths that have the weights of a node exceeding the maximum weight a knapsack can hold. As an example (60,280) is not a solution to the problem. Since we are looking for an optimal solution we cannot prune the nodes with (0,0)

object 3

\\

0/1 Knapsack Problem – DFS Implementation Results

Number of objects = 20

Maximum weight of the Knapsack = 2.5 Objects that are picked (1) and not picked(0)0 0 1 1 0 0 1 0 1 0 1 1 0 1 0 0 1 0 1 0 Total Weight of the objects picked = 2.48 Total Value of the objects picked = 5.95

Number of objects = 100Maximum weight of the Knapsack = 12.5Best Results achievedTotal Weight of the objects picked = 12.4703 Total Value of the objects picked = 17.3843 [ 18000 seconds or 5hrs]

Data set (s) obtained from Dr. Terence Soule Department of Computer Science University of Idaho

http://www.cs.uidaho.edu/~tsoule/cs472/Knapsack.html

0/1 Knapsack Problem – DFS Implementation Results

Number of objects = 1000

Maximum weight of the Knapsack = 125.0Best Results achievedTotal Weight of the objects picked = 124.999Total Value of the objects picked = 134.414[18hrs]

Lessons Learned

For 0/1 Knapsack problem DFS is a better search strategy .

DFS will minimize the space requirement.

To find a candidate solution, we may need to reach the maximum depth of the search tree.

In larger search space, time requirement is very high.

0/1 Knapsack Problem with EAs

Assume a knapsack problem with 20 objects.An individual is a bit vector with 20 elements, each element

is a 1 or a 0.Initial Population contains 200 individuals with randomly

allocated bit values.Evaluation function: Individual with higher cumulative value

and cumulative weight of the objects which is still below the maximum weight of the knapsack has the a better chance to reproduce.

Selection procedure: modified (μ,λ) method. Ex: generate k new individuals from each μi,so then chose the fittest μ individuals from λ.

Reproduction could be accomplished by performing 1-point or N-point crossover on two randomly chosen parents. Occasional mutation or flipping a randomly chosen bit with a very small probability may generate better individuals.

Results

Number of objects = 20

Maximum weight of the Knapsack = 2.5 Objects that are picked (1) and not

picked(0)0 0 1 1 0 0 1 0 1 0 1 1 0 1 0 0 1 0 1 0

Total Weight of the objects picked = 2.48

Total Value of the objects picked = 5.95

(same as DFS)

Results

Number of objects = 100Maximum weight of the Knapsack = 12.5Objects that are picked (1) and not

1 0 1 0 1 0 1 0 1 0 0 0 0 0 1 0 0 1 1 0 1 1 1 0 0 1 1 1 1 0 1 0 0 1 1 0 0 1 1 0 0 0 1 1 1 1 0 0 1 0 0 0 1 0 0 1 0 1 1 0 0 0 1 1 1 0 0 0 1 0 1 1 1 1 0 1 0 1 0 1 1 1 1 0 0 0 1 0 1 1 1 1 1 0 0 1 1 0 0 0

Total Weight of the objects picked = 12.47 Total Value of the objects picked = 25.30 (compare with 17.38

with DFS)[1500 seconds or 25min, 12 Times better than DFS]

ResultsNumber of objects = 1000Maximum weight of the Knapsack = 125.0Objects that are picked (1) and not

0 1 0 0 1 1 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 1 1 0 1 1 0 0 1 1 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 0 0 0 0 0 1 0 1 0 1 0 0 1 1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 0 1 1 1 1 1 1 0 1 1 0 1 0 1 0 1 0 1 1 1 0 1 0 0 1 0 1 0 1 0 0 1 0 1 0 0 0 1 0 1 0 1 0 0 1 1 1 0 1 1 1 0 1 1 0 1 0 0 0 0 0 1 0 0 1 0 1 1 0 1 1 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 0 0 1 0 0 1 0 0 1 1 0 0 0 0 1 0 1 1 1 0 1 0 1 0 0 1 0 0 0 1 1 0 1 1 0 0 1 1 1 1 1 1 0 0 0 1 1 1 0 0 0 0 1 0 0 1 0 1 0 1 1 0 1 1 1 0 1 0 0 0 1 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 1 1 0 0 1 1 0 0 0 0 1 0 1 1 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 0 1 0 0 1 1 1 0 1 0 1 1 0 1 1 1 1 1 0 0 1 1 1 0 0 1 1 0 1 0 1 1 1 0 1 1 1 1 1 0 1 0 1 0 0 0 1 1 0 1 1 0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1 0 1 0 1 0 0 1 0 1 0 1 0 1 0 0 0 1 0 1 1 1 1 0 0 0 0 1 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 1 1 0 0 0 1 0 1 0 0 0 0 1 1 0 1 1 1 0 1 0 1 0 0 1 0 0 1 0 0 1 1 0 0 0 0 1 1 0 1 1 0 0 0 0 1 0 1 1 1 1 1 0 1 1 1 0 1 0 1 0 0 1 0 0 0 0 0 1 1 0 0 0 1 1 0 0 1 0 1 0 0 0 0 0 1 1 0 1 1 1 0 1 1 0 1 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 1 1 1 1 0 0 0 1 0 0 0 1 0 1 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 1 1 1 1 0 0 1 0 1 0 1 0 0 1 0 1 0 0 0 0 0 1 1 1 1 0 1 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 1 0 1 1 0 1 1 1 0 0 0 1 1 1 1 0 0 0 0 0 1 0 1 1 0 1 1 1 1 0 1 1 1 0 0 1 0 0 1 1 1 0 0 0 0 0 0 1 0 0 1 0 0 0 1 1 0 1 1 0 1 1 0 0 1 0 1 1 0 0 0 1 1 1 0 0 1 1 1 0 0 0 1 0 1 0 1 1 0 0 1 1 0 0 1 1 1 1 0 1 1 1 1 1 0 1 0 1 1 1 0 1 0 0 1 1 1 1 1 0 1 1 1 1 0 0 1 0 0 1 1 0 0 1 1 0 1 1 1 1 0 0 0 0 1 0 1 0 0 1 1 1 0 1 0 0 0 1 0 1 1 1 0 0 1 1 1 1 0 1 0 1 1 1 0 0 0 1 1 0 1 1 0 0 1 1 1 0 0 0 0 1 1 0 0 1 1 1 0 1 1 1 0 0 1 1 0 1 0 1 1 1 1 1 1 0 0 1 0 1 0 1 1 0 1 1 0 0 0 1 0 1 1 1 1 0 0 0 0 0 0 0 1 0 1 0 1 1 1 1 1 0 1 1 0 0 1 0 0 0 1 0 0 1 0 0 1 1 0 1 1 1 0 0 0 1 0 1 1 1 0 1 0 0 1 0 0 0 1 0 0 1 1 1 0 1 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 0 1 1 0 1 0 0 1 1 1 1 1 0 0 1 0 1 1 0 1 1 0 1 1 0 0 1 1 1 0 1 0 0 0 0 1

Total Weight of the objects picked = 124.82 Total Value of the objects picked = 257.06 [40min, 27 times better than DFS]

Lessons Learned

EA’s are easy to implement and produce results faster. Also EAs are not optimal or optimality is not provable.

Mutation is an insurance policy against premature loss of important subparts of a solution.

We have to be careful when deciding the size of the population; neither choosing extremely large population size nor choosing a very small population size will produce effective results.

It is difficult to avoid getting stuck in a local maxima; the only solution to this problem is a better selection strategy.

Permutation Problems

N Queen [Decision Problem]

1.TSP [Optimization Problem]

N Queens Problem

The N queens puzzle is the problem of putting N queens on an NxN chessboard such that none of them is able to capture any other. That is to say, no two queens should share the same row, column, or diagonal.

Characteristics of the Problem

The search space of the problem is very large, for large N.

Need to Explore the possibility of reducing the search space.

Smart representation may give us faster results.

Amount of space required to solve the problem could be extremely large, if all the states are expanded and explored.

Eight Queen Problem

To the right: board with all the eight queens on the board without any conflicts. This could also be shown in an eight element vector.

0 1 2 3 4 5 6 7

Index represents the rowElement represents the

column QQ

QQ

QQ

QQ

526 1

3704

Eight Queens Problem - Search space for 3 Different Representation

92 solutions

remove row conflicts

Remove column conflicts

remove diagonal conflicts

64 choose 8

8X8 board

88 = [16,777,216]

8 element vector –contains duplicates

8 element vector –no duplicates

8! = [40,320]

[4,426,165,368]

[ # of candidate solutions]

8 Queens ProblemDepth-first Search (DFS) Results

Results for the first implementation – 8 element vector with duplicates. Row conflicts are removed.

8 queensSolutions: 92Actual representation of a Solution in the output

file: Q E E E E E E E E E E E Q E E E E E E E E E E Q E E E E E Q E E E E Q E E E E E E E E E E E Q E E Q E E E E E E E E E Q E E E E

8 Queens Problem DFS Results

Results for the Second implementation – 8 element vector with no duplicates. Row and Column conflicts are removed.

Some Partial SolutionsBoard : [3 7 4 2 0 5 ] Queens :[1 6 ]Board : [3 7 4 2 0 5 1 ] Queens :[6 ]Board : [3 7 4 2 0 6 ] Queens :[1 5 ]Board : [3 7 4 2 0 6 1 ] Queens :[5 ]Board : [3 7 4 2 0 6 1 5 ] Queens :[ ] SolutionBoard : [3 7 4 2 5 ] Queens :[0 1 6 ]Board : [4 ] Queens :[0 1 2 3 5 6 7 ]Board : [4 0 ] Queens :[1 2 3 5 6 7 ]Board : [4 0 3 ] Queens :[1 2 5 6 7 ]Board : [4 0 3 5 ] Queens :[1 2 6 7 ]Board : [4 0 3 5 2 ] Queens :[1 6 7 ]Board : [4 0 3 5 7 ] Queens :[1 2 6 ]Board : [4 0 3 5 7 1 ] Queens :[2 6 ]Board : [4 0 3 5 7 1 6 ] Queens :[2 ]Board : [4 0 3 5 7 1 6 2 ] Queens :[ ] Solution

8 Queens Problem DFS Results

Results for Second implementation , Cont.

Some Solutions[ 6 4 2 0 5 7 1 3 ][ 7 1 3 0 6 4 2 5 ][ 7 1 4 2 0 6 3 5 ][ 7 2 0 5 1 4 6 3 ][ 7 3 0 2 5 1 6 4 ]Number of Solutions = 92

8 - 13 Queens Time Comparison on Two Previous Algorithms - Average Over 3 Runs

22791841233.72NA1

5

3655961

86.83NA1

4

737123

0.08103.5513

142005.231

7.1212

26800.993.3511

7240.20.6710

3520.050.229

920.010.048

SolutionsNo Row and Column ConflictsNo Row ConflictsQueens

Number of Queens Vs Algorithm Execution Time

050

100150200250300350400450500550600650700750800850900950

1000105011001150120012501300

8 9 10 11 12 13 14 15

Number of Queens

rowconflictsremoved

row andcolumnconflictsremoved

Number of Queens Vs Execution log(Time) for Two Algorithms

-3

-2

-1

0

1

2

3

4

8 9 10 11 12 13 14 15

Nimber of Queens

No Row Conflicts

No Raw and ColumnConflicts

Lessons Learned

DFS is a better algorithm to solve this problem because of less space requirement.

We could improve the performance of DFS based on the representation of a problem.

We could attempt to remove the symmetries as an another improvement.

It is impossible to come up with a representation that does not contain diagonal conflicts [then we don’t have a problem to solve].

With more than 30 queens, it is very hard for DFS to even come up with a single solution.

N Queens Problem with EAs

Assume N queens problem with 200 queens.An individual is a 200 element vector with natural numbers from

0 to 199. Initial Population contains 30 individuals with randomly

allocated integer values.Evaluation function would be to minimize the diagonal conflicts.

Since our implementation does not contain duplicate integers in the vector, there are no row or column conflicts.

Selection procedure: modified (μ,λ) method. Ex: generate k new individuals from each μi,so then chose the fittest μ individuals from λ.

Reproduction: you could only use mutation in N Queens problem, crossover is not possible since we should avoid duplicates to eliminate row/column conflicts.

Results for 200 Queens from EA

22 24 99 82 56 101 87 42 97 186 116 154 49 17 94 57 127 102 79 25 50 175 178 51 108 7 70 152 23 86 139 9 153 192 183 75 158 113 190 162 176 169 160 120 136 34 95 137 119 58 132 83 182 115 107 69 67 12 151 105 32 187 41 46 40 92 20 16 146 171 18 64 84 180 157 138 77 37 114 38 181 141 106 100 188 123 26 173 59 13 165 54 150 93 185 80 130 1 131 55 0 36 197 172 45 6 19 155 196 89 30 184 85 144 133 179 15 35 33 170 117 166 11 191 88 53 78 2 31 61 111 29 122 60 142 174 110 44 163 126 8 103 63 3 27 147 156 124 118 74 168 177 148 62 195 21 159 149 125 90 98 112 76 73 121 104 52 10 189 134 4 68 109 164 96 161 48 145 28 66 71 194 5 199 72 14 193 65 135 43 143 39 167 198 140 129 47 91 128 81

200,000 queens problem has been solved this way!Impossible with DFS!

Traveling Salesman Problem

There are N cities in a graph and there are roads from every city to every other city, which have costs associated with them. Find a “tour” that starts at some city, visits every other city once, ends back at the start city, and has the minimal cost.

Characteristics of Traveling Salesman Problem

A tour can be represented in two different ways for symmetrical TSP.

In symmetrical TSP for a pair of cities i, j cost (i, j) = cost (j, i)

Represent a tour in a N+1 element vector, last element to store the cost of the tour.

Candidate solutions are permutations of natural numbers from 1 to N.

Characteristics of Traveling Salesman Problem

Each number corresponds to a city to be visited in the sequence, so the search space = N!

In symmetrical TSP, shrink the search space by ½, so |s| = N! / 2

Since the tour could be the same regardless of the starting city, we can reduce the search space by N. So |s| = (N-1)! / 2

Traveling Salesman Problem Search Strategy

We implement the TSP similar to the second implementation of the N Queen problem.

Maintain Two vectors, one for the visited cities and one for the cities to be visited.

Visited [ 0 1 2 ] : To be visited [ 3 4 5 6 7] So we avoid producing duplicate cities in

the tour.The starting city does not change, so the

permutations always begin with the same city.

Traveling Salesman Problem Search Strategy

Either we use DFS or BFS, we have to do an exhaustive search.

We need to explore all the possible tours to find the minimum cost tour. Also all the solutions are at the leaf nodes at the maximum depth of the tree .

In DFS, we can prune partial tours, if the current partial tour cost already exceeds a previously found cost of a full tour.

Results for TSP Using DFS

Time is averaged over Three runs

Fifteen Cities

Results[ 0 5 1 14 2 6 3 8 11 12 4 9 13 10 7 ]best cost = 941Execution Time (hrs):0.6730560

Fourteen Cities

Results[ 0 5 8 3 2 6 13 12 4 9 1 10 11 7 ]best cost = 910Execution Time (hrs):0.1580560

Thirteen Cities

Results[ 0 5 6 2 4 9 10 1 12 11 3 8 7 ]best cost = 870Execution Time (hrs):0.0247222

Twelve Cities

Results[ 0 5 6 8 3 2 11 10 1 4 9 7 ]best cost = 837Execution Time (hrs):0.0072222

Eleven Cities

Results[ 0 5 7 10 1 6 9 4 2 3 8 ]best cost = 825Execution Time (hrs):0.002500

Ten Cities

Results[ 0 5 1 9 4 6 2 3 8 7 ]best cost = 718Execution Time (hrs):0.0003703

Nine Cities

Results[ 0 1 2 3 8 4 7 6 5 ]best cost = 631Execution Time (hrs):0.0002777

TSP Time Analysis for 9-15 Cities Using DFS

0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

9 10 11 12 13 14 15

Cities

Tim

e(hr

s)

TSP Time

Lessons Learned

Time taken to solve the problem grows exponentially with the number of cities.

DFS is chosen to solve this problem to minimize the space requirement.

To find a complete tour, algorithm has to reach the maximum depth of the search tree.

It is extremely difficult to solve this problem for 29 city TSP - the best path cost I got is 2790.

TSP with EAs Assume a TSP with 29 cities.An individual is a 29 element vector with natural

numbers from 0 to 28.Initial population contains 200 candidate tours that

are randomly initialized with natural numbers from 0 to 28.

Evaluation function is to minimize the cost of the tour. Only the tours with lower costs are fit to survive in the environment.

Selection procedure: modified (μ,λ) method. Ex: generate k new individuals from each μi,so then chose the fittest μ individuals from λ

Reproduction: you have to use mutation in TSP, crossover is not possible since we should avoid duplicate cities in the tour.

Results

Best results found so far for 29 city TSP using an EA.

Tour0 27 5 11 8 25 2 28 4 20 1 19 9 3 14 17 13 16 21 10 18 24 6 22 7

26 15 12 23 0

Cost of the tour 1610 (this is best known)

This was impossible with DFS that we discussed earlier.

END

Acknowledgement

Thanks to Dr. William Spears and Dr. Diana Spears for all the help. I appreciate all their guidance and advice. Thanks to Dr. Thomas Bailey for answering my questions and all his help through out this project. Also like to thank Ms. Nadezda Kuzmina for fixing the bug in N Queens program and Mr. Dimitri Zarzhitsky for helping me with this presentation.

Estimated total Cost Vs True Minimal Cost

h*(n) = the true minimal cost to goal node from n.

f*(n) : true minimal total cost of the cheapest solution path through node n.

g*(n) : true path cost from start node to node n. so g*(n) = g(n).

h(n) is an admissible heuristic if

A* with an Admissible Heuristic is Optimal

sG

n’

G’

Proof (by contradiction): Suppose optimal path isthe thick one shown in darker green, and the path found by A* with an admissible h function is the thin one shownin green, which is longer, i.e., A* terminates at a suboptimalnode G’. Let the green path deviate from the optimal path atnode n. Let f* be the optimal path cost...

with permission of Prof. Spears

n

Formal Proof of A*’s Optimality

Lemma: f(n) <= f*. [proved earlier]

Proof: f(n) = g(n) + h(n) [by definition]

= g*(n) + h(n) [A* has found optimal path to n]

<= g*(n) + h*(n) [h is admissible]

= f*(n) [by definition]

= f* [f* is the same for every node on optimal path]

with permission of Prof. Spears

Proof Cont.

f(n) >= f(G’) [A* terminates at G’ rather than

expanding n]

f* >= f(n) [lemma]f* >= f(G’) [consequence of above two facts,

transitivity]f(G’) = g(G’) [because h(G’)=0]f* >= g(G’) [consequence of above two facts]Contradicts that G’ is sub-optimal!Conclusion: A* cannot terminate at G’.

with permission of Prof. Spears