Elsevier

Computers & Operations Research

Volume 101, January 2019, Pages 263-274
Computers & Operations Research

A Branch-and-Bound Algorithm for a Class of Mixed Integer Linear Maximum Multiplicative Programs: A Bi-objective Optimization Approach

https://doi.org/10.1016/j.cor.2018.08.004Get rights and content

Highlights

  • We study a class of mixed integer non-linear optimization problems.

  • We develop a novel branch-and-bound algorithm.

  • We show that the proposed algorithm outperforms a standard solver.

Abstract

We present a linear programming based branch-and-bound algorithm for a class of mixed integer optimization problems with a bi-linear objective function and linear constraints. This class of optimization problems can be viewed as a special case of the problem of optimization over the set of efficient solutions in bi-objective optimization. It is known that when there exists no integer decision variable, such a problem can be solved in polynomial time. In fact, in such a case, the problem can be transformed into a Second-Order Cone Program (SOCP) and so it can be solved efficiently by a commercial solver such as CPLEX SOCP solver. However, in a recent study, it is shown that such a problem can be solved even faster in practice by using a bi-objective linear programming based algorithm. So, in this study, we embed that algorithm in an effective branch-and-bound framework to solve mixed integer instances. We also develop several enhancement techniques including preprocessing and cuts. A computational study demonstrates that the proposed branch-and-bound algorithm outperforms a commercial mixed integer SOCP solver. Moreover, the effect of different branching and node selecting strategies is explored.

Introduction

Many real-world optimization problems involve multiple objectives. Such an optimization problem (with p objectives) can be stated as follows: maxxX{z1(x),,zp(x)},where XRn represents the set of feasible solutions of the problem. The objectives of such a problem are often conflicting, i.e., it is impossible to find a feasible solution that simultaneously optimizes all objectives. Consequently, it is not surprising that the focus of the multi-objective optimization community has been primarily on developing effective techniques for generating some, if not all, efficient solutions, i.e., solutions in which it is impossible to improve the value of one objective without a deterioration in the value of at least one other objective of the multi-objective optimization problem. In fact, in recent years, significant advances have been made on developing exact solution approaches for multi-objective optimization problems, see for instance Boland et al. (2017b); Dächert and Klamroth (2014); Ehrgott and Gandibleux (2007); Kirlik and Sayın (2014); Lokman and Köksalan (2013); Özlen et al. (2013); Özpeynirci and Köksalan (2010); Przybylski and Gandibleux (2017); Soylu and Yıldız (2016); and Eusébio et al. (2014). This is mainly because understanding the trade-offs between objectives can help decision makers select their preferred solutions.

Although understanding the trade-offs between objectives can be valuable, some researchers argue (see for instance Jorge (2009); and Boland et al. (2017a)) that presenting too many efficient solutions can confuse a decision maker, and so may make selecting a preferred solution almost impossible. An approach that alleviates this issue is finding a preferred solution among the set of efficient solutions directly. This approach is known as optimizing over the efficient set, which is a global optimization problem (Benson, 1984). Let XE be the set of efficient solutions of Problem  (1). Also, let f(x) be a function representing how decision makers will choose their preferred solutions from XE. The problem of optimizing over the efficient set can be stated as follows: maxxXEf(x).

A specific subclass of such optimization problems is maximum multiplicative programs, i.e., problems of the form: maxxXi=1pzi(x),where zi(x) ≥ 0 for all xX and i=1,,p. It is known (see for example Nash, 1950) that a maximum multiplicative program is equivalent to the following problem: maxxXEi=1pzi(x).Therefore, a maximum multiplicative program is a special case of the problem of optimization over the efficient set since we can set f(x)=i=1pzi(x). Overall, there are several studies in the literature about applications of linear maximum multiplicative programs, i.e., all variables are continuous, X is defined by a set of linear constraints, and zi(x) is linear for all i=1,,p. This is mainly because such optimization problems often arise in game theory settings where the x variables represent players’ actions and z(x):=(z1(x),,zp(x)) represents players’ utilities. Examples include computing the Nash solution to a bargaining problem (Nash, 1950, Nash, 1953), computing an equilibrium of a linear Fisher or a Kelly capacity allocation market (Chakrabarty, Devanur, Vazirani, 2006, Eisenberg, Gale, 1959, Jain, Vazirani, 2007, Vazirani, 2012, Vazirani, 2012). Moreover, this class of optimization problems has applications in system reliability as well (Ardakan, Sima, Hamadani, Coit, 2016, Feizabadi, Jahromi, 2017, Zhang, Chen, 2016).

