greedy backtracking

44
Greedy method By Abhishek Mukhopadhyay

Upload: abhishek-mukhopadhyay

Post on 20-Jul-2016

90 views

Category:

Documents


3 download

DESCRIPTION

greedy: Introduction, Knapsack problem, Job sequence deadline problem with exampleBacktracking: Introduction, n-queen problem. Graph coloring problem

TRANSCRIPT

Page 1: Greedy Backtracking

Greedy method

ByAbhishek Mukhopadhyay

Page 2: Greedy Backtracking

Concept about Greedy method• It is used to solve problems that have ‘n’ inputs and require us

to obtain a subset that satisfies some constraints.• Greedy method suggests that one can divide the algorithm

that works in stages.• At each stage a decision is made regarding weather or

particular input is in the optimum solution.• For this purpose all the inputs must be arranged in a

particular order by using a selection process.

Page 3: Greedy Backtracking

Control abstraction for GREEDY• Algorithm Greedy (a,n)• • //a[1:n] contains the ‘n’ inputs• { Solution: = 0; //initialize the solution• for i: = 1 to n do• { x: = select (a);• if feasible (solution, x) then• solution: = Union (solution, x);• }• return solution;• }

Page 4: Greedy Backtracking

Feasible solution and optimal solution

• Feasible solution: Any subset of the solutions that satisfies the constraints of the problem is known as a feasible solution.

• Optimal solution: The feasible solution that maximizes or minimizes the given objective function is an optimal solution. Every problem will have a unique optimal solution.

Page 5: Greedy Backtracking

Knapsack problem

Knapsack problem

Based on pick-up of weights

0-1 knapsack Fractional knapsack

Page 6: Greedy Backtracking

Fractional Knapsack• A knapsack with capacity ‘m’ is given.• we are required to place certain weights such that the sum of

the weights will not exceed the knapsack capacity. • Associated with each weight we have associated profit which

will be earned by the inclusion of the object in to the knapsack.

• If it is not possible to include an object entirely a fraction of the object can be included and accordingly a fraction of the profit is earned.

Page 7: Greedy Backtracking

Mathematical representation• m=capacity of knapsack.• n=no. of objects.• object ‘i’ has a profit pi and weight wi associated with it.

• If a fraction xj (o≤ x, ≤ 1) of the object i is placed in the bad. A profit pi x xi is made.

• The knapsack problem can be stated mathematically as follows:

Maximize ∑ Pi xi, for 1 ≤ i ≤ nS.T.C∑ wi xi ≤ m1 ≤ u ≤ no ≤ xi ≤ 11 ≤ i ≤ n

Page 8: Greedy Backtracking

Example:

Consider 3 objects whose profits and weights are defined as

(P1, P2, P3) = ( 25, 24, 15 )(W1, W2, W3) = ( 18, 15, 10 )

n=3 m=20 Consider a knapsack of capasity 20. Determine the

optimum strategy for placing the objects in to the knapsack.

Page 9: Greedy Backtracking

Example(Cont..)

• Greedy about profit(1,2/15,D)• Greedy about weight(D,2/3,1)• Greedy about profit/unit weight (0,1,1/2)

Page 10: Greedy Backtracking

Pseudocode of knapsack problem• Algorithm Greedy knapsack (m, n)• //p (1>n) and w(1:n) contain the profits and weights• //resp. of the n objects ordered such that p(i)/W(i)• // p[i+1)/w (i+1]. M is the knapsack size and x (1:n)• // is the solution vector• {• for i: = 1 to n do x(i) = 0.0i// initialize x • u : = m;• for i: = 1 to n do• { if (w(i) > u) then break;• x(i): = 1.0; u: = u-w(i);• }• if (i≤n) then x(i): = u/w(i);• }

Page 11: Greedy Backtracking

Job Sequencing with Deadlines• We are given a set of ‘n’ jobs.• Associated with each job there is a integer dead line di0 and

a profit pi>0.• A feasible solution for the problem will be a subset ‘j’ of jobs

• each job in this subset can be completed by its deadline.• An optimum solution is a feasible solution with maximum

value.

Page 12: Greedy Backtracking

Example

• Obtain the optimal sequence for the following jobs. j1 j2 j3 j4

(P1, P2, P3, P4) = (100, 10, 15, 27) (d1, d2, d3, d4) = (2, 1, 2, 1) n =4 • Find out feasible solutions and optimal solution

Page 13: Greedy Backtracking

Pseudo code for JSD• Algorithm Greedy Job (d,j,n) // j is a set of jobs that can be completed by// their dead lines { j: = {1}; for i: = 2 to n do { if (all jobs in j u {i} can be completed by their dead lines)

then j: = ju{ i}; } }

Page 14: Greedy Backtracking

Self-Study

Prim’s algorithm and Kruskal’s

algorithm( Elaborate the algorithm with suitable

example)

Page 15: Greedy Backtracking

Backtracking• Backtracking is a form of recursion.• The usual scenario is that you are faced with a number of

