🧩 Constraint Solving POTD:Problem of the Day: The Cutting Stock Problem

[github-actions[bot]]

Problem Statement

The Cutting Stock Problem is a classic optimization problem: given raw material in standard widths (or rolls, sheets, etc.) and a set of customer orders for specific smaller widths in specified quantities, find a way to cut the material to fulfill all orders while minimizing waste (or equivalently, minimizing the number of raw items used).

Concrete Example

Suppose a paper mill has raw rolls of width 100 cm. Customers place orders for:

• 40 rolls of width 50 cm
• 30 rolls of width 40 cm
• 20 rolls of width 30 cm

A cutting pattern is a way to arrange the desired widths on one raw roll. For instance:

• Pattern A: one 50 cm + one 40 cm + one 10 cm waste = 100 cm
• Pattern B: two 50 cm + no waste = 100 cm
• Pattern C: one 50 cm + one 30 cm + one 20 cm waste = 100 cm
• Pattern D: one 40 cm + two 30 cm + no waste = 100 cm

The problem is to decide how many rolls to cut using each pattern such that:

1. All customer orders are fulfilled (demand constraints)
2. The total number of raw rolls is minimized
3. Waste is minimized

Input/Output

Input:

• Raw material width: W (e.g., 100 cm)
• Desired widths: w_1, w_2, ..., w_m (e.g., 50, 40, 30)
• Customer demand: d_1, d_2, ..., d_m (e.g., 40, 30, 20)

Output:

• Set of cutting patterns (each pattern is a combination of desired widths that fit in W)
• Multiplicity for each pattern (how many rolls cut using that pattern)

---

Why It Matters

The cutting stock problem appears everywhere material waste is expensive:

• Paper and textile mills: cutting large rolls into smaller rolls for customers
• Steel and glass industries: cutting steel coils or glass sheets into specified sizes while minimizing scrap
• Lumber yards: optimally sawing logs into boards of customer-ordered lengths
• Packaging manufacturers: cutting cardboard sheets to create box blanks with minimal waste

In practice, even a 1% reduction in waste across a large mill translates to significant cost savings and environmental impact. This makes the cutting stock problem one of the most commercially important constraint problems in industry.

---

Modeling Approaches

Approach 1: Column Generation / Dantzig-Wolfe Decomposition (MIP)

The classic pattern-based formulation works as follows:

Decision variables:

• Generate all (or many) feasible cutting patterns P_j (each a combination of widths that fit in W)
• Let x_j = number of raw rolls cut using pattern j

Objective: minimize Σ_j x_j (total rolls used)

Constraints: For each desired width i:

Σ_j (amount of width i in pattern j) × x_j ≥ d_i

Trade-offs:

• Pros: Exact solutions via branch-and-bound, well-understood, leverages standard MIP solvers
• Cons: The set of patterns can be exponentially large; solved via column generation (iteratively add patterns that improve the LP relaxation)
• Strength: Global optimality can be proven; good for small to medium instances

Approach 2: Direct Integer Programming with Cutting Decisions

Decision variables:

• For each position p on each raw roll r, a binary variable y_{r,p,i} indicating whether desired width i is cut at position p on roll r
• Or, more compactly, real-valued variables for continuous material allocation

Objective: minimize total raw material used

Constraints:

• Material balance: each unit of each width demanded must be supplied
• Guillotine cuts (if relevant): no overlap, no waste overlap constraints
• Bin capacity: on each roll, total width of cuts ≤ raw width

Trade-offs:

• Pros: Avoids enumerating patterns explicitly; works for complex constraints (e.g., restricted cutting sequences, quality grading)
• Cons: Larger model size; fewer symmetries exploited; often weaker LP relaxations
• Strength: Flexible for real-world variants

Approach 3: Constraint Programming + Greedy / First-Fit Heuristics

Decision variables:

• For each raw roll, a sequence of desired widths assigned to it
• Cumulative "remaining width" on each roll

Objective: minimize number of rolls

Constraints:

• Each assignment satisfies packing constraints (sum of widths ≤ raw width)
• All demands met

Propagation:

• Bounds consistency on remaining capacities
• Channeling constraints linking pattern representation to assignment
• Global cardinality constraint to count widths used

Search strategy:

• First-fit or best-fit heuristics combined with backtracking
• Good for small instances; quick heuristic solutions

Trade-offs:

• Pros: Intuitive to implement; good pruning via global constraints; scalable with domain-specific reasoning
• Cons: May not find proven optimum; less competitive for very large instances
• Strength: Natural modeling of "real-world" heuristics; flexible reasoning