A convex programming solver, for example one that uses an interior point method, can find an optimal solution to a linear maximum multiplicative program in polynomial time (Grötschel et al., 1988). Note that since we assume that the optimal objective value of a linear maximum multiplicative program is strictly positive, it is possible to use i=1plogzi(x) as the objective function. This transformation can help us to solve a linear maximum multiplicative program faster in practice. In fact, Charkhgard et al. (2018) have computationally shown that even a faster way of solving linear maximum multiplicative programs is to reformulate such problems as Second-Order Cone Programs (SOCP) using the technique developed by Ben-Tal and Nemirovski (2001). This is mainly because such a reformulation enables us to use the power of commercial SOCP solvers, e.g., CPLEX SOCP, for solving linear maximum multiplicative programs.

Some authors (see for instance Vazirani, 2012b) argue that because convex programming solvers are significantly slower than linear programming solvers, it may be possible to develop even faster solvers for linear maximum multiplicative programs. In order to do so, one should develop an exact algorithm that can solve a linear maximum multiplicative program by solving a number of (single-objective) linear programs. Using this observation and the fact that linear maximum multiplicative programs are special cases of the problem of optimization over the efficient set of multi-objective linear programs, Charkhgard et al. (2018) were able to develop a linear programming based algorithm to solve a maximum multiplicative programs when p=2 in polynomial time. It is numerically shown that this algorithm outperforms CPLEX SOCP solver significantly, i.e., by a factor of up to three, for large-sized instances.

As an aside, we note that linear maximum multiplicative programs appear to be closely related to linear minimum multiplicative programs (see for instance Gao, Xu, Yang, 2006, Ryoo, Sahinidis, 2003, Shao, Ehrgott, 2014; and Shao and Ehrgott, 2016). Specifically, by changing the objective function of a linear maximum multiplicative programs from max to min a linear minimum multiplicative program is obtained. However, it is known that a linear minimum multiplicative program is NP-hard (Shao and Ehrgott, 2016). Therefore, because of this significant difference, we do not consider this class of optimization problems in this study.

In light of the above, the main contribution of our research is extending the algorithm proposed by Charkhgard et al. (2018) to solve any mixed integer linear maximum multiplicative program with p=2, i.e., those for which some of the decision variables have to take integer values. We propose an effective branch-and-bound algorithm which employs the power the algorithm developed by Charkhgard et al. (2018) for solving mixed integer instances. We also develop several preprocessing and cut generating techniques to improve the solution time of the proposed algorithm. Moreover, the effects of several branching and node selecting strategies are explored. A computational study shows that, for large-sized mixed binary instances, our proposed approach outperforms a commercial solver, i.e., CPLEX Mixed Integer SOCP solver, by a factor of around two on average. Also, for general mixed integer instances, our proposed algorithm outperforms CPLEX Mixed Integer SOCP solver not only on large-sized instances but also on small-sized instances by a factor of two on average.

The remainder of the paper is organized as follows. In Section 2, we provide some preliminaries and explain a high-level description of the algorithm proposed by Charkhgard et al. (2018). In Section 3, we explain our proposed branch-and-bound algorithm in detail. In Section 4, some branching strategies are introduced. In Section 5, some node selecting strategies are presented. In Section 6, we explain some potential enhancement techniques. In Section 7, we conduct an extensive computational study. Finally, in Section 8, we give some concluding remarks.

Section snippets

Preliminaries

A Mixed Integer Linear Maximum Multiplicative Program with p=2 can be stated as follows: maxΠ2i=1yis.t.y=Dx+dAxbx,y0,xRnc×Bnb×Zni,yR2,where nc, nb, and ni represent the number of continuous, binary, and integer decision variables, respectively. Also, D is a 2 × n matrix where n:=nc+nb+ni, d is a 2-vector, A is an m × n matrix, and b is an m-vector.

The focus of this study is on solving Problem (2). We refer to the set X:={xRn:Axb,x0} as the feasible set in the decision space and to the

A branch-and-bound algorithm

Our proposed algorithm is similar to the traditional branch-and-bound algorithm for single-objective mixed integer linear programs. The main difference is that instead of using a linear programming solver to compute dual bounds, we employ the CST algorithm. Next, we provide a detailed explanation of our proposed branch-and-bound algorithm.

