Available online at www.tjnsa.

com
J. Nonlinear Sci. Appl. 9 (2016), 1153–1164
Research Article

A new branch and bound algorithm for integer

quadratic programming problems
Xiaohua Ma, Yuelin Gao∗, Xia Liu
Beifang University for Nationalities, Institute of Information and System Sciences, Yinchuan, 750021, China.

Communicated by Y. Yao

Abstract
For integer quadratic programming problems, a new branch and bound algorithm is proposed in this
paper through a series of improvements on the traditional branch and bound algorithm, which can be
used to solve integer quadratic programming problems effectively and efficiently. This algorithm employs
a new linear relaxation and bound method and a rectangular deep bisection method. At the same time, a
rectangular reduction strategy is used to improve the approximation degree and speed up the convergence
of the algorithm. Numerical results show that the proposed algorithm is feasible and effective and has
improved the existing relevant branch and bound algorithms. 2016
c All rights reserved.
Keywords: Integer quadratic programming, branch and bound, linear relaxation, rectangular deep
bisection, rectangular reduction.
2010 MSC: 47H10, 54H25.

1. Introduction

Integer programming problems are optimization problems that minimize or maximize the objective
function in the limitation of equality or inequality constraints and integer variables. More widely application,
integer programming can be used to properly describe the decision problems on the management and effective
use of resources in engineering technology, social science, finance, business administration and many other
fields. With the development of science and technology and the urgent need for solving complex decision
problems in the actual, the algorithm research on nonlinear integer programming problems has become one
of the hot research topics in the field of operations research and optimization. Integer programming problems

∗
Corresponding author
Email addresses: [email protected] (Xiaohua Ma), [email protected] (Yuelin Gao), [email protected] (Xia Liu)
Received 2015-09-04
X. Ma, Y. Gao, X. Liu, J. Nonlinear Sci. Appl. 9 (2016), 1153–1164 1154

that we usually discuss are linear and it is known that the general linear integer programming problem is
NP- hard. From the mathematical programming section in appendix A6 of literature [13], we know that the
problem is NP- hard if constraints are quadratic and the objective function is linear and it is undecidable
if add an integer requirement to the last problem then the nonlinear integer programming problem is even
more difficult. The deterministic methods for solving nonlinear integer programming problems are outer
approximation methods [1, 2, 4, 6], cutting plane methods [5, 12, 16], decomposition algorithms [7, 15] and
branch and bound methods [3, 8, 9, 10, 11, 14], in which branch and bound methods are more practical.
However, as the integer programming problem is NP-hard problem, existing algorithms can only solve a
particular form of integer programming problems and there are often many shortcomings, such as a slow
convergence rate, large calculation quantity and poor efficiency. In view of this, as a preparation for seeking
a common and effective algorithm of solving general nonlinear integer programming problems, this paper
investigates the following special nonlinear integer programming problems − integer quadratic programming
problems:
 1
 min f (x) = xT Qx + cT x

(IQP ) 2
 s.t. x ∈ D = {x ∈ Rn |Ax ≤ b, x ≥ 0},
x ∈ Z n,


where Q ∈ Rn×n is a n-dimension symmetric matrix, c ∈ Rn , A ∈ Rm×n , b ∈ Rm . Z n is a set of integer

vectors in Rn , and D = {x ∈ Rn |Ax ≤ b, x ≥ 0} is a non-empty and bounded set.
Since the optimal solution of the integer quadratic programming problem may not be able to meet KKT
conditions, it is often more difficult to solve than the continuous optimization problem. Through a series of
improvements on the traditional branch and bound method, this paper presents an algorithm which can be
used to solve integer quadratic programming problems quickly and effectively.
This algorithm adopts a new linear relaxation and bound method, a rectangular deep bisection method
and the rectangular reduction method in the literature [9]. The feasibility, effectiveness and superiority
of the proposed new algorithm are explained by a lot of numerical experiments and the comparison with
existing literatures. This paper is organized as follows. In section 2, the relaxation and bound method is
given. In section 3, The subdivision and reduction of the rectangle are provided. The new branch and bound
algorithm is described in detail in section 4, and the convergence of the algorithm is analyzed. Finally, a
lot of numerical experiment results and the comparison with existing literatures turn out that the proposed
new algorithm is feasible, effective and superior.

2. Relaxation and bound method

In this section, we construct the integer rectangle R first, which contains the feasible region of the original
problem (IQP ). For this purpose, calculating the following 2n linear programming problems first:


 min h(xj ) = xj ,
s.t. Ax ≤ b,

 = 1, 2, ..., n

 x ≥ o,
x ∈ Rn .



 min l(xj ) = xj ,
s.t. Ax ≤ b,

 = 1, 2, ..., n

 x ≥ o,
x ∈ Rn .


We obtain optimal solutions h∗j , j = 1, 2, ..., n from (1) and optimal solutions lj∗ , j = 1, 2, ..., n from (2). Let

