Greedy method

ByAbhishek Mukhopadhyay

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.

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;• }

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.

Knapsack problem

Knapsack problem

Based on pick-up of weights

0-1 knapsack Fractional knapsack

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.

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

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.

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)

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);• }

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.

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

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}; } }

Self-Study

Prim’s algorithm and Kruskal’s

algorithm( Elaborate the algorithm with suitable

example)

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.

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 } }

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

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

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

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

4-Queens

Q Q QQ

Q x

Qx

Q x

Qx

Q x Q

Qx Q

Q x x

4-Queens

Q Qx x

Q x x

QQ xx x

Q x x

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

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

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

4-Queens

Qx

Qx Q

Q Qx x

QQ xx x

Qx

Q xx x

Qx

Q xx x Q

4-Queens

Qx

Q xx x Q Q

Qx

Q x Qx x Q x

Qx Q

Q x xx x Q x

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

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

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

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

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

Graph Coloring

C

A

FB

E

D

Graph Coloring

C

A

FB

E

D

Graph Coloring

C

A

FB

E

D

Graph Coloring

C

A

FB

E

D

Graph Coloring

C

A

FB

E

D

Graph Coloring

C

A

FB

E

D

Graph Coloring

C

A

FB

E

D

Graph Coloring

C

A

FB

E

D

Graph Coloring

C

A

FB

E

D

Graph Coloring

C

A

FB

E

D

Graph Coloring

C

A

FB

E

D

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