Exhaustive Search

Brute Force Methods

guarantee best fitness value is found feasible for ‘small’ data sets only

SAT satisfiability problem

set of propositions prop[n] fitness function

logical expression based on propositionsboolean fitness(prop)

try all 2n combinations of T/F for propositions

boolean fitness(boolean b[]) //fitness functionboolean [] prop = new boolean[n];boolean satisfied = sat(n-1);

boolean sat (int index) // find a solution{ if (index==0) //base case

{prop[0] = true;if fitness(prop) return true;prop[0] = false;return fitness(prop);

}prop[index] = true; // recursiveif (sat(index-1)) return true;

prop[index] = false;return sat(index-1);

} ...

..T ..F

.FT.TT .TF .FF

FFTFTT FTF FFFTFTTTT TTF TFF

2

1

0

...

efficiency without risk

pruning the tree: suppose fitness(prop) is

(p0 \/ ~p1) /\ (~p2)

partial evaluation

...

..T ..F

.FT.TT .TF .FF

FFTFTT FTF FFFTFTTTT TTF TFF

...

2

1

0

nodes can be ignored: fitness can not be true

TSP travelling salesman directed edges, complete graph:

exhaustive search is the permutation problem

enumerate all n! permutations of n distinct items (cities) {0,2,3,…,n-1}

1

2

0

3

ij 0 1 2 3

0 .

1 .

2 .

3 .

rank in path array

3 1 4 2

0 1 2 3D[i][j]

TSP travelling salesman O(nn)input(V) // number of cities (Vertices)

int[V] rIP // rankInPath, initialized to 0==not ranked

visit(1) // generate visiting sequences

void visit(int rank)

{ for (city = 0 to V-1)

if (rIP[city] == 0) // not yet visited

{ rIP[city] = rank;

if (rank == V) fitness(rIP)

else visit(rank+1)

rIP[city] = 0

}

}

fitness(int[] p)

calculate pathlength

from D[i][j]

if bestpath, save p

fitness(int[] p)

calculate pathlength

from D[i][j]

if bestpath, save p

efficiency without risk

fix first city O((n-1)n-1) use sets instead of searching array

O((n-1)!) keep partial fitness values

reduce cost of fitness evaluation apply branch and bound

BUT… still O(en)

Variations on TSP

undirected edges: D[i][j] == D[j][i] incomplete graph: some D[i][j] = null Euclidean distances (on a plane)

cities are located on plane at (xi,yi) D[i][j] is computed from coordinates:

D[i][j] = D[j][i]

= sqrt((xi-xj)2 + (yi-yj)2)

other data structures, efficiencies

Continuousproblem spaces

Where isheight of land?1. what scale to sample?

x[0,1], y[0,1]interval length:0.1: 100 data points0.01: 10,0000.001: 1,000,000

--- x --

- y

Continuousproblem spaces

Where isheight of land?1. what scale to sample?

x[0,1], y[0,1]interval length:0.1: 100 data points0.01: 10,0000.001: 1,000,000

--- x --

- y

Continuousproblem spaces

Where isheight of land?2. constraints –

ignore waterfewer data points but constraints must

be tested

--- x --

- y

Continuousproblem spaces

Where isheight of land?3. where to locate

sample --- x --

- y

Continuousproblem spaces - NLP

Non-Linear Programming problemsTypical problems are functions of multiple

variables over domains of eachMaximize f(x1,x2,x3,…,xn)

for x1 D1, x2 D2, x3 D3,…, xn Dn

NLP problems are NP complete*Linear Programming problems are

polynomial solvable O(nk)