Integer Programming

Integer Programming

---

Model 1(Linearization of nonlinear integer programming problem)

When there is a product (x_1,cdots,x_k) of k 0-1 variables (x_j), we call the problem is nonlinear problem. So we deal with the problem with following methods:

1. Introduce 0-1 variable y to replace product and add two constraint conditions：

   [egin{aligned}&sum_{j=1}^kx_j-yle k-1\ &-sum^k_{j=1}x_j + ky le 0\ &x_j = 0,1,quad j=1,cdots,k\ &y=0,1end{aligned} ]

2. Introduce non-negative variables (y) to replace the product term (x_1x_2cdots x_k)，and we add ((k+1)) limit constraint conditions:

   [egin{aligned} &sum^k_{j=1}x_j - yle k-1,\ &y le x_j,quad j=1,cdots, k\ &y ge 0,\ &x_j = 0,1,quad j=1,cdots, k end{aligned} ]

Model2 (Linearization of nonlinear integer programming problem)

problem describe

[max f(x_1) = egin{cases}10x_1 -100,当x_1 > 0\0quad quad quad quad ,当x_1 = 0 end{cases} ]

we get

[max Z = 10x_1 - 100y_1\ x_1 le My_1\ x_1 ge 0,y_1 = 0,1 ]

---

The Cutting Plane Method of Pure Integer Programming

The Geometric Characteristics of Cutting Plane Method

Mark the integer programming as AIP, it's feasible region is marked as (K_{AIP}). If we get rid of the constraint condition that variables have to be integers, then we get a linear problem (LP), it's feasible region is (K_{LP}).

The cutting plane method essentially use the same method of solving linear programming to solve integer programming. It's basic idea is:

When we solve the problem (LP), if the best solve (X^*) is an integer result, then (X^*) is of course the best result of AIP; if not, we try to add a linear constraint condition (call it cutting plane) to split a set out that does not include integer results from (LP)'s feasible region (K_{LP}), then we try to get the best result (X^{**}) of new linear programming. If (X^{**}) is still not the optimal solution of (AIP), then repeat the above process.

The Comory Cut

The key point of the cutting plane method is to find an appropriate cut constraint condition. Let's discuss it.

We import some signs:

(lfloor x floor) represents the largest integer that does not exceed x, (lceil x ceil) represents the smallest integer that does not less than x. $langle x angle = x - lfloor x floor $

Say B is a base of (LP), X is a feasible solution of (AIP), as (K_{AIP} in K_{LP}), so X is also a feasible solution of (LP), then X satisfy the equation set:

[x_{B_j} + sum_{jin I_D}y_{ij}x_j = overline b_i;quad i=1,2,cdots,m ]

As (X ge 0,lfloor y_{ij} floor le y_{ij}), so

[x_{B_j} + sum_{jin I_D}lfloor y_{ij} floor x_j le overline b_i;quad i=1,2,cdots,m ]

As left side is always an integer, so

[x_{B_j} + sum_{jin I_D}lfloor y_{ij} floor x_j le lfloor overline b_i floor;quad i=1,2,cdots,m ]

So

[sum_{jin I_D}(y_{ij} - lfloor y_{ij} floor)x_j ge overline b_i - lfloor overline b_i floor, i=1,2,cdots,m ag{5-20} ]

This is the necessary condition for every feasible solution in (AIP), we call it the Comory cut.

Assume B is the optimal base of (LP), X^* is the optimal solution about base B of (LP) and X^* is not an integer solution. Now then, (x^*_j = 0(jin I_D), x^*_{B_i} = overline b_i(i=1,cdots,m)), and at least one of (overline b_k) is not an integer.

Now, we choose (i=k) for inequation(5-20), it's left side equal to 0, and the right side is not. In another word, it definitely does not satisfy the Comory cut, so we need to split the X^* out. Then we import a slack variable (x_{n+1}) and get a new constraint condition:

[-sum_{jin I_D}langle y_{ki} angle x_j + x_{n+1} = -langle overline b_k angle ]

The Comory Cutting Plane Method

Assume the feasible region (K_{LP}) of (LP) that corresponds to (AIP) is not null and bounded, we give the following calculation steps:

• Solve (LP) with simplex method, get basic optimal solution X^*, optimal base B and optimal table T(B)
• If X^* is not an integer solution, let (langle overline b_k angle = max {langle overline b_i angle|1le ile m}), add the new constraint condition (-sum_{jin I_D}langle y_{ki} angle x_j + x_{n+1} = -langle overline b_k angle) to (LP) to get a new (LP). Then solve this new (LP).
• If we get the best integer solution, done. If not, repeat the above process.
• Tip: When we find a slack variable (x^{'}) become basic variable again after the spinning the spindle, delete the row and the column corresponding to the (x^{'}) may be a better option.