options– you must choose one of these;– After you make your choice you will get a new set of options;

• This procedure is repeated over and over until you reach a final state.

• If you made a good sequence of choices, your final state is a goal state.

Page 16: Greedy Backtracking

Backtracking algorithm boolean solve(Node n) { if n is a leaf node { if the leaf is a goal node, return true else return false } else { for each child c of n { if solve(c) succeeds, return true } return false } }

Page 17: Greedy Backtracking

N-Queens

• The object is to place queens on a chess board in such as way as no queen can capture another one in a single move– Recall that a queen can move horz, vert, or

diagonally an infinite distance• This implies that no two queens can be on the same

row, col, or diagonal– We usually want to know how many different

placements there are

Page 18: Greedy Backtracking

4-Queens

• Lets take a look at the simple problem of placing queens 4 queens on a 4x4 board

• The brute-force solution is to place the first queen, then the second, third, and forth– After all are placed we determine if they are placed

legally• There are 16 spots for the first queen, 15 for the

second, etc.– Leading to 16*15*14*13 = 43,680 different combinations

• Obviously this isn’t a good way to solve the problem

Page 19: Greedy Backtracking

4-Queens

• First lets use the fact that no two queens can be in the same col to help us– That means we get to place a queen in each col

• So we can place the first queen into the first col, the second into the second, etc.

• This cuts down on the amount of work– Now there are 4 spots for the first queen, 4 spots for the

second, etc.• 4*4*4*4 = 256 different combinations

Page 20: Greedy Backtracking

4-Queens

• However, we can still do better because as we place each queen we can look at the previous queens we have placed to make sure our new queen is not in the same row or diagonal as a previously place queen

• Then we could use a Greedy-like strategy to select the next valid position for each col

Page 21: Greedy Backtracking

4-Queens

Q Q QQ

Q x

Qx

Q x

Qx

Q x Q

Qx Q

Q x x

Page 22: Greedy Backtracking

4-Queens

Q Qx x

Q x x

QQ xx x

Q x x

Page 23: Greedy Backtracking

4-Queens

• So now what do we do?• Well, this is very much like solving a maze– As you walk though the maze you have to make a series of

choices– If one of your choices leads to a dead end, you need to

back up to the last choice you made and take a different route• That is, you need to change one of your earlier selections

– Eventually you will find your way out of the maze

Page 24: Greedy Backtracking

4-Queens

QQ xx x

Q x x

Qxx

Q x

Qxx

Q x Q

Qxx Q

Q x x

Qxx Q

Q x x Q

Qxx Q Q

Q x x x

Page 25: Greedy Backtracking

4-Queens

Qx Qx Q x

Q x x x

Q Qx xx Q x

Q x x x

Qx Qx x

Q x x

Q Qx xx x

Q x x

Qxx

Q xQx

Page 26: Greedy Backtracking

4-Queens

Qx

Qx Q

Q Qx x

QQ xx x

Qx

Q xx x

Qx

Q xx x Q

Page 27: Greedy Backtracking

4-Queens

Qx

Q xx x Q Q

Qx

Q x Qx x Q x

Qx Q

Q x xx x Q x

Page 28: Greedy Backtracking

4-Queens

• This type of problem is often viewed as a state-space tree– A tree of all the states that the problem can be in

• We start with an empty board state at the root and try to work our way down to a leaf node– Leaf nodes are completed boards

Page 29: Greedy Backtracking

4-Queens

1

1 2 3 4

2

1 2 3 4 1 2 43

1 2 43

1 2 3 4

1

1 2 3

Page 30: Greedy Backtracking

Graph Coloring

• Graph coloring is the problem of coloring each vertex in a graph such that no two adjacent vertices are the same color

• Some direct examples:– Map coloring– Register assignment

Page 31: Greedy Backtracking

Graph Coloring

• The same issues apply as in N-Queens– We don’t want to simply pick all subsets

• Way too many– We want to prune the state-space tree as soon as we find

something that won’t work• This implies that we need a sequence of vertices to color• As we color the next vertex we need to make sure it doesn’t conflict

with any of its previously colored neighbors– We may need to backtrack

Page 32: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

• As an example:– The vertices are

enumerated in order A-F– The colors are given in

order: R, G, B

Page 33: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

Page 34: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

Page 35: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

Page 36: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

Page 37: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

Page 38: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

Page 39: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

Page 40: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

Page 41: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

Page 42: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

Page 43: Greedy Backtracking

Graph Coloring

C

A

FB

E

D

Page 44: Greedy Backtracking

Algorithm RCA (Recursive Color Assignment)

• Input: Vertex i, Set of Vertices V• 1 For each color c ϵ Li, if c is not assigned to any neighbour of i• 1.1 Assign c to i• 1.2 If i is the last vertex in V• 1.2.1 If x(G) > M• 1.2.1.1 x(G) = M• 1.2.1.2 Save the current coloring• 1.2.1.3 If M = LB then stop• 1.2.1.4 Otherwise UB = M – 1• 1.3 Otherwise execute RCA for the next vertex in V