I have to set up a linear programming problem corresponding to the following scenario:
What I tried:
I think we have 8 templates for 1 $68 \times l$ reel (or whatever):
$22,22,22$ (66)
$20,20,20$ (60)
$12,12,12,12,12$ (60)
$22,22,20$ (64)
$22,20,20$ (62)
$22,20,12,12$ (66)
$22,12,12,12$ (58)
$12,12,12,12,20$ (68)
Let $x_{i,j}$ denote order $j$ from type $i$
for $i = 1,2,...,8$
for $j = 1,2,3$
We want to minimise reels (or whatever) used
$$z = \sum_i \sum_j x_{i,j}$$
s.t.
Nonnegativity:
- $$x_{i,j} \ge 0$$
Orders:
$$\sum_i x_{i,1} \ge 110$$
$$\sum_i x_{i,2} \ge 120$$
$$\sum_i x_{i,3} \ge 80$$
Is that right?
From Chapter 2 here.
Your approach, reduce all possible combinations how to cut the jumbo reels to a couple of useful order type cuts, looks very good to me.
Optimization Goal:
Your optimization goal is wrong. You are requested to minimize trim waste.
For this you just need to define the amount of trim waste $w_i$ for each order type $i$ and sum this up multiplied with the order type amounts $x_i$. E.g. $w_1 = 68\cdot L - 66 \cdot L = 2 \cdot L$. We would just count it in multiples of the fixed length $L$, so we simply say $w_1 = 2$.
Our goal of minimized total waste might be written as: $$ \min w = \min \sum_i w_i \, x_i $$
The Constraints:
For each order type $i$ you can define a quantity $n_{ij}$, which describes how many type $j$ reels result from an order of type $i$. E.g. $n_2 = = (n_{21}, n_{22}, n_{23}) = (0, 3, 0)$, $n_6 = (1,1,2)$.
The constraint of the ordered $j$ reel amounts is e.g. $$ \sum_i n_{i1} x_i \ge 110 $$
Trim Waste Revisited:
Having those $n_{ij}$ will give you the trim wastes $$ w_i = 68 - 22 \cdot n_{i1} - 20 \cdot n_{i2} - 12 \cdot n_{i3} $$
Order Types:
Important for your result is the choice of the order types, which are represented by the $n_{ij}$. You defined $8$ of them, I do not know if there are more useful order types. I would consider all with a resulting trim waste $$ 0 \le w_i < 12 $$ and $$ n_{ij} \ge 0 $$ but different from the null vector. I would write a small script to determine all by brute force.
Update:
My friend Ruby found $10$ order types, see here. (Source)