The algorithm maintains a queue of nodes, denoted by Tree. The algorithm also maintains a global upper bound, denoted by GUB, and global lower bound, denoted

Branching strategies

Selecting a branching variable is a crucial task in any branch-and-bound algorithm since it can impact the solution time of the algorithm significantly. Ideally, we would like to select a variable for branching that helps us to explore the minimum number of nodes in total. In light of this observation, in this study, we explore some variants of several well-known branching strategies that will define the operation BranchingIndex(x) in Algorithm 1. Let I be the index sets of all binary and

Node selecting strategies

Selecting which node should be popped out in each iteration is another crucial task in any branch-and-bound algorithm since it can impact the solution time of the algorithm significantly. The aim of node selecting strategies is pruning open nodes and ending the queue as quickly as possible. This can be done by either finding a good feasible solution, in order to increase the global lower bound (or primal bound), or decreasing the global upper bound (or dual bound). We implemented five different

Enhancements

In this section, we explain a preprocessing technique which is developed for the aim of producing good global lower bounds and cuts for Problem (2). The preprocessing technique can be called before running Algorithm 1 to possibly improve the performance of this algorithm. Obviously, generating a good global lower/primal bound can be helpful since the nodes of the branch-and-bound tree can be pruned faster. Also, by generating cuts and adding them to the formulation, better global upper/dual

Computational study

As we will explain later in this section, based on the study of Ben-Tal and Nemirovski (2001), Problem (2) can be reformulated as a mixed integer SOCP. So, in this section, we compare the performance of our proposed branch-and-bound algorithm with the performance of the mixed integer SOCP solver of CPLEX 12.7 (CPLEX-MI-SOCP). We implement our algorithm in C++ and use CPLEX 12.7 to solve linear programs and mixed integer programs arising during the course of Algorithm 1 and Algorithm 2. The

Final remarks

We developed a bi-objective linear programming based branch-and-bound algorithm for solving a class of mixed integer linear maximum multiplicative programs (with a bi-linear objective function). This class of optimization problems has only one objective function and it can be solved directly by a commercial mixed integer second-order cone programming solver. However, it was shown that the proposed branch-and-bound algorithm outperforms such a solver by a factor of around 2 on average. Using a

References (42)

  • A.H. Land et al.

    An automatic method of solving discrete programming problems

    Econometrica

    (1960)
  • L. Shao et al.

    An objective space cut and bound algorithm for convex multiplicative programmes

    J. Glob. Optim.

    (2014)
  • V.V. Vazirani

    Rational convex programs and efficient algorithms for 2-player Nash and nonsymmetric bargaining games

    SIAM J. Discrete Math

    (2012)
  • Y.P. Aneja et al.

    Bicriteria transportation problem

    Manag. Sci.

    (1979)
  • M.A. Ardakan et al.

    A novel strategy for redundant components in reliability–redundancy allocation problems

    IIE Trans.

    (2016)
  • P. Belotti et al.

    Mixed-integer nonlinear optimization

    Acta Numer.

    (2013)
  • A. Ben-Tal et al.

    On polyhedral approximations of the second-order cone

    Math. of Oper. Res.

    (2001)
  • M. Bénichou et al.

    Experiments in mixed-integer linear programming

    Math. Program.

    (1971)
  • P. Bonami et al.

    More branch-and-bound experiments in convex nonlinear integer programming

    Preprint ANL/MCS-P1949-0911, Argonne National Laboratory, Mathematics and Computer Science Division

    (2011)
  • D. Chakrabarty et al.

    New results on rationality and strongly polynomial time solvability in Eisenberg-Gale markets

    Internet and Network Economics

    (2006)
  • K. Dächert et al.

    A linear bound on the number of scalarizations needed to solve discrete tricriteria optimization problems

    J. Global Optim.

    (2014)
  • Cited by (24)

    • Optimal sensor placement method for wastewater treatment plants based on discrete multi-objective state transition algorithm

      2022, Journal of Environmental Management
      Citation Excerpt :

      Generally speaking, the sensor placement optimization problem in WWTPs can be converted to a discrete multi-objective optimization problem. For one thing, deterministic algorithms such as branch and bound algorithm (Saghand et al., 2019), dynamic programming (Zeng et al., 2019), filled function method (Zhang et al., 2017), and mixed integer nonlinear programming (Moazeni and Khazaei, 2021) are adopted to solve the optimization problem. Nevertheless, the time complexity of these approaches exhibits exponential characteristics.

    View all citing articles on Scopus
    View full text