M Tech Project – First Stage

Improving Branch-And-Price Algorithms For Solving 1D Cutting Stock Problem

Soumitra Pal [05305015]

Agenda

Cutting stock problem & formulation Generic Branch-and-price algorithm Implementation by Vance [1994], etc Work in next stage Conclusion

Cutting stock problem

Bigger rolls (raw) available Orders of smaller rolls are to be cut

(items) Minimize no of raws used

IP formulation

λj denotes the no of rolls cut in pattern j aij denote no of times item i is cut from

pattern j bi is order for item i

Solution using branch-and-price

Branch-and-bound technique of IP The bound is calculated using LP

relaxation solved by column generation

Generic branch-and-price algorithmGenerate Initial heuristic. Set it as incumbent. Make root node of BB tree and enter into Q

Unexamined node exists in Q?

Undiscovered?

Calculate LB (column generation)Set the node as discovered

LB = some feasible sol X and X< incumbent?

Update incumbent to X

LB >= incumbent?

Branch (i.e. make two nodes and make them undiscovered and unexamined and enter in Q)

Fathom(do nothing)

Set the node as examined

Stop; incumbentis the solution

Y

N

NN

N

Y

Y

Y

Column Generation in brief

Take few initial feasible columns Solve the restricted master problem Use the dual solution of the master

problem as the profit for the knapsack problem to get new better column

Continue as far as better columns can be found

BAP implementation variations

Initial heuristic solution Branching rule Node selection rule Bounds

Branching rules

Excludes fractional solution Guarantees feasible solution after a

finite number of steps Must encode branching info in

subproblem

Creates trees of ~ equal size Keeps master & subproblem

tractable

Conventional branching

Excludes fractional solution Finite no of steps since finite no of variables Encoding of branch info is explained next

λp = α

λp ≤ floor(α) λp ≥ ceil(α)

Subproblem modification

On the right branch, it is equivalent to reducing the demand vector & solve the residual

No need to modify the subproblem

On the left branch, the column should not be regenerated

This is done by keeping forbidden list in subproblem

Problem in conventional branching

Solution space is not equally divided on both the branches

Here, solution space is equivalent to all possible columns

On the right branch, no of possible new columns is reduced

Left branch reduces only one column Subproblem may become difficult

Branching for BCS (demand=1)

Branching rule by Vance [1994]

Branching in BCS (2)

Left branch should include both items l and m together

This can be solved by replacing the two items by one item of combined width

On the right branch, at most one of them should get included

This is solved by including edge constraints in the subproblem

The subspaces are of ~ equal size

Solving the subproblem

When no edge constraint, solve using Horowitz-Sahni algorithm

When no overlapping edge constraints, solve using modified HS using Jhonson-Padberg bounds

When overlapping edge constraints, use general IP solver

Horowitz-Sahni algorithm

Backtracking with bounds Items ordered in decreasing profit density

(profit/weight) In forward move, try inserting one item Bound

If U>current best, move forward Otherwise backtrack (remove last inserted

item) & repeat Update current best when last item is

considered Stop when no more backtracking is possible

Jhonson-Padberg algorithm

Solves Knapsack Problem with SOS SOS is a set of variables, at most one

can be set to 1

Jhonson-Padberg algorithm (2)

Order SOSs according to max p/w If w1≥W, set corresponding x1=W/w1 and all

other xi=0 Otherwise, RECORD xi for the item with

minimum weight Remove from S1, all items having profit less

than wi; update remaining items in S1, pj-=pi, wj-=wi and W-=wi

Repeat If multiple items in same SOSs is

RECORDED, set variables as shown in the example

JP algorithm Example

Modified HS

Use SOS ordering In forward move at most one from

each SOS can be inserted Bound is calculated using JP In backtrack, other item in the same

SOS is considered next

Branching for general CSP

Branch on a set of variables Need to explore more

Bounding

Bounding can be used to avoid tailing-off effect

When the following condition is satisfied, column generation can be stopped

Initial heuristic solution

First Fit Decreasing (FFD) Items in decreasing size is fit in

existing roll If can not be fit, use a new roll

Work in next stage

Complete literature survey Vance [1998] Vanderbeck [1999] Degraeve and Peeters [2003] Carvalho [1999]

Comparative study of them Different set of experimental instances Time quoted are on different machines Need to gather absolute numbers such

as no of nodes, no of sub-problems etc

Knapsack with forbidden list

A dynamic programming algorithm

KPFL(I,W,S) := max{KPFL(I-1,W,S), KPFL(I-1,W-wI,S uinon I)}

O(n x W x 2n x L)

Need to improve that Core algorithms

Conclusion

We explored solution of 1D CSP using branch-and-price

Need to improve the solution to subproblem for overall improvement

Dynamic programming etc to solve subproblem instead of using IP solvers