xj = dh∗j e, j = 1, 2, ..., n,
X. Ma, Y. Gao, X. Liu, J. Nonlinear Sci. Appl. 9 (2016), 1153–1164 1155

xj = blj∗ c, j = 1, 2, ..., n.
Then we get the integer rectangle which contains the feasible region F = D ∩ Z n

R = [x, x] = {x|x ≤ x ≤ x, x, x ∈ Z n },
where x = (x1 , x2 , ..., xn )T , x = (x1 , x2 , ..., xn )T are integer vectors. So the original problem (IQP ) is
equivalent to the following problem (IQP ), :
( 1
, min f (x) = xT Qx + cT x
(IQP ) 2
s.t. x ∈ D ∩ R ∩ Z n .
Consider the following continuous relaxation programming problem (QP ) of the problem (IQP ), :
( 1
min f (x) = xT Qx + cT x
(QP ) 2
s.t. x ∈ D ∩ R.
The optimal value of the problem (QP ) is a lower bound of the problem (IQP ), obviously. Therefore, it is
an effective lower bound of the optimal value of the original problem (IQP ).
Consider the lower bound estimation of the optimal value of the problem (QP ) first. Introducing the
variable d = (d1 , d2 , ..., dn )T ∈ Z n , and it satisfies

dj = min{QTj x|Ax ≤ b, x ≥ 0, x ≤ x ≤ x, x ∈ Rn }, j = 1, 2, ..., n,

where Qj represents the j-th row of the matrix Q. Because x ≥ 0, so there is
1 1
f (x) = xT Qx + cT x ≥ (c + d)T x, ∀x ∈ D ∩ R.
2 2
Then we get the following linear and relaxation programming problem of the problem (QP ) on the rectangle
Rk :
( 1
min f (x) = (c + d)T x
(LP (Rk )) 2
s.t. x ∈ D ∩ Rk .
Solving the problem (LP (Rk )), we obtain the optimal value. It is a lower bound of the global optimal value
ν(QP ) of the problem (QP ) on Rk , and it is also an effective lower bound of the global optimal value of the
original problem (IQP ) on Rk , i.e.

ν((IQP )Rk ) ≤ ν((QP )Rk ) ≤ ν((LP )Rk ).

Determining the upper bound is completed by feasible points of the problem (IQP ) in the process of
branching. Suppose x is the feasible point of the problem (IQP ) and W represents the set of current feasible
points of problems (IQP), which are obtained in the process of branch and bound. Let x → W . γ is the
upper bound of the current global optimal value of the problem (IQP ). If W = ∅, let γ = +∞; if W 6= ∅,
let γ = min{f (x) : x ∈ W } and find a current optimal solution xγ ∈ arg min W . During the process of
the branch and bound, all the feasible solutions x → W dynamically, and the upper bound is updated by
adding new feasible point constantly.

3. The subdivision and reduction of the rectangle

3.1. The subdivision of the rectangle
Suppose that Rk = [xk , xk ] ⊆ R is the current sub-rectangle to be divided and (xk , ν k ) denotes the
optimal solution of the problem (LP (Rk )). Obviously, xk ∈ D ∩ Rk .
Assuming X k ∈ Rk but xk ∈ / Z n , do the following subdivision to Rk = [xk , xk ]:
X. Ma, Y. Gao, X. Liu, J. Nonlinear Sci. Appl. 9 (2016), 1153–1164 1156

Step1 Compute ω = max{(xkj − xkj )(xkj − xkj ) : j = 1, 2, ..., n},

if ω = 0,
let xkξ − xkξ = max{xkj − xkj : j = 1, 2, ..., n},
xkξ + xkξ
then xkξ = ;
2
else ,
find the first xkj ∈ arg maxW and mark xkx = xkj
end if;
mark x, = (xk1 , xk2 , ..., xkj−1 , xkj , xkj+1 , ..., xkn );
Step2 Divide the rectangle Rk into two sub-rectangles Rk1 = [xk1 , xk1 ] and Rk2 = [xk2 , xk2 ] by the line
for x, and xk . Dividing the edge [xkj , xkj ] into two parts and rounding them, we get [xkj , bxkξ c] and [dxkξ e, xkj ].
So the left lower vertex and the right upper vertex of the sub-rectangle Rk1 = [xk1 , xk1 ] are:

xk1 = (xk1 k1 k1 T
1 , x2 , ..., xn ) , x
k1
= (xk1 k1 k1 k k1 k1 T
1 , x2 , ..., xj−1 , bxξ c, xj+1 , ..., xn ) ;

the left lower vertex and the right upper vertex of the sub-rectangle Rk2 = [xk2 , xk2 ] are:

xk2 = (xk2 k2 k2 k k2 k2
1 , x2 , ..., xj−1 , dxj )e, xj+1 , ..., xn ), x
k2
= (xk2 k2 k1 T
1 , x2 , ..., xn ) .

3.2. The reduction of the rectangle

All linear and inequality constraints of the problem (IQP ) can be expanded into the form nj=1 aij xj , (i =
P

1, 2, ..., m). Using the rectangular reduction technique of the literature [9], let I k := {1, 2, ..., m}.

For i = 1, 2, ..., m, doP begin

compute rUi := nj=1 max{aij xkj , aij xkj , and rLi := nj=1 min{aij xkj , aij xkj ;
P
if rLi > bi
then stop. Problem (IQP ) does not have feasible solutions on Rk . (Rk is removed);
else if rUi ≤ bi ,
then I k := I k − {i}. The i − th linear and inequality constraint of problem (IQP ) is removed;
else
for j = 1, 2, ..., n, do
if aij > 0,
k k
bi − rLi + min{aij xkj , aij xkj }
then xj := min{xj , };
aij
if xkj ∈ Z,
xkj := xkj ,
else
xkj := dxkj e
end if;
else if aij < 0
bi − rUi + max{aij xkj , aij xkj }
then xkj := max{xkj , } if xkj ∈ Z,
aij
xkj := xkj ,
else
xkj := bxkj c
end if;
end if;
end do;
end if;
end do.
X. Ma, Y. Gao, X. Liu, J. Nonlinear Sci. Appl. 9 (2016), 1153–1164 1157

For convenience, the new integer rectangle generated by this new algorithm still denoted by Rk , which
is a subset of the original integer rectangle.

4. The new branch and bound algorithm

When the iteration proceed in step k, the feasible region of the problem (IQP ) is denoted by F , Rk
represents the integer rectangle which will be divided soon, the set of all current feasible points is denoted
by W , T represents the set of remained rectangles after pruning, xk , ν(Rk ) are the optimal solution and
the optimal value of problem (LP (Rk )) on Rk respectively. ν = min{ν(Rk ) : Rk ∈ T and xν ∈ arg minν
represent the current global optimal solution and global optimal value of the problem (LP (Rk )) respectively,
ν is also a lower bound of the global optimal value of the problem (IQP ), Rν is the integer rectangle which
correspond to ν, the upper bound of the global optimal value of the problem (IQP ) is denoted by γ.
If W = ∅, let γ = +∞; if W 6= ∅, let γ = min{f (x) : x ∈ W } and find a current optimal solution
xγ ∈ arg minW .
Step1(initialization)
Construct a n-dimension rectangle R = [x, x] which contains F and let W = {x, x} ∩ F . Solving the
linear programming problem (LP (R)), we get the optimal value and the optimal solution, which is denoted
by ν and xν respectively, where the rectangle to which xν belongs is denoted by Rν , ν is a lower bound of the
global optimal value of the problem (IQP ). If xν ∈ F let W = W ∪{xν }, γ = min{f (x) : x ∈ W }. If W = ∅,
let γ = +∞; if W 6= ∅, let γ = min{f (x) : x ∈ W } and find a current optimal solution xγ ∈ arg minW .
Let T = {R}, k = 1.
Step2(termination criterion)
If ν = γ, then stop the calculation and output the global optimal solution Xγ and the global optimal
value f (xγ ) of the problem (IQP ), otherwise, go to the next step.
Step3(selection rule)
Select the rectangle Rk in T , which ν corresponds to, i.e. ν = ν(Rk );
Step4(subdivision method)
If xk ∈ Z n , delete Rk = [xk , xk ] and keep the optimal solution xk , otherwise, divide S
the rectangle Rk into
two sub-rectangles Rk1 and Rk2 by the method in 3.1, and intRk1 ∩intRk2=f , W = W ∪{ 2i=1 ({xki , xki }∩F )};
Step5(reduction method)
Perform the following reduction to the sub-rectangles after dividing by the technique in 3.2. For conve-
nience, the new rectangles after reducing still will be denoted by Rki , i ⊂ Γ, where Γ is the index set of the
reduced rectangle:
Step5.1 if xk1 = xk1
delete Rk1 and reserve the optimal solution xk1 ;
else
reduce Rk1 by the reduction technique in 3.2
if Rk1 is deleted
T = T \ {Rk }, turn to Step5.2;
else
T = T \ {Rk } ∪ {Rk1 }
solving the linear relaxation programming problem (LP (Rk )) we can get the optimal
value νk1 and the optimal solution xk1
if xk1 ∈ Z n
W = W ∪ {{xk1 , xk1 , xk1 } ∩ F };
else
W = W ∪ {{xk1 , xk1 } ∩ F };
endif
endif
endif
X. Ma, Y. Gao, X. Liu, J. Nonlinear Sci. Appl. 9 (2016), 1153–1164 1158

Step5.2 if xk2 = xk2

delete Rk2 and reserve the optimal solution xk2 ;
else
reduce Rk2 by the reduction technique in 3.2
if Rk2 is deleted, turn to Step6;
else T = T ∪ {Rk2 };
solving the linear relaxation programming problem (LP (Rk2 )) we can get the optimal value
νk2 and the optimal solution xk2
if xk2 ∈ Z n
W = W ∪ {{xk2 , xk2 , xk2 } ∩ F };
else
W = W ∪ {{xk2 , xk2 } ∩ F };
endif
endif
endif
Step6(determine the upper bound)
If W = ∅, then γ = γ;
If W 6= ∅, then γ = min{f (x) : x ∈ W } and find a current optimal solution xγ ∈ arg minW .
Step7(pruning rule)
Let T = T \ {R : ν(R) ≥ γ, R ∈ T }.
Step8(determine the lower bound)

γ, T = ∅,
ν=
min{ν(R) : R ∈ T }, T = ∅.
Let k¬k + 1. Turn to Step2

5. Numerical experiments

For the new algorithm in this paper and the method in literature [9], we apply MATLAB7.8.0 for
programming. When Q is positive definite, negative definite and indefinite, we use symmetric matrices Q of
different conditions and sizes to test respectively. All tests run on the computer with Intel (R) Core (TM)
i5-3570K, [email protected], 4.00GB RAM, 32-bit operating system. Firstly, we explain the feasibility and
effectiveness of the new algorithm through a simple example.
Example 5.1.  1
 min
 f (x) = xT Qx + cT x
(IQP ) 2
 s.t. Ax ≤ b,
0 ≤ x ≤ 60, x ∈ Z n ,

   
    2 −5 3 4
2 4 6 2  −4 −1 −3  −3
where Q = 4 4 10 , c = 4 , A =   , b =  .
 0 −1 −1  −1
6 10 6 9
−14 −2 −14 −4
 
0 60
The initial rectangle of the original problem is R1 = 0 60. Using the new proposed algorithm in this
0 60
paper to solve the linear relaxation programming problem (LP (R1 )) of the original problem (IQP ) first, we
obtain the optimal solution x1 = [0.5000; 1.0000; 0.0000] and the optimal value 9.2500 then the lower bound
and the upper bound of the original problem on the initial rectangle are 9.2500 and 94500 respectively,
and the corresponding optimal solution is x∗ = [60; 60; 60]. Updating the feasible solution set W constantly
X. Ma, Y. Gao, X. Liu, J. Nonlinear Sci. Appl. 9 (2016), 1153–1164 1159

during the process of calculating the lower bound  and subdividing

 and reducing the rectangle, so as to update
0 60
the upper bound. Select the rectangle R1 = 0 60 with the minimum lower bound to divide. Divide
0 60
   
0 60 0 60
the rectangle R1 into two sub-rectangles R11 = 0 1  and R12 = 1 60 by the method in 3.1 and
0 60 0 60
 
0 60
reduce it by the technique in 3.2, then the new rectangle after reducing is R2 = R12 = 1 60. Solving the
0 60
linear relaxation programming problem (LP (R2 )) on the rectangle R2 , we obtain the optimal value 9.2500
so the lower bound of the original problem is not updated, while the current upper bound is updated  to

0 60
2736 and the corresponding optimal solution is x∗ = [0; 30; 0]. Divide the rectangle R2 into R21 = 1 60
0 60
   
1 60 1 60
and R22 = 1 60 then reduce them, the new rectangle after reducing is R3 = R22 = 1 60. Solve the
0 60 0 60
linear relaxation programming problem (LP (R3 )) and get the optimal value 9.2500, while the current upper
bound is 13 and optimal solution is x∗ = [1; 1; 0]. Subdividing and reducing R3 constantly, its sub-rectangles
are all deleted, so we can know that the global optimal value of the original problem (IQP ) is 13 and the
global optimal solution is x∗ = [1; 1; 0].
The two main factors that affect the difficulty of solving integer quadratic programming problems are
the condition number of the matrix Q in the objective function and the form of the coefficient matrix A in
constraints. In order to make the test general and persuasive, we randomly generate matrices Q of specified
dimensions and different conditions and vectors of the first degree of the objective function in MATLAB.
The specific forms of constraints are selected from Table 5.
To better illustrate the advantages of the new algorithm in this paper for solving general integer quadratic
programming problems, we compare the new algorithm with the branch and bound method in [9], the
specific results are listed in Table 1 to 4 respectively. In tables, the column of constraint No. represents the
corresponding number of constraints in the Table 5. The column of the condition number of the matrix Q
indicates the norm condition number of the matrix Q. Integer objective value represents the optimal value
of the objective function when algorithm terminates. Alg.1 and Alg.2 denote the new branch and bound
algorithm in this paper and the branch and bound method in literature [9] respectively. In order to investigate
the effect when Q is positive definite, negative definite and indefinite on the algorithm respectively, Tables
1 to 3 give the test results for matrices Q with different constraints, sizes and conditions. From tables, we
know that the test time when the matrix Q is indefinite is relatively longer than that when Q is positive
definite and negative definite. In addition, in order to investigate the influence of the condition number of
the matrix Q on the algorithm, we give test results of 100-dimension problems with same constraints but
different condition numbers of matrices Q in Table 4. From the table, we know that the time which the
algorithm needs to solve the problem increases with the condition number of the matrix Q, which indicates
that the condition number of the matrix Q is indeed a major factor that affects the effectiveness of the
algorithm.
Results in tables show that the calculation time of the new algorithm in this paper are all much less than
that of the algorithm in [9] with the increase of the dimension and the calculation results are better, which
indicates that the proposed algorithm improves the computational efficiency, so the algorithm in this paper
is effective and feasible. From results of Table 1 to 4, although the iteration and the integer objective value
of our new algorithm may exceed that in the algorithm of [9], for large-scale integer quadratic programming
problems, running times of the new algorithm is far less than that in [9], so the algorithm in this paper is
superior to the algorithm in the literature [9], while the algorithm in [9] is superior than the normal branch
X. Ma, Y. Gao, X. Liu, J. Nonlinear Sci. Appl. 9 (2016), 1153–1164 1160

and bound algorithm.

Generally speaking, with the increase of determine variables of the problem and the effective constraints,
the time of solving the problem also increases. With the increase of the condition number of the matrix Q,
the complexity and the time of solving the problem all increase. Tests which we use in this paper are all
based on the literature [9], but from the calculation time of the proposed algorithm and the algorithm in
[9], the former algorithm is far less than the latter one.

Table 1: when Q is positive definite, results of solving integer quadratic programming problems with different sizes

Integer objective
test Constraint Condition number Time (s) Iteration
dimension value
No. No. of the matrix Q
Alg.1 Alg.2 Alg.1 Alg.2 Alg.1 Alg.2
1 10 1 305 1.136 2.675 352.5 200 5 7
2 30 2 3823 10.133 21.756 76112.5 73336.5 13 15
3 50 3 244269 10.642 39.278 1535261 1845614 7 9
4 50 4 244269 10.161 26.103 4930 4959 7 9
5 70 5 13114 52.829 63.653 27737.5 24445 25 17
6 70 6 13114 13.279 41.628 6804 6923.5 5 9
7 100 7 225175 20.861 17.709 10589 14400 5 3
8 100 8 225175 212.380 222.497 42018.5 38655 57 35
9 100 9 225175 55.056 87.462 10515 9850.5 13 11

Table 2: when Q is negative definite, results of solving integer quadratic programming problems with different sizes

Integer objective
test Constraint Condition number Time (s) Iteration
dimension value
No. No. of the matrix Q
Alg.1 Alg.2 Alg.1 Alg.2 Alg.1 Alg.2
1 10 1 132 1.127 1.883 212.5 233.5 5 5
2 30 2 4514 8.558 12.810 75210 64662 11 9
3 50 3 4979 6.916 20.003 1187750 4837869 5 7
4 50 4 4979 3.684 18.734 4950 4264 3 7
5 70 5 8099 57.491 69.244 28939 26874 27 17
6 70 6 8099 13.701 12.953 7665 10380 5 3
7 100 7 577740 17.790 21.310 10602 15887.5 5 3
8 100 8 577740 205.962 238.168 42150.5 37818 59 35
9 100 9 577740 62.875 86.562 11152.5 9717.5 15 11
X. Ma, Y. Gao, X. Liu, J. Nonlinear Sci. Appl. 9 (2016), 1153–1164 1161

Table 3: when Q is indefinite, results of solving integer quadratic programming problems with different sizes

Integer objective
test Constraint Condition number Time (s) Iteration
dimension value
No. No. of the matrix Q
Alg.1 Alg.2 Alg.1 Alg.2 Alg.1 Alg.2
1 10 1 204 1.908 3.275 255.5 274.5 9 9
2 30 2 8102 8.936 12.138 68010 57283 11 9
3 50 3 56641.8 7.843 22.749 16002009 2132540 5 7
4 50 4 56641.8 9.976 24.945 5221.5 5519 7 9
5 70 5 144119 49.891 64.527 28265.5 26016.5 23 17
6 70 6 144119 12.084 22.993 9441 7374 5 5
7 100 7 27341 19.982 21.463 9747 14430 5 3
8 100 8 27341 211.563 223.472 42277 38045.5 61 35
9 100 9 27341 50.597 88.102 9861.5 9225.5 13 11

Table 4: results of solving integer quadratic programming problems with same sizes and constraints but different conditions

Integer objective
test Constraint Condition number Time (s) Iteration
dimension value
No. No. of the matrix Q
Alg.1 Alg.2 Alg.1 Alg.2 Alg.1 Alg.2
1 100 9 21645 52.133 84.947 10660 9489.5 13 11
2 100 9 63552 53.611 90.163 9990 9638.5 13 11
3 100 9 151295 65.511 73.871 10146.5 9709 15 9
4 100 9 397950 47.072 90.799 10049 9720.5 11 11
5 100 9 750783 45.727 109.414 10593 9468.5 11 13

Table 5: [9] constraints be used in different tests

Constraints No. The specific form of constraints

x1 + x2 + 2x3 + 8x4 + x5 ≤ 100
x2 + 3x4 + 15x6 + x9 ≤ 200
1 x3 + x5 + 13x6 + 10x1 + x9 ≤ 300
x4 + 20x5 + 8x7 + x10 ≤ 300
P10
i=1 xi ≥ 15, 0 ≤ xi ≤ 60, xi ∈ Z, i = 1, 2, ..., 10
x1 + 5x6 + x7 + 8x8 + 2x9 + x10 − 2x11 + 5x13 + 3x22 − x28 ≤ 500
x2 + 8x11 + 4x13 − x14 + 3x19 + 2x20 + x21 + 2x22 + x23 + x24 ≤ 500
x3 + 5x7 + x8 + 3x12 + 2x14 + x18 + 3x22 + 8x25 + 3x27 + x30 ≤ 600
2
x4 + x9 + 2x13 + 5x14 + 3x15 + 2x16 + x17 + x26 ≤ 400
x5 + 2x6 + x11 + 4x17 + 5x20 + 3x21 + 4x23 + x28 + x29 ≤ 400
P30
i=1 xi ≥ 150, 0 ≤ xi ≤ 60, xi ∈ Z, i = 1, 2, ..., 30
X. Ma, Y. Gao, X. Liu, J. Nonlinear Sci. Appl. 9 (2016), 1153–1164 1162

Table 6: example of table

x1 + x9 + x1 0 + 4x15 − 5x19 + 3x23 + x24 − x28 + 2x29 + x31 ≤ 1000

x2 − x9 + x11 + 4x13 + 2x19 + 2x20 + x21 + 3x22 + x23 + x24 ≤ 1000
2x3 + x10 − 2x11 + 3x12 + x14 + 5x17 + 3x22 + 2x25 + 3x27 + x30 ≤ 1000
x4 + x9 + 2x13 + 5x14 + 3x15 + x16 + x31 + x33 + x35 + x36 ≤ 1000
3 4x5 + x11 + x17 + 5x20 + x21 + 4x23 − x26 + 5x29 + 2x38 + x40 ≤ 1000
x6 + 2x10 + 2x12 + 5x13 + 8x16 + x18 + 3x26 + 2x28 + 4x32 + x44 ≤ 1000
2x7 + 4x9 + x12 + 2x15 + x17 + 3x18 + 5x31 + 6x34 + x37 + x45 ≤ 1000
x + 2x + x41 + x42 + 4x43 + x46 + x47 + x48 + x49 + x50 ≤ 1000
P8 50 39
i=1 xi ≥ 500, 0 ≤ xi ≤ 800, xi ∈ Z, i = 1, 2, ..., 50
x1 + 2x9 − x10 + 4x15 + x19 + x23 + x24 − x28 + 2x29 + x31 ≤ 300
x2 + x12 − x13 + 2x19 + x20 + x21 + 3x22 + x23 + x24 + x29 ≤ 300
x3 + x12 + x14 + 3x17 − 2x21 + x22 + 2x25 + 3x27 + x30 + x31 ≤ 300
x4 + x14 + 3x15 + x16 + 2x19 + x31 + 2x33 + x35 + x36 + 5x49 ≤ 300
4 x5 + 2x17 + x20 + x21 + 4x23 − x26 + x29 + 2x38 + x40 + x41 ≤ 300
x6 + x10 + 8x12 + x16 + x18 − x26 + 2x28 + 4x32 + x43 + x44 ≤ 300
x7 − x15 + x17 + x22 + 4x32 + 6x34 + 3x43 + x45 + x47 + x49 ≤ 300
x8 + 4x18 + x31 + x37 − 2x39 + x41 + x42 + 3x46 + x48 + x50 ≤ 300
P50
P70i=1 xi ≥ 30, 0P≤ xi ≤ 50, xi ∈ Z, i = 1, 2, ..., 50
70
5 i=1 xi = 500, i=1 xi ≥ 60, 0 ≤ xi ≤ 10, xi ∈ Z, i = 1, 2, ..., 70
x1 + 3x12 + x10 + 2x19 + x30 − 5x31 + x34 + x37 − x45 + x65 ≤ 500
x2 + x19 + 2x20 + 5x29 + x32 + x37 + x42 − x45 − x46 + 4x64 ≤ 500
x3 + 5x13 + 2x16 + x28 + x39 + x43 − x41 − x58 + 2x59 + 3x63 ≤ 500
x4 + x11 + x26 + x33 + 2x34 − x39 − 2x40 + x57 + 3x61 + 5x62 ≤ 500
x5 + x18 + x27 + 2x28 − x29 − x30 + x38 + x39 + 5x47 + x66 ≤ 500
6 x6 + x14 + 2x23 + 5x34 + x36 + x37 + x38 − x55 − x56 + 4x67 ≤ 500
x7 + 2x15 − x22 − x35 + 7x44 + x46 + x47 + x48 + x50 + x54 ≤ 500
x8 − x16 − 2x24 + 6x28 + 2x30 + x35 + x37 + x53 + x58 + 2x69 ≤ 500
x9 − x17 + 7x21 + x36 + 5x37 + x45 + x49 + x52 + x60 − 7x68 ≤ 500
x10 + 6x20 + x25 + x27 + x39 + x40 + x50 + x51 + x54 + x70 ≤ 500
P70
i=1 xi ≥ 30, 0 ≤ xi ≤ 50, xi ∈ Z, i = 1, 2, ..., 70
X. Ma, Y. Gao, X. Liu, J. Nonlinear Sci. Appl. 9 (2016), 1153–1164 1163

Table 7: example of table

x1 + x11 + 3x21 + x36 + x48 + x58 + x66 + 2x71 + x81 + 3x99 ≤ 550
x2 + 4x12 + x22 + x38 + x44 − x57 + x65 + x77 + x79 + x98 ≤ 550
x3 + x12 + x23 + 5x31 + x47 + 2x53 + x70 + x72 + 2x82 + x91 ≤ 550
x4 + x14 + x24 + x33 + 2x43 − x59 − 2x64 + x73 + 3x76 + 5x100 ≤ 550
x5 + x15 + x27 + 2x39 + x42 − x52 + x63 + x78 + x80 + 3x97 ≤ 550
x6 + x16 + x30 + x32 − x41 + x45 + 3x54 + x69 + x74 + x92 ≤ 550
x7 + 2x17 + x26 + x40 + x45 − 2x51 + x62 + x77 + x83 + 7x96 ≤ 550
x8 + x18 + x25 + x34 + x46 − x55 + 5x61 + x75 + x79 + x93 ≤ 550
7
x9 − x19 + x29 + 4x35 + 5x49 + x60 + x67 + x80 − 3x84 + x95 ≤ 550
x10 + x20 − x23 + x37 + 3x50 + x56 + x68 + 4x76 + x78 + x94 ≤ 550
x11 + x23 + 3x31 + x37 + x39 + x54 + x64 + 2x67 + x79 + x90 ≤ 550
x12 + x36 + 2x40 + x41 + 7x55 + x56 + x68 + x74 + x79 + x90 ≤ 550
x13 + x18 + x25 + 5x42 + x51 − x57 + x58 + x71 + x72 + x87 ≤ 550
x14 + x27 + x45 − 3x47 + x49 + x59 + x60 + x75 + 3x79 + 3x88 ≤ 550
x15 + x31 + x40 + x50 + x51 + x62 + x63 + x81 + x85 + x89 ≤ 550
P100
xi ≥ 30, 0 ≤ xi ≤ 60, xi ∈ Z, i = 1, 2, ..., 100
Pi=1
100 P100
8 i=1 xi = 300, i=1 xi ≥ 60, 0 ≤ xi ≤ 4, xi ∈ Z, i = 1, 2, ..., 100
x1 + x11 + 3x21 + x36 + x48 + x58 − 7x66 + 2x71 + x81 + 3x99 ≤ 60
x2 + 4x12 + x22 − 3x38 + x44 − x57 + x65 + x77 + x79 + x98 ≤ 60
x3 + x12 + x23 + 5x31 + x47 + 2x53 + x70 + x72 + 2x82 + x91 ≤ 60
x4 + x14 − 3x24 + x33 + 2x43 + x59 + x64 + 4x73 + 3x76 + 5x100 ≤ 60
x5 + x15 + x27 + 2x39 + x42 − x52 + x63 + x78 + x80 + 3x97 ≤ 60
x6 + x16 + x30 + x32 − x41 + x45 + 3x54 + x69 + x74 + x92 ≤ 60
x7 + x17 + x26 + x40 + x45 − 2x51 + x62 + x77 + x83 + 7x96 ≤ 60
x8 + x18 + x25 + x34 + x46 − x55 + 5x61 + x75 + x79 + x93 ≤ 60
9
x9 − x19 + x29 + 4x35 + 5x49 + x60 + x67 + x80 − 3x84 + x95 ≤ 60
x10 + x20 − x23 + x37 + 3x50 + x56 + x68 + 4x76 + x78 + x94 ≤ 60
x11 + x23 − 2x31 + x37 + x39 + x54 + x64 + 2x67 + x79 + x90 ≤ 60
x12 + x36 + 2x40 + x41 + 7x55 + x56 + x68 + x74 + x79 + x90 ≤ 60
x13 + x18 + x25 + 5x42 + x51 − x57 + x58 + x71 + x72 + x87 ≤ 60
x14 + x27 + x45 − 3x47 + x49 + x59 + x60 + x75 + 3x79 + 3x88 ≤ 60
x15 + 4x31 + x40 + x50 + x51 + x62 + x63 + x81 + x85 + x89 ≤ 60
P10
i=1 xi ≥ 30, 0 ≤ xi ≤ 10, xi ∈ Z, i = 1, 2, ..., 100
X. Ma, Y. Gao, X. Liu, J. Nonlinear Sci. Appl. 9 (2016), 1153–1164 1164

6. Conclusion

For the preparation to seek a common and effective algorithm for solving general nonlinear integer
programming problems, this paper comes up with an algorithm for solving integer quadratic programming
problems quickly and effectively by using a new linear relaxation and bound method, a rectangular deep
bisection method and a rectangular reduction technology to improve the traditional branch and bound
algorithm. Numerical results show that the proposed algorithm is feasible and effective. Although the
iteration and the integer objective value of the new algorithm in this paper may exceed those of the algorithm
in [9] sometimes, for large-scale integer quadratic programming problems, the running time of our new
algorithm is far less than that in [9] and our new algorithm have a better calculation results. The algorithm
in this paper is superior to the branch and bound algorithm in the literature [9], which indicates that the
proposed algorithm improves the calculation efficiency and is more obvious to large-scale integer quadratic
programming problems.

Acknowledgements

This work was supported by the National Natural Science Foundation of P. R. China (11161001) and
the Foundations of research projects of State Ethnic Affairs Commission of P.R. China (14BFZ003) and the
Foundations of research projects of Beifang University of Nationalities (2015KJ10).

References
[1] M. L. Bergamini, I. Grossmann, N. Seenna, P. Aguirre, An improved piecewise oute-approximation algorithm for
the global optimization of MINLP models involving concave and bilinear terms, Comput. Chem. Eng., 32 (2008),
477–493. 1
[2] C. Buchheim, L. Trieu, Quadratic outer approximation for convex integer programming with box constraints, Exp.
Algorithms, 7933 (2013), 224–235. 1
[3] Z. P. Chen, F. Xi, A new branch-and-bound algorithm for solving large complex integer convex quadratic programs,
Math. Numer. Sin., 26 (2004), 445–458. 1
[4] M. A. Duran, I. E. Grossmann, An outer-approximation algorithm for a class of mixed-integer nonlinear programs,
Math. Program., 36 (1986), 307–339. 1
[5] V. P. Eronena, M. M. Mäkeläa, T. Westerlundb, Extended cutting plane method for a class of nonsmooth non-
convex MINLP problems, Optim., 64 (2015), 641–661. 1
[6] R. Fletcher, S. Leyffer, Solving mixed intger nonlinear programs by outer approximation, Math. program., 66
(1994), 327–349. 1
[7] O. E. Flippo, A. H. Rinnoy Kan, A note on benders decomposion in mixed-integer quadratic programming, Oper.
Res. Lett., 9 (1990), 81–83. 1
[8] Y. L. Gao, Y. J. Wang, X. W. Du, A two-level relaxed bound method for a nonlinear class of 0-1 knapsack
problems, Intelligent Information, Manage. Syst. Technol., 3 (2005), 461–470. 1
[9] Y. L. Gao, F. Wei, A branch-and-bound reduced method for a class of non-negative integer quadratic programming
problems, math. Numer. sin., 33 (2011), 233–248. 1, 3.2, 5, 5, 5, 6
[10] T. Kuno, Solving a Class of Multiplicative programs with 0-1 Knapsack Constraints, J. Optim. Theory Appl.,
103 (1999), 121–135. 1
[11] R. Misener, C. A. Floudas, GloMIQO: Global mixed-integer quadratic optimizer, J. Global Optim., 57 (2013),
3–50. 1
[12] I. Nowak, S. Vigerske., LaGO: a (heuristic) branch and cut algorithm for nonconvex MINLPs., CEJOR Cent.
Eur. J. Oper. Res., 16 (2008), 127–138. 1
[13] A. Schrijver, Theory of linear and integer programming, John Wiley and Sons, Chichester, (1986). 1
[14] R. A. Stubbs, S. Mehrotea, A branch-and-cut method for 0-1mixed convex programming, Math. Program., 86
(1999), 512–532. 1
[15] X. L. Sun, J. L. Li, H. Z. Luo, Convex relaxation and Lagrangian decomposition for indefinite quadratic integer
programming, Optim., 59 (2010), 627–641. 1
[16] T. Westerlund, F. Pettersson, An extended cutting plane method for solving convex MINLP problems, Comput.
Chem. Eng., 19 (1995), 131–136. 1