Example Model (MiniZinc-style)

% Cutting Stock Problem - Pattern-Based Model
int: raw_width = 100;
int: num_widths = 3;
int: num_patterns = 4;

array[1..num_widths] of int: demand = [40, 30, 20];
array[1..num_widths] of int: widths = [50, 40, 30];

% Pre-generated patterns: pattern[p, i] = count of width i in pattern p
array[1..num_patterns, 1..num_widths] of int: pattern = [
  | 2, 0, 0 |  % Pattern A: two 50cm
  | 1, 1, 0 |  % Pattern B: one 50cm, one 40cm
  | 1, 0, 2 |  % Pattern C: one 50cm, two 30cm
  | 0, 1, 2 |  % Pattern D: one 40cm, two 30cm
];

% Decision: how many rolls cut with each pattern
array[1..num_patterns] of var int: x;

% Objective: minimize total rolls
minimize sum(x);

% Demand constraints
constraint forall(i in 1..num_widths) (
  sum(p in 1..num_patterns) (pattern[p, i] * x[p]) >= demand[i]
);

% Non-negativity
constraint forall(p in 1..num_patterns) (x[p] >= 0);

---

Key Techniques

1. Column Generation

The brute-force approach of enumerating all patterns is infeasible for large widths. Column generation solves the LP relaxation of the pattern-based model iteratively:

• Start with a few feasible patterns
• Solve the current LP
• Use dual values to identify a new pattern with negative reduced cost
• Add this pattern and repeat

This technique is fundamental for production-scale cutting stock solvers and has led to dramatic efficiency improvements over naive branch-and-bound.

2. Bin Packing Heuristics + Bin Covering

• First-fit decreasing (FFD): Sort desired widths in decreasing order, greedily assign each to the first roll with enough space. Often gives solutions within 10–15% of optimal.
• Bin covering lower bounds: Compute lower bounds on the minimum number of rolls needed (e.g., via linear programming relaxation or worst-case bin packing analysis).
• Combine heuristic upper bounds with lower bounds to estimate solution quality.

3. Symmetry Breaking and Reformulation

• Many patterns are equivalent (e.g., "50+40+10 waste" is the same as "40+50+10 waste"). Group patterns to reduce variables.
• Cutting plane methods: Add valid inequalities (e.g., clique inequalities in the pattern graph) to tighten the LP relaxation and speed up branch-and-bound.
• Problem reformulation: For one-dimensional cutting, reduce to the classic bin packing problem; for two-dimensional or complex constraints, model as a 2D guillotine cutting problem.

---

Challenge Corner

Open Question for You:

Suppose you have a two-dimensional variant: you must cut items of various sizes (e.g., 50×30, 40×40, 30×50) from large sheets of size 100×100. Orders are for quantities of each size.

1. How would you extend the pattern-based model to handle 2D cutting? (Hint: patterns now describe 2D layouts, but enumerating them is much harder!)
2. Can you formulate a constraint that ensures "no overlaps" and "all cuts are guillotine" (i.e., made with straight lines, no jigsaw-like cuts)?
3. What additional real-world constraints might appear in a glass-cutting or steel-coil-cutting factory?

---

References

1. Wäscher, G., Haußner, H., & Schumann, H. (2007). "An improved typology of cutting and packing problems." European Journal of Operational Research, 183(3), 1109–1130.

   • Comprehensive survey and taxonomy of cutting and packing problems.

2. Gilmore, P. C., & Gomory, R. E. (1961). "A linear programming approach to the cutting-stock problem." Operations Research, 9(6), 849–859.

   • Classic paper introducing column generation for the cutting stock problem.

3. Vance, P. H. (1998). "Branch-and-price algorithms for the one-dimensional cutting stock problem." Computational Optimization and Applications, 9(3), 211–228.

   • Modern treatment of exact algorithms via branch-and-price.

4. Scheithauer, G., & Terno, J. (1996). "The modified integer round-up property for the one-dimensional cutting stock problem." European Journal of Operational Research, 84(3), 562–571.

   • Theory of optimal solutions and approximation bounds.

Generated by 🧩 Constraint Solving — Problem of the Day · copilot · haiku45 · 7.35 AIC · ⌖ 11.8 AIC · ⊞ 6.3K · ◷

• expires on Sep 20, 2026, 3:32 AM UTC-08:00

[github-actions[bot]]

This discussion has been marked as outdated by Constraint Solving — Problem of the Day.

A newer discussion is available at Discussion #60814.