Vinícius L De Lima

Cláudio Alves

François Clautiaux
email: francois.clautiaux@math.u-bordeaux.fr

Manuel Iori
email: manuel.iori@unimore.it

José M Valério De Carvalho

Arc Flow Formulations Based on Dynamic Programming: Theoretical Foundations and Applications

Keywords: Combinatorial Optimization, Arc Flow, Dynamic Programming, Acyclic Network, Pseudo-Polynomial

Network flow formulations are among the most successful tools to solve optimization problems. One of such formulations is the arc flow, where variables represent flows on individual arcs of the network. For NP-hard problems, polynomial-sized arc flow models typically provide weak linear relaxations and may have too much symmetry to be efficient in practice. Instead, arc flow models with a pseudo-polynomial size usually provide strong relaxations and are efficient in practice. The interest in pseudo-polynomial arc flow formulations has grown considerably in the last twenty years, in which they have been used to solve many open instances of hard problems. A remarkable advantage of arc flow models is the possibility to solve practical-sized instances directly by a Mixed Integer Linear Programming solver, avoiding the implementation of complex methods based on column generation.

In this survey, we present theoretical foundations of pseudo-polynomial arc flow formulations, by showing a relation between their network and Dynamic Programming (DP). This relation allows a better understanding of the strength of these formulations, through a link with models obtained by Dantzig-Wolfe decomposition. The relation with DP also allows a new perspective to relate state-space relaxation methods for DP with arc flow models. We also present a dual point of view to contrast the linear relaxation of arc flow models with that of models based on paths and cycles. To conclude, we review the main solution methods and applications of arc flow models based on DP in several domains such as cutting, packing, scheduling, and routing.

Introduction

Optimization problems can assume different characterizations, each allowing the reduction of the original problem to other optimization problems, leading to, possibly, different solution methods. One of such characterizations is based on a network, that is, a directed graph with costs on the arcs and two special nodes, referred to as source and sink, and is the base of the well-known network flow problems (see, e.g., Ahuja et al. [START_REF] Ahuja | Network flows: theory, algorithms, and applications[END_REF]). A network flow problem is to determine a flow, from the source to the sink of the network, that satisfies the flow conservation on each node and possible additional side constraints on the flow on the arcs, and that optimizes an objective function based on the cost of the arcs. The list of real-life problems that can be solved as network flow problems is extensive, including not only direct applications (i.e., the network is an input of the problem), as vehicle routing, telecommunication network planning, and train scheduling (see, e.g., Gouveia et al. [START_REF] Gouveia | Layered graph approaches for combinatorial optimization problems[END_REF], Minoux [START_REF] Minoux | Multicommodity network flow models and algorithms in telecommunications[END_REF], and Cacchiani and Toth [START_REF] Cacchiani | Nominal and robust train timetabling problems[END_REF]), but also indirect ones (i.e., the network must be constructed), as cutting and packing, scheduling, and project management (see, e.g., Delorme and Iori [START_REF] Delorme | Enhanced pseudo-polynomial formulations for bin packing and cutting stock problems[END_REF], Kramer et al. [START_REF] Kramer | Mathematical formulations for scheduling jobs on identical parallel machines with family setup times and total weighted completion time minimization[END_REF], and Riedler et al. [START_REF] Riedler | An iterative time-bucket refinement algorithm for a high-resolution resource-constrained project scheduling problem[END_REF]).

When the side constraints are sufficiently simple, network flow problems can be solved by algorithms whose time complexity is polynomial in the network size. However, when the side constraints are complex, these problems become hard, and one must rely on enumerative approaches to look for an optimal solution. Mixed Integer Linear Programming (MILP) has been a successful tool to solve hard network flow problems, as the flow conservation and the side constraints can be, generally, formulated as linear constraints. Two main paradigms to model network flow problems are the path formulations and the arc flow formulations. Path formulations have variables corresponding to flow on paths from the source to the sink and cycles, and are frequently associated with setcovering, set-packing, or set-partitioning models. In contrast, arc flow formulations have variables corresponding to flow on individual arcs. The Flow Decomposition Theorem by Ahuja et al. [START_REF] Ahuja | Network flows: theory, algorithms, and applications[END_REF] guarantees that both formulations produce equivalent models when based on the same network.

When considering hard problems, path formulations have a large number of variables, as the number of paths and cycles can be exponential on the network size. Most of the time, to solve the resulting path models, one has to rely on sophisticated methods based on column generation and branch-and-price algorithms (see, e.g., Desaulniers et al. [START_REF] Desaulniers | Column Generation[END_REF] and Sadykov and Vanderbeck [START_REF] Sadykov | Column generation for extended formulations[END_REF]). On the other hand, arc flow formulations have to explicitly model the flow conservation, resulting in a larger number of linear constraints. Still, their overall size can be substantially smaller (as the number of feasible paths may be exponentially larger than the number of arcs), while the linear relaxation bound is the same. The difference in size is a remarkable advantage of arc flow formulations, as they may be used to solve medium-sized instances directly by a commercial MILP solver, avoiding the implementation of complex methods.

Some hard problems can be formulated as compact (i.e., polynomial-sized) models. Although their size is favorable, these models are usually associated with weak linear relaxations and very symmetrical solution spaces, leading to an overly extensive enumeration on branch-and-bound algorithms. To overcome such inefficiency, one may rely on the Dantzig-Wolfe decomposition (see Dantzig and Wolfe [START_REF] Dantzig | The decomposition algorithm for linear programs[END_REF]), which can obtain models with stronger linear relaxations and less symmetry. The models resulting from Dantzig-Wolfe (DW) decomposition usually have exponentially more variables than the original model and are solved by column generation. When the associated pricing problem is solved by Dynamic Programming (DP), the model can be seen as a path formulation, where each variable corresponds to a path in the network inherent from the DP problem. From this observation, one can devise an equivalent arc flow model based on the DP network. Originated by a DW decomposition, the resulting arc flow model will, possibly, have a strong linear relaxation and a less symmetrical solution space, compared to the original model.

To obtain strong models by a DW decomposition, one may have to pay the price of having an increased complexity on the pricing problem, as such complexity usually becomes pseudo-polynomial or exponential. When the size of the DP network from the pricing problem is pseudo-polynomial, the resulting arc flow model can still be used to solve medium-sized instances in practice directly by a MILP solver. On the other hand, when the DP network is too large (possibly exponential), one can obtain smaller (yet still strong) arc flow models relying on a state-space relaxation of the DP. Different state-space relaxations lead to arc flow models with different sizes and different linear relaxation strength, implying in a flexible possibility to balance size and strength of arc flow models.

To the best of our knowledge, Ford and Fulkerson [START_REF] Ford | Constructing maximal dynamic flows from static flows[END_REF] were the first to propose a pseudo-polynomial arc flow model, which was based on a time-expanded network and was used to solve the maximal dynamic flow problem. Already in the sixties, Shapiro [START_REF] Shapiro | Dynamic programming algorithms for the integer programming problem-I: The integer programming problem viewed as a knapsack type problem[END_REF] studied the relation between DP and Integer Programming, by modeling the knapsack problem as a pseudo-polynomial network flow problem. More than ten years later, Wolsey [START_REF] Wolsey | Valid inequalities, covering problems and discrete dynamic programs[END_REF] proposed a general methodology to build packing and covering models from the set of feasible solutions of DP problems. As an application, he introduced a pseudo-polynomial arc flow model based on a DP network of the knapsack problem for the cutting stock problem (CSP), a strongly N P-hard problem. Due to the context, Wolsey [START_REF] Wolsey | Valid inequalities, covering problems and discrete dynamic programs[END_REF] did not present computational experiments for the model, and such formulations did not get much attention for decades. It was more than twenty years later that Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF] independently proposed this model, used it to solve to (integer) optimality open instances in the CSP literature, and showed that it is equivalent to the Gilmore-Gomory model [START_REF] Gilmore | A linear programming approach to the cutting-stock problem[END_REF][START_REF] Gilmore | A linear programming approach to the cutting stock problem -part II[END_REF], a path model obtained from a Dantzig-Wolfe decomposition.

Since the work by Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF], the popularity of pseudo-polynomial arc flow formulations based on DP has grown, and several different applications to N P-hard problems have appeared in the literature. Large instances have been solved for the first time to proven optimality by arc flow models in several cutting, packing, and scheduling problems. Also, arc flow formulations have effectively modeled complex problems involving, for instance, multiple-stage cutting processes or the presence of setups.

Some previous surveys considered arc flow models on specific applications (see, e.g., Valério de Carvalho [START_REF] Valério De Carvalho | LP models for bin packing and cutting stock problems[END_REF] and Delorme et al. [START_REF] Delorme | Bin packing and cutting stock problems: Mathematical models and exact algorithms[END_REF] for bin packing and cutting stock problems, and Cattaruzza et al. [START_REF] Cattaruzza | Vehicle routing problems with multiple trips[END_REF] for vehicle routing problems with multiple trips). Skutella [START_REF] Skutella | An introduction to network flows over time[END_REF] presented a survey on problems based on dynamic flow, which is also called "flows over time". One of the main formulations for this class of problems is the arc flow based on time-expanded networks, introduced by Ford and Fulkerson [START_REF] Ford | Constructing maximal dynamic flows from static flows[END_REF], which is derived from acyclic graphs of pseudo-polynomial size. A generalization of such networks is the layered graphs, which considers, for instance, networks from capacity-indexed models for vehicle routing problems. Modeling techniques and efficient solution methods for pseudo-polynomial arc flow formulations based on layered graphs were surveyed by Gouveia et al. [START_REF] Gouveia | Layered graph approaches for combinatorial optimization problems[END_REF]. Other surveys, such as Sadykov and Vanderbeck [START_REF] Sadykov | Column generation for extended formulations[END_REF], focused instead on how arc flow formulations can be used to devise effective branch-and-price algorithms. Conforti et al. [START_REF] Conforti | Extended formulations in combinatorial optimization[END_REF] and Lancia and Serafini [START_REF] Lancia | Deriving compact extended formulations via LP-based separation techniques[END_REF] studied techniques to transform large extended formulations into compact ones. In the case of network flow formulations, this occurs when path models are transformed into equivalent arc flow models with (possibly exponentially) fewer variables.

In this survey, we extend the previous discussion to provide a base for some reasons behind the (primal) strength of pseudo-polynomial arc flow formulations. Based on the Flow Decomposition Theorem, we show how DW decomposition can derive strong arc flow models. We also discuss how the state-space relaxation method allows a balance between strength and complexity when constructing arc flow models. This relation between state-space relaxation and arc flow formulations can implicitly relate different arc flow models in the literature (see Section 4). We provide a dual insight that may explain arc flow models' practical computational efficiency over their equivalent path models, which is the richer description of the dual space. The relevance is that a better description of the dual space leads to less primal degeneracy, which is headwind for LP simplex (vertex) algorithms used in branch-and-bound. We also discuss the main solution methods to solve large-scale arc flow models and present the main applications considered in the literature.

The remainder of this paper is organized as follows. Section 2 presents the theoretical foundations of network flow formulations and DP. The relationship between strong arc flow formulations and DW decomposition is presented in Section 3. In Section 4, we present some discussion on how the state-space relaxation can be used to obtain smaller arc flow models. In Section 5, we show how arc flow formulations present a more detailed dual space than path formulations, which leads to a better convergence of the LP solution. The state-of-the-art methods to solve large-scale arc flow models and the main applications are shown in Sections 6 and 7, respectively. Finally, our concluding thoughts are presented in Section 8.

Network Flow Formulations and Dynamic Programming

A network N is composed of a directed graph G = (V, A), where V is the set of nodes (vertices) and A ⊆ {(u, v) | u, v ∈ V} is the set of arcs, and of a cost function c : A → R that maps each arc to a cost. In addition, a network has two special nodes in V, called source (v source ) and sink (v sink ), such that no arcs in A enters v source or leaves v sink . We denote by P the set of all paths from v source to v sink , and by A(p) the set of arcs of a path p ∈ P. The cost of an arc (u, v) ∈ A is denoted by c(u, v), and the cost of a path p ∈ P is given by cp = (u,v)∈A(p) c(u, v).

A feasible flow in a network must satisfy the flow conservation constraint: the flow entering a node must be equal to the flow leaving it, except for v source and v sink , where there is only outgoing and incoming flow, respectively. By the flow conservation, the flow leaving v source is always equal to the flow entering the v sink . In general terms, a network flow problem is to determine a feasible flow that satisfies side constraints and optimizes an objective function based on the cost of the arcs.

A fundamental network flow problem is the longest path problem (LPP): find a longest path, i.e., a unitary flow of maximum cost, from v source to v sink . When the network does not have cycles of negative cost, a longest path can be found in polynomial time with respect to the network size. In particular, when the network is acyclic, a longest path can be found in O(|A|) by a topological ordering of the nodes (see, e.g., Ahuja et al. [START_REF] Ahuja | Network flows: theory, algorithms, and applications[END_REF]). The LPP often appears in solution methods for more complex network flow problems. Such problems have, for instance, side constraints characterized by generalized upper and lower bounds on the amount of flow on subsets of arcs (see, e.g., Clautiaux et al. [START_REF] Clautiaux | Iterative aggregation and disaggregation algorithm for pseudo-polynomial network flow models with side constraints[END_REF]).

In practice, the solution of network flow problems can be given as a set of paths and cycles with a positive flow (where a cycle is a path that starts and ends at the same node) or as the amount of flow on each arc of the network. This gives rise to two different classes of formulations for network flow problems: path formulations and arc flow formulations (see Ahuja et al. [START_REF] Ahuja | Network flows: theory, algorithms, and applications[END_REF]).

Path formulations consider non-negative variables representing the flow on each path and each cycle of the network. In this way, the flow conservation is implicitly imposed on the variables. Path formulations usually have an exponential number of variables with respect to the network size. Despite the large number of variables, such formulations have been successfully solved in the literature by column generation based algorithms (see, e.g., Poggi and Uchoa [START_REF] Poggi | New exact algorithms for the capacitated vehicle routing problem[END_REF]).

In contrast to path formulations, arc flow formulations consider the flow on individual arcs and the flow conservation is explicitly modeled by linear constraints. Let variable ϕ (u,v) ∈ R + , for each arc (u, v) ∈ A, represent the amount of flow on arc (u, v), and let variable z ∈ R + represent the total flow on the network. Flow conservation constraints can be formulated as:

(u,v)∈A ϕ (u,v) - (v,w)∈A ϕ (v,w) =      -z, if v = v source , z, if v = v sink , 0, otherwise, ∀v ∈ V. (1)
The underlying matrix from (1) is totally unimodular (see, e.g., Nemhauser and Wolsey [START_REF] Nemhauser | Integer and Combinatorial Optimization[END_REF]), which is an interesting property, as LP models where the constraints matrix is totally unimodular have the integrality property, i.e., every vertex of the corresponding polytope is integer, implying the existence of an integer optimal solution if the right-hand side of the constraints is integer.

Although the flow conservation constraints must be explicitly included, differently from path formulations, arc flow formulations have polynomial size with respect to network size. An important result that relates these two classes of formulations is the following: Theorem 1 (Flow Decomposition Theorem (Ahuja et al. [START_REF] Ahuja | Network flows: theory, algorithms, and applications[END_REF])). Every path and cycle flow has a unique representation as non-negative arc flows. Conversely, every non-negative arc flow can be represented as a path and cycle flow (though not necessarily uniquely) with the following two properties: Theorem 1 proves the equivalence between arc flow and path formulations: an arc flow solution can be transformed into positive flow on a set of paths and cycles, and a solution of path formulations can be decomposed into flow on individual arcs. Consequently, arc flow and path formulations based on the same network, produce the same linear relaxation bounds for integer problems.

Arc flow and path formulations are also equivalent to the time-indexed formulations, first proposed by Sousa and Wolsey [START_REF] Sousa | A time indexed formulation of non-preemptive single machine scheduling problems[END_REF] and often used to model scheduling problems (see, e.g., Pessoa et al. [START_REF] Pessoa | Exact algorithm over an arc-timeindexed formulation for parallel machine scheduling problems[END_REF] and Lancia et al. [START_REF] Lancia | A time-indexed LP-based approach for min-sum job-shop problems[END_REF]). Such equivalence has been shown in different contexts starting from Valério de Carvalho [START_REF] Valério De Carvalho | LP models for bin packing and cutting stock problems[END_REF], who proved by a unimodular transformation the equivalence of arc flow and time-indexed formulations for the CSP.

In the remainder of this section, we define Dynamic Programming and its relation to acyclic networks flow formulations.

Dynamic Programming and Arc Flow Formulations

(Discrete) Dynamic Programming (DP) is a well-known method, proposed in the fifties (see, e.g., Bellman [START_REF] Bellman | Dynamic Programming[END_REF]), to solve combinatorial optimization problems that can be decomposed into a sequence of decisions, often represented by stages, each corresponding to a decision step. DP models are defined by a state space S, where each state s ∈ S is characterized by a set of entities. Each state is defined, for instance, by the subset of clients already visited in routing problems (see, e.g., Desrochers et al. [START_REF] Desrochers | A new optimization algorithm for the vehicle routing problem with time windows[END_REF]) or by the level of usage of a given resource in, e.g., cutting, packing or scheduling problems (see, e.g., Christofides and Hadjiconstantinou [START_REF] Christofides | An exact algorithm for orthogonal 2-D cutting problems using guillotine cuts[END_REF]).

A key aspect in DP modeling is the fact that the description of a state s ∈ S should be sufficient to recognize the admissible decisions for s, which is coined as the no-memory property of DP. Then, when stages are considered, problems are divided into a sequence of sub-problems, so that the solution of a sub-problem depends only on the sub-problems from the previous stage. Nowadays, some authors changed the perspective of DP from the stage-dependent description to a table-filling method, as described by, e.g., Ahuja et al. [START_REF] Ahuja | Network flows: theory, algorithms, and applications[END_REF].

A DP model can be represented by a recursive function, in which the value of a state is only based on the values of the precedent states and the cost (contribution) of the decisions leading to that state. Formally, for each state s ∈ S, let ∆(s) be the set of precedent states, and c(r, s) ∈ R be the cost required to move from r ∈ ∆(s) to s. The state space S contains two special states, s 0 and s * , representing the initial condition of the recursion and the optimal solution of the problem, respectively. No state precedes s 0 (∆(s 0 ) = ∅) and s * does not precede any other state (s * / ∈ ∆(s), ∀s ∈ S). The DP recursion we consider is given by:

f DP (s) = max {r∈∆(s)} {f DP (r) + c(r, s)}, if s = s 0 , 0, if s = s 0 , ∀s ∈ S. (2)
Based on the recursion, a DP model can be defined on a directed acyclic graph (DAG), where vertices and arcs correspond to states and decisions, respectively. In this characterization, the DP solution is given by a longest path, that is, a path from s 0 to s * with maximum total cost (profit). In some cases, the description of the recursion produces states that are not in any solution from the initial state to the goal state, and such states can be disregarded.

The previous characterization of DP is a classical definition, and one of the most used by the integer programming literature. Nevertheless, other definitions of DP were proposed. For instance, Martin et al. [START_REF] Martin | Polyhedral characterization of discrete dynamic programming[END_REF] defined DP over a directed acyclic hypergraph, to obtain a better polyhedral characterization of a class of combinatorial optimization problems. This generalization was later used to solve network flow problems (see, e.g., Clautiaux et al. [START_REF] Clautiaux | Combining dynamic programming with filtering to solve a four-stage two-dimensional guillotine-cut bounded knapsack problem[END_REF]).

Following our DP definition, the DAG from a DP model produces the dynamic programming network N DP . Each node is associated with a state, that is, V(N DP ) ≡ S, where states s 0 and s * correspond to nodes v source and v sink , respectively. The set of arcs is defined by A(N DP ) = {(r, s) | s ∈ S, r ∈ ∆(s)}, and the cost c(r, s) of an arc (r, s) ∈ A is equivalent to the decision cost c(r, s) for moving from state r to state s.

The fact that DP can be seen as a LPP in the DP network provides a generic recipe to transform a DP model into the arc flow model given by: max

(u,v)∈A(N DP ) c(u, v)ϕ (u,v) , (3) s.t.
:

(u,v)∈A(N DP ) ϕ (u,v) - (v,w)∈A(N DP ) ϕ (v,w) =      -1, if v = v source , 1, if v = v sink , 0, otherwise, ∀v ∈ V(N DP ), (4)
ϕ (u,v) ∈ {0, 1}, ∀(u, v) ∈ A(N DP ). ( 5
)
Model (3)-( 5) considers flow conservation constraints with a unitary flow (z = 1) and no side constraints. The objective function is to maximize the cost of the selected path, given by the sum of the contributions of the state decisions. As this model has only flow conservation constraints, it has the integrality property, because, as previously discussed, its underlying matrix is totally unimodular. This property is linked with the fact that the LPP on a DAG can be solved in linear time with respect to the number of arcs (see, e.g., Bellman [START_REF] Bellman | Dynamic Programming[END_REF]).

In strongly N P-hard problems, DP often provides pseudo-polynomial algorithms to solve subproblems that determine partial plans. Examples of such sub-problems are: finding a single cutting/packing pattern on cutting and packing problems (see, e.g., Valério de Carvalho [START_REF] Valério De Carvalho | LP models for bin packing and cutting stock problems[END_REF]); obtaining a schedule in a single machine in scheduling problems (see, e.g., Kramer et al. [START_REF] Kramer | Mathematical formulations for scheduling jobs on identical parallel machines with family setup times and total weighted completion time minimization[END_REF]); determining a route of a single vehicle on vehicle routing problems (see, e.g., Poggi and Uchoa [START_REF] Poggi | New exact algorithms for the capacitated vehicle routing problem[END_REF]).

The DP network from the sub-problems (partial plans) may be used to derive arc flow models to solve the main problem (global plan). If the global plan is a strongly N P-hard problem (which is often the case), these models do not have the integrality property, unless P = N P, but they usually provide strong relaxations. We provide examples of DP networks of two problems that are often associated with partial plans.

Example on the Knapsack Problem

Let us consider an example on the knapsack problem (KP): given a knapsack with capacity W ∈ Z + and a set I = {1, 2, . . . , n} of items, each item i ∈ I with a weight w i ∈ Z + , a profit p i ∈ Z + , and a maximum number of copies d i ∈ Z + , determine the number x i ≤ d i of copies of each item i ∈ I in the solution, so that i∈I w i x i ≤ W and i∈I p i x i is maximum (see, e.g., Martello and Toth [START_REF] Martello | Knapsack Problems: Algorithms and Computer Implementations[END_REF]). The optimal solution value f KP (i, W ) of a knapsack sub-problem that considers the items {1, 2, . . . , i} and a partial capacity W can be recursively computed by:

f KP (i, W ) = max l∈{0,1,...,min{d i , W /w i }} {f KP (i -1, W -w i l) + p i l}, if i > 0 and W > 0, 0, otherwise. (6)
The optimal KP solution value is given by OP T (I, W ) = max {0<W ≤W } f KP (|I|, W ) and it is associated to a DP model where the state space S is a subset of {(i, W ) | i ∈ I, W ∈ {0, 1, . . . , W }} ∪ {s * }, each partial set of items corresponds to a stage, the initial condition state is s 0 = (0, 0), and the goal is represented by a dummy state s * , so that the precedent states in ∆(s * ) are related to the recursion of OP T (I, W ). The set of precedent states of each state (i, W ) ∈ S \ {s * }, where i > 0, is ∆((i, W )) = {(i-1, W -w i l) | w i l ≤ W , l ∈ {0, 1, . . . , d i }}, and the decision cost for reaching (i, W ) from a precedent state (i-1,

W -w i l) ∈ ∆((i, W )) is c((i -1, W -w i l), (i, W )) = p i l. The set of precedent states of s * is ∆(s * ) = {(|I|, W ) | W ∈ {0, 1, . . . , W }} and the cost to move from a precedent state (|I|, W ) ∈ ∆(s * ) to s * is c((|I|, W ), s * ) = 0.
Let N KP be a DP network for the KP. The set of nodes V(N KP ) ≡ S corresponds to the set of states, where v source and v sink are associated with s 0 and s * , respectively. The set of arcs is A(N KP ) = ∪ {i∈I,l∈{0,1,...,min{d i , W /w i }} A il ∪ A S . For each i ∈ I, the set

A il = {((i -1, W - w i l), (i, W )) | (i, W ) ∈ S, (i -1, W -w i l) ∈ ∆((i, W ))
} contains the arcs corresponding to the decision of choosing l copies of i in the solution, and these arcs have profit p i l. The set

A S = {((n, W ), v sink ) | (n, W ) ∈ S}
contains arcs, called loss arcs, that link the nodes from the last stage to v sink , and their profit is 0.

As an example, Figure 1 shows the network for a KP with capacity W = 8, and three items having w 1 = 4, w 2 = 3, w 3 = 2, p 1 = 8, p 2 = 5, p 3 = 4, and

d 1 = d 2 = d 3 = 1.
There is a node s * representing v sink , a node (i, W ) for each state, and v source = (0, 0). Arcs A S are depicted as dotted links, and for every item i ∈ I, the arcs in A i1 and A i0 are depicted as full and dashed links, respectively. The arcs that do not belong to any path from (0, 0) to s * are disregarded. By definition, the only non-zero profit arcs are the ones from A i1 , and their profits are shown in the figure. The bold arcs are from the longest path, i.e., the optimal solution, which contains items 1 and 2 and has total profit 13.

The network N DP can be used in the generic recipe previously discussed, to derive an arc flow model for the KP with O(|I|W ) nodes and arcs. Although the resulting arc flow model has pseudopolynomial size and has the integrality property, solving it with LP algorithms is usually not as fast as solving the problem by DP. However, the LP model can be a base for interesting results. For instance, Andrew Boyd [START_REF] Boyd | A pseudopolynomial network flow formulation for exact knapsack separation[END_REF] extended this model to solve the knapsack separation problem, which is a generic tool to generate cutting planes for MILP formulations.

Example on the Elementary Shortest Path Problem with Resource Constraints

The elementary shortest path problem with resource constraints (ESPPRC) is linked with determining the best route of a single vehicle in vehicle routing problems (see, e.g., Lozano et al. [START_REF] Lozano | An exact algorithm for the elementary shortest path problem with resource constraints[END_REF]). In the ESPPRC there is a resource capacity and a directed graph. Each vertex is associated with a resource consumption and each arc is associated with a cost. The objective is to find a path with minimum cost such that: (i) each vertex is visited at most once (elementary constraint); and (ii) the total resource consumption from the vertices in the path does not exceed the resource capacity (resource constraint).

1, 0 In the context of vehicle routing, the vertices are given by I = {0, 1, . . . , n}, where 0 represents the depot and the other n vertices represent the clients. The solution must start and finish at the depot. Generally, the ESPPRC might consider a set of resources, but in this example we are concerned only with a single resource W , which is associated with the load capacity of a vehicle. Let e (i,j) ∈ R be the cost of arc (i, j) ∈ I × I and w i ∈ R + be the resource consumption of i ∈ I.

Given a set of clients S ⊆ I \ {0} that satisfies the resource constraint (i.e., j∈S w j ≤ W ), we denote by f ESP P RC (S, i) the cost of a path of minimum cost from the depot 0 to a client i ∈ S that visits every client in S exactly once. A client j ∈ S \ {i} that precedes i in an optimal path related to f ESP P RC (S, i) is one that minimizes the sum of the distance cost e (j,i) from j to i and the cost f ESP P RC (S \ {i}, j) of a path of minimum cost that visits every client in S \ {i} exactly once and finishes in j ∈ S \ {i}. This relation can be mapped into the following recursion:

f ESP P RC (S, i) = min j∈S\{i} {f ESP P RC (S \ {i}, j) + e (j,i) }, if S = ∅ and i > 0, 0, otherwise. (7)
The optimal ESPPRC solution value is given by OP T (I, e, r) = min{f ESP P RC (S, i) + e (i,0) | S ⊆ I, i ∈ S, j∈S w j ≤ W }. The recursion can be transformed into a maximization problem, by inverting the sign of each e (i,j) , resulting in a DP model. The state space S is a subset of {(S, i) | S ⊆ I, i ∈ S, j∈S w j ≤ W } ∪ {s * }, where the initial state is s 0 = (∅, 0) and the goal state s * has precedent states related to the recursion of OP T (I, e, r). For each state (S, i) ∈ S \ {s * }, the set of precedent states is ∆((S, i)) = {(S \ {i}, j) | j ∈ S \ {i}}, and the decision cost to move from state (S \ {i}, j) ∈ ∆((S, i)) to (S, i) is c((S \ {i}, j), (S, i)) = e (j,i) . The set of precedent states of s * is ∆(s * ) = S \ {s * }, and the cost to move from state (S, i) ∈ ∆(s * ) to s * is c((S, i), s * ) = e (i,0) .

Let N ESP P RC be the DP network for the ESPPRC obtained from the state space S presented above. The set of nodes V(N ESP P RC ) ≡ S corresponds to the state space, where v source and v sink are associated with (∅, 0) and OP T (I, e, r), respectively. The set of arcs A(N ESP P RC ) = ∪ i∈I A i contains arcs A i = {((S \ {i}, j), (S, i)) ∈ V × V} related to the decision of visiting client i ∈ I \ {0}, and arcs A 0 = {((S, j), v sink ) ∈ V × V} related to the decision of returning to the depot.

The network N ESP P RC can be the base of an arc flow model for the ESPPRC, following the generic recipe previously presented. However, the number of subsets S ⊆ I such that j∈S w j ≤ W is exponential, implying that the state space presented for the ESPPRC is also exponential. Consequently, the corresponding arc flow model has an exponential number of variables and constraints, and it is not practical to solve it directly. Practical techniques that can be used to overcome this inconvenience are described in Section 4 [START_REF] Boyd | A pseudopolynomial network flow formulation for exact knapsack separation[END_REF]

Dantzig-Wolfe Decomposition and Network Flow Formulations

Several challenging problems admit compact MILP models that, although having a reasonable (polynomial) size, are usually associated with weak linear relaxations. In such cases, reformulation methods can obtain models with stronger linear relaxation. One of such methods is the well-known Dantzig-Wolfe (DW) decomposition (see Dantzig and Wolfe [START_REF] Dantzig | The decomposition algorithm for linear programs[END_REF]), which has been successfully used in many applications. The resulting models may be stronger, but they usually have an exponential number of variables, and complex methods are required to solve them in practice. In the following, we show how models obtained from DW decomposition can be the base to derive equivalent arc flow models with smaller (and possibly practical) size.

First, we show how the DW decomposition can be applied to Linear Programming (LP) models. Let us express the feasible solution region of the LP model as:

X LP = {x ∈ R n + | Ax ≥ b, x ∈ X}, (8)
where

A ∈ R m×n , b ∈ R m ,
and X is a bounded convex polytope of a set of constraints. According to the Minkowski's Theorem, any point in X can be represented as a convex combination of the vertices (extreme points) of X (for the general case of an unbounded polyhedron, it is also necessary to consider a non-negative linear combination of the extreme rays of the polyhedron, see, e.g., Nemhauser and Wolsey [START_REF] Nemhauser | Integer and Combinatorial Optimization[END_REF]). Then, by defining Q(X) as the set of vertices of X, it follows:

X = {x ∈ R n + | x = q∈Q(X)
qλ q , q∈Q(X)

λ q = 1, λ q ≥ 0, ∀q ∈ Q(X)}. (9)
By substituting x as in ( 9) in ( 8), the feasible region becomes:

X LP = {λ ∈ R |Q(X)| + | q∈Q(X) (Aq)λ q ≥ b, q∈Q(X) λ q = 1}. ( 10
)
The reformulated problem, called DW model, has a variable associated with each vertex of X, and a new set of constraints, usually referred to as convexity constraints (see, e.g., Lübbecke and Desrosiers [START_REF] Lübbecke | Selected topics in column generation[END_REF]). The decomposition applied to LP models preserves the optimal solution value. However, in the context of MILP, to obtain linear models stronger than the original linear relaxation, the integrality constraints must be implicitly considered in the reformulated variables. A possibility is to reformulate over the vertices of Conv{x ∈ X and integer}, the convex hull of the integer points in X (see, e.g., Nemhauser and Wolsey [START_REF] Nemhauser | Integer and Combinatorial Optimization[END_REF]), to optimize over the set:

X DW = {x ∈ R n + |Ax ≥ b, x ∈ Conv{x ∈ X and integer}}. (11)
A typical issue from the DW decomposition is that the resulting model may have an exponential number of variables. To solve it, one may rely on the column generation method, a technique to solve LP models with a large number of variables (see, e.g., Lübbecke and Desrosiers [START_REF] Lübbecke | Selected topics in column generation[END_REF]). The method solves a restricted version of the LP model with only a subset of variables by iteratively solving a pricing problem. The pricing generates non-basic variables (columns) that are candidates to improve the current restricted model. If no such variable exists, then the current basis of the restricted model is optimal for the original model, and the method halts.

When the pricing problem of a DW model can be solved by DP, each column of the model can be associated with a path in the DP network, and the model can be seen as a path formulation. In such cases, the coefficients of a column are given as contributions from the arcs of the corresponding path. In addition, due to the no-memory property of the DP, for each column, the contribution k (u,v) ∈ R of an arc (u, v) to a row coefficient k ∈ C, where C is the set of constraints, is independent from other arcs. Then, given a DP network N , and d k ∈ R, for every constraint k ∈ C, we obtain a general path formulation:

min p∈P(N ) cp λ p , (12)
s.t.:

p∈P(N ) (u,v)∈A(p) k (u,v) λ p ≥ d k , ∀k ∈ C, (13)
λ p ∈ Z + , ∀p ∈ P(N ). ( 14
)
The objective function [START_REF] Braga | Exact solution of the multi-trip inventory routing problem using a pseudo-polynomial model[END_REF] minimizes the total cost from the paths in the solution, and ( 13) is a set of general linear constraints. As discussed previously, due to the flow decomposition theorem, the path formulation ( 12)-( 14) can be reformulated as the following arc flow formulation:

min (u,v)∈A(N ) c(u, v)ϕ (u,v) , (15) s.t.
:

(u,v)∈A(N ) ϕ (u,v) - (v,w)∈A(N ) ϕ (v,w) =      -z, if v = v source , z, if v = v sink , 0, otherwise, ∀v ∈ V(N ), (16)
(u,v)∈A(N ) k (u,v) ϕ (u,v) ≥ d k , ∀k ∈ C, (17)
z ≥ 0, (18)
ϕ (u,v) ∈ Z + , ∀(u, v) ∈ A(N ). ( 19
)
The objective function [START_REF] Cacchiani | Nominal and robust train timetabling problems[END_REF] minimizes the total cost from the arcs in the solution, ( 16) are the flow conservation constraints, and ( 17) are general linear constraints, adapted from [START_REF] Brandão | Bin packing and related problems: General arc-flow formulation with graph compression[END_REF].

DW decomposition can generate path formulations that are usually associated with strong linear relaxations, and equivalent arc flow formulations can be derived from the DP network of the underlying pricing problem. As pointed before, to obtain stronger relaxations, one should reformulate over the convex hull of the integer points in a polytope that does not have the integrality property. Although a stronger linear relaxation is obtained, this kind of reformulation leads to pricing problems that are N P-hard.

On the other hand, for arc flow models, the price to pay to obtain a stronger relaxation (i.e., to obtain a set equivalent to X DW ) is to use a set of constraints that defines a DP network with a pseudo-polynomial or an exponential number of arcs.

Usually, arc flow models of practical size can be derived when the resulting pricing problem has pseudo-polynomial complexity. However, when the pricing problem is strongly N P-hard, the resulting arc flow model is generally too large to be solved in practice. When the pricing problem from path formulations is too difficult in practice, one may rely on relaxation methods. We show in Section 4 one of such relaxation methods, which can be used to derive smaller networks and obtain arc flow formulations that are still strong and have practical size. In the next sections, we present two examples of arc flow formulations derived from DW decomposition, with pseudo-polynomial and exponential size, respectively.

Example on the Cutting Stock Problem

We present an example of an arc flow model derived from a DW decomposition for the Cutting Stock Problem (CSP). In the CSP, a roll of width W and a set I = {1, 2, . . . , n} of items are given, such that each item i ∈ I has a demand d i and a width w i . The objective is to cut the demand of all items from the minimum number of rolls.

Given an upper bound K on the minimum number of rolls, following Martello and Toth [START_REF] Martello | Knapsack Problems: Algorithms and Computer Implementations[END_REF], the CSP can be formulated as:

min K j=1 y j , (20) s.t.
:

n i=1 w i x ij ≤ W y j , j = 1, 2, . . . , K, (21)
K j=1 x ij ≥ d i , ∀i ∈ I, (22)
y j ∈ {0, 1}, j = 1, 2, . . . , K, (23)
x ij ∈ Z + , ∀i ∈ I. (24)
Each roll j = 1, 2, . . . , K is associated with a binary variable y j that is equal to 1 if and only if roll j is used in the solution. The integer variables x ij represent the number of copies of item i ∈ I that is cut from roll j. The objective function [START_REF] Cattaruzza | Vehicle routing problems with multiple trips[END_REF] is to minimize the number of rolls cut in the solution. Constraints [START_REF] Christofides | An exact algorithm for orthogonal 2-D cutting problems using guillotine cuts[END_REF] ensure that the size of each roll is satisfied, whereas constraints [START_REF] Christofides | State-space relaxation procedures for the computation of bounds to routing problems[END_REF] ensure that the demand of each item is satisfied.

According to Martello and Toth [START_REF] Martello | Knapsack Problems: Algorithms and Computer Implementations[END_REF], the linear relaxation of ( 20)-( 24) is equivalent to the continuous lower bound that is obtained from the minimum length required to cut all of the demand from a stock with unlimited width, i.e., i∈I w i d i /W . This bound is known to be weak in practice, and its worst-case performance ratio asymptotically tends to 1/2. To obtain a stronger bound, a DW decomposition can be applied to the model above (see, e.g., Vance [START_REF] Vance | Branch-and-price algorithms for the one-dimensional cutting stock problem[END_REF]).

Constraints [START_REF] Christofides | An exact algorithm for orthogonal 2-D cutting problems using guillotine cuts[END_REF] correspond to K identical fractional knapsack polytopes. When integrality constraints ( 23) and ( 24) are taken into account, the K identical polytopes correspond to K identical sets P CSP of integer knapsack solutions. A DW decomposition that includes constraints ( 21), [START_REF] Cire | A network-based formulation for scheduling clinical rotations[END_REF], and [START_REF] Clautiaux | Iterative aggregation and disaggregation algorithm for pseudo-polynomial network flow models with side constraints[END_REF] in the sub-problem results in the following set-covering model:

min p∈P CSP λ p , (25)
s.t.:

p∈P CSP a ip λ p ≥ d i , ∀i ∈ I, (26)
λ p ∈ Z + , ∀p ∈ P CSP . (27)
In the CSP, the integer knapsack solutions from P CSP are called cutting patterns (or just patterns, for short, in the following), and each of them represents the cutting of a single piece of stock. The objective function [START_REF] Clautiaux | Combining dynamic programming with filtering to solve a four-stage two-dimensional guillotine-cut bounded knapsack problem[END_REF] is to minimize the number of cutting patterns. Constraints [START_REF] Conforti | Extended formulations in combinatorial optimization[END_REF] ensure that the demand of each item is satisfied, where a ip is the number of copies of item i in pattern p.

In cutting and packing problems, a proper pattern is a pattern that respects the maximum number of copies of the items, whereas a non-proper pattern does not. The set-covering model by Gilmore and Gomory [START_REF] Gilmore | A linear programming approach to the cutting-stock problem[END_REF][START_REF] Gilmore | A linear programming approach to the cutting stock problem -part II[END_REF] for the CSP is similar to ( 25)-( 27), but it includes non-proper patterns that are obtained from the polytope of an unbounded knapsack problem (UKP), a variant of the KP where each item has an unlimited number of copies. The linear relaxation of ( 25)- [START_REF] Côté | The meet-in-the-middle principle for cutting and packing problems[END_REF], often referred to as proper relaxation (see, e.g., Kartak et al. [START_REF] Kartak | Minimal proper non-IRUP instances of the one-dimensional cutting stock problem[END_REF]), is stronger than the linear relaxation of the model by Gilmore and Gomory [START_REF] Gilmore | A linear programming approach to the cutting-stock problem[END_REF][START_REF] Gilmore | A linear programming approach to the cutting stock problem -part II[END_REF], but their optimal integer solution value is the same.

The linear relaxation of ( 25)-( 27) is strong and often the number of stock rolls in the optimal solution is the rounded up optimal solution value from this relaxation. In fact, there is a conjecture related to the strength of this relaxation (see, e.g., Caprara et al. [START_REF] Caprara | Friendly bin packing instances without integer round-up property[END_REF] and Kartak et al. [START_REF] Kartak | Minimal proper non-IRUP instances of the one-dimensional cutting stock problem[END_REF]):

Conjecture 1 (Modified Integer Round-Up Property (MIRUP)). The difference between the optimal solution value of the CSP and the rounded-up solution value of the linear relaxation of (25)-( 27) is at most one.

The pricing problem of the set-covering model is a KP (where each item has d i copies), which, as shown in Section 2.2, can be solved by DP, implying on the existence of a DP network N KP . As every column from the set-covering model can be represented as a path in N KP , this network can be the base of an arc flow model for the CSP:

min z, (28) s.t.
:

(u,v)∈A(N KP ) ϕ (u,v) - (v,w)∈A(N KP ) ϕ (v,w) =      -z, if v = v source , z, if v = v sink , 0, otherwise, ∀v ∈ V(N KP ), ( 29
) (u,v)∈A i (N KP ) i (u,v) ϕ (u,v) ≥ d i , ∀i ∈ I, (30)
z ∈ Z + , (31)
ϕ (u,v) ∈ Z + , ∀(u, v) ∈ A(N KP ). ( 32
)
The objective function [START_REF] Dantzig | The decomposition algorithm for linear programs[END_REF] is to minimize the total flow. Constraints (29) impose the flow conservation and constraints [START_REF] Delorme | Enhanced pseudo-polynomial formulations for bin packing and cutting stock problems[END_REF] are related to the demand of each item, where A i (N KP ) = ∪ l∈{0,1,...,d i } A il (N KP ) and the contribution i (u,v) of arc (u, v) ∈ A i (N DP ) is the number of copies of i associated with (u, v). The arc flow model ( 28)- [START_REF] Delorme | Logic based Benders' decomposition for orthogonal stock cutting problems[END_REF], corresponds to the arc flow model proposed by Cambazard and O'Sullivan [START_REF] Cambazard | Propagating the bin packing constraint using linear programming[END_REF], under the name DP-flow, for the bin packing problem (BPP), a particular case of the CSP where d i = 1 for every i ∈ I. The DP-flow is equivalent to the set-covering model ( 25)- [START_REF] Côté | The meet-in-the-middle principle for cutting and packing problems[END_REF] (see, e.g., Delorme and Iori [START_REF] Delorme | Enhanced pseudo-polynomial formulations for bin packing and cutting stock problems[END_REF]), and it follows the proper relaxation.

In this example, we started from a model that is associated with a weak linear relaxation. A DW decomposition resulted in a model with a stronger relaxation, but with the drawback of having a potentially exponential number of variables. Then, we showed how the DP network related to the pricing problem of the exponential model derives an equivalent pseudo-polynomial network flow model. Practical successful applications of this idea are shown in Section 7.

Example on the Capacitated Vehicle Routing Problem

In the capacitated vehicle routing problem (CVRP), we are given a set K of identical vehicles and a set I = {0, 1, . . . , n} of vertices where vertex 0 corresponds to a depot, and vertices 1, . . . , n correspond to n clients. Each vehicle has a load capacity W , each client i ∈ I \ {0} has a demand w i , and each pair of vertices i, j ∈ I is associated with a cost c(i, j). The CVRP aims at determining a routing plan with the minimum total cost, such that: (i) exactly |K| routes are considered; (ii) each route starts and ends at the depot; (iii) each client is visited exactly once; and (iv) the total demand from the clients of a route does not exceed the load capacity W .

In this example, we apply a DW decomposition on a compact arc flow model for the CVRP, obtaining a set partitioning model that derives an equivalent arc flow model of exponential size.

Let I * = {I \ {0}} ∪ {0 + , 0 -} be the set of clients with two additional vertices 0 + and 0 -, which are copies of the depot, each corresponding to the source and the sink of a route, respectively. The following compact arc flow model, also known as three-index (vehicle-flow) formulation (see, e.g., Irnich et al. [START_REF] Irnich | The family of vehicle routing problems[END_REF]), solves the CVRP:

min k∈K i∈I * j∈I * \{i} c(i, j)φ k (i,j) , (33)
s.t.:

j∈I * \{i} φ k (i,j) - j∈I * \{i} φ k (j,i) =      -1, if i = 0 + , 1, if i = 0 -, 0, otherwise, ∀k ∈ K, i ∈ I * , ( 34
)
k∈K j∈I * \{i} φ k (i,j) = 1, ∀i ∈ I \ {0}, (35)
ω ik -ω jk + W φ k (i,j) ≤ W -w j , ∀i, j ∈ I * , i = j, k ∈ K, (36)
ω ik ≤ W, ∀i ∈ I * , k ∈ K, (37)
φ k (i,j) ∈ {0, 1}, ∀i, j ∈ I * , k ∈ K, (38)
ω ik ≥ 0, ∀i ∈ I * , k ∈ K. (39)
Model ( 33)-( 39) considers a copy of the original graph for each vehicle k ∈ K. The binary variable φ k (i,j) is equal to 1 if and only if vehicle k moves from client i to client j, and the variable ω ik indicates the accumulated demand already distributed by the vehicle k when arriving at client i. The objective function [START_REF] Desaulniers | Column Generation[END_REF] is to minimize the total cost of the routes. Constraints [START_REF] Desaulniers | Variable fixing for two-arc sequences in branchprice-and-cut algorithms on path-based models[END_REF] guarantee the conservation of a unitary flow (representing a single route) for each of the |K| vehicles. Constraints [START_REF] Desrochers | A new optimization algorithm for the vehicle routing problem with time windows[END_REF] guarantee that each client is visited exactly once. Constraints [START_REF] Dyckhoff | A new linear programming approach to the cutting stock problem[END_REF] and (37) model the propagation of the accumulated demand of the load capacity of each vehicle, and they are also used to ensure that the route of each vehicle is a single connected component (path).

Although model ( 33)-( 39) has a polynomial number of variables, it has a large number of symmetries that makes it inefficient in practice (see, e.g., Irnich et al. [START_REF] Irnich | The family of vehicle routing problems[END_REF]). Each possible route can be attributed to any vehicle, so each solution (routing plan) has |K|! equivalent permutations. Next, we present a DW decomposition that eliminates this symmetry.

Flow conservation constraints [START_REF] Desaulniers | Variable fixing for two-arc sequences in branchprice-and-cut algorithms on path-based models[END_REF] correspond to |K| identical polytopes, each containing all paths from 0 + to 0 -, whose vertices are always integer. By including constraints [START_REF] Dyckhoff | A new linear programming approach to the cutting stock problem[END_REF] and [START_REF] Fischer | Dynamic graph generation for the shortest path problem in time expanded networks[END_REF], each of the |K| resulting polytopes contains all paths from 0 + to 0 -satisfying the load capacity, but the integrality property is lost. Let us consider the DW decomposition over the set P CV RP of vertices of the convex hull of constraints [START_REF] Desaulniers | Variable fixing for two-arc sequences in branchprice-and-cut algorithms on path-based models[END_REF], [START_REF] Dyckhoff | A new linear programming approach to the cutting stock problem[END_REF], [START_REF] Fischer | Dynamic graph generation for the shortest path problem in time expanded networks[END_REF], and [START_REF] Ford | Constructing maximal dynamic flows from static flows[END_REF], that represent the set of integer paths that satisfy the load capacity. The resulting DW model is:

min p∈P CV RP cp λ p , (40)
s.t.:

p∈P CV RP a pi λ p = 1, ∀i ∈ I \ {0}, (41)
p∈P CV RP

λ p = |K|, (42)
λ p ∈ {0, 1}, ∀p ∈ P CV RP . (43)
The set partitioning model ( 40)-( 43) provides a strong lower bound and it is among the most successful formulations to solve the CVRP in practice (see, e.g., Poggi and Uchoa [START_REF] Poggi | New exact algorithms for the capacitated vehicle routing problem[END_REF] and Pecin et al. [START_REF] Pecin | Improved branch-cut-and-price for capacitated vehicle routing[END_REF]). This model associates with each path p ∈ P CV RP a variable λ p . The binary coefficient a ip is equal to 1 if and only if client i ∈ I \ {0} is visited in p. The objective function [START_REF] Furini | Modeling two-dimensional guillotine cutting problems via integer programming[END_REF] is to minimize the total cost, where the cost cp of a path p is the sum of the costs of the arcs in A(p). Constraints [START_REF] Gabrel | Mathematical programming for earth observation satellite mission planning[END_REF] guarantee that each client is visited by exactly one route. As each variable represents a unique path, the symmetry from the model ( 33)-( 39) is eliminated.

The pricing problem associated with model ( 40)-( 43) is equivalent to the ESPPRC. In Section 2.3, we presented the exponential DP network N ESP P RC for the ESPPRC. Based on this network, and recalling that A i (N ESP P RC ) is the set of arcs that visit i ∈ I, we can reformulate the set partitioning model into the following arc flow model:

min (u,v)∈A(N ESP P RC ) c(u, v)ϕ (u,v) , (44) s.t.
:

(u,v)∈A(N ESP P RC ) ϕ (u,v) - (v,w)∈A(N ESP P RC ) ϕ (v,w) =      -|K|, if v = v source , |K|, if v = v sink , 0, otherwise, ∀v ∈ V(N ESP P RC ), (45)
(u,v)∈A i (N ESP P RC ) ϕ (u,v) = 1, ∀i ∈ I \ {0}, (46)
ϕ (u,v) ∈ {0, 1}, ∀(u, v) ∈ A(N ESP P RC ). ( 47
)
The objective function [START_REF] Godinho | On time-dependent models for unit demand vehicle routing problems[END_REF] minimizes the total cost of the routing plan. Constraints (45) impose the flow conservation, and constraints [START_REF] Graham | Optimization and approximation in deterministic sequencing and scheduling: a survey[END_REF] imply that each client is visited exactly once.

As network N ESP P RC is possibly exponential, the arc flow model ( 44)-( 47) may be too large to be used in practice. Nonetheless, this model is presented so as to provide an example in Section 4.2 on how a relaxation for the pricing problem of ( 40)-( 43) derives a pseudo-polynomial arc flow model for the CVRP.

State-Space Relaxation on Arc Flow Formulations

Dynamic programming is often an efficient tool to solve hard problems. However, when the number of states from a DP model is very large, it is not practical to solve it by enumerating all states, and more sophisticated methods are needed. From that observation, Christofides et al. [START_REF] Christofides | State-space relaxation procedures for the computation of bounds to routing problems[END_REF] proposed a general relaxation procedure for DP, called state-space relaxation, to obtain a smaller state space that provides a bound for the original problem. Such relaxation can be embedded in branch-andbound schemes to obtain exact algorithms.

Formally, a state-space relaxation consists of a mapping function g : S → G between two state spaces, where |G| < |S|. For every s ∈ S and r ∈ ∆(s), function g must guarantee that g(r) ∈ ∆(g(s)), and the decision cost of going from g(r) to g(s) is defined as c(g(r),g(s)) = max {p,q∈S} {c(p, q) | g(p) = g(r), g(q) = g(s)}. The DP recursion of the resulting state-space relaxation is given by:

f SSR (g(s)) = max {p∈∆(g(s))} (f SSR (p) + c(p,g(s)) ), if s = s 0 , 0, if s = s 0 , ∀s ∈ S. (48)
As a relaxation, recursion [START_REF] Hooker | Decision diagrams and dynamic programming[END_REF] guarantees that f SSR (g(s)) ≥ f DP (s), i.e., it produces a bound for the original recursion f DP . In the context of arc flow formulations induced by DP, the size of the LP formulation is strictly related to the size of the state space. In this case, smaller arc flow formulations can be obtained from state-space relaxations. Solutions obtained with the state-space relaxation may be unfeasible for the original problem. However, there are many cases in which arc flow formulations based on networks from state-space relaxations are guaranteed to produce optimal inter solutions that are feasible for the original problem. The main drawback of state-space relaxations is that they lead to arc flow formulations with weaker linear relaxation. This weakness occurs as the relaxation can profit from paths that were not feasible in the original network, generating, for instance, non-proper patterns in cutting and packing problems or non-elementary routes in vehicle routing problems.

Strong pseudo-polynomial arc flow formulations can be obtained from state-space relaxations of both pseudo-polynomial and exponential state spaces. Motivated by vehicle routing problems, Gouveia et al. [START_REF] Gouveia | Layered graph approaches for combinatorial optimization problems[END_REF] studied modeling and solution methods of a class of pseudo-polynomial arc flow formulations obtained from state-space relaxation of exponential state-spaces, named by the authors as layered graph formulations.

Next, we present two examples of pseudo-polynomial arc flow formulations obtained from statespace relaxations over a pseudo-polynomial and an exponential state space.

Example on the State Space for the Cutting Stock Problem

In Section 2.2, we presented recursion [START_REF] Ben Amor | Dual-optimal inequalities for stabilized column generation[END_REF] to solve the KP. This recursion produces network N KP , which has O(|I|W ) nodes and O(|I|W ) arcs. Then, in Section 3.1, network N KP was the base of arc flow model ( 28)- [START_REF] Delorme | Logic based Benders' decomposition for orthogonal stock cutting problems[END_REF] for the CSP, i.e., the DP-Flow model of Cambazard and O'Sullivan [START_REF] Cambazard | Propagating the bin packing constraint using linear programming[END_REF].

Let N KP -SSR be the network of a state-space relaxation of N KP based on the mapping function g((i, W )) = (W ), for every state (i, W ) ∈ V(N KP ). This mapping function disregards the dimension related to the partial set of items and merges states representing the same partial capacities, into a single state. Network N KP -SSR is smaller than N KP , with O(W ) nodes, but it may contain paths that violate the maximum number of copies of each item. Then, an arc flow model for the KP, based on N KP -SSR , needs additional side constraints to impose limits on the number of copies of items, while in N KP , such constraints are implicitly imposed by the configuration of the network.

In the CSP, as each demand constraint is to satisfy a minimum number of items, there is no problem in considering a network that has paths representing cutting patterns with more copies of a single item than the required. Hence, the arc flow model obtained by substituting N KP by N KP -SSR on model ( 28)-( 32) still solves the CSP, because unnecessary items copies, if any, can be removed from the solution without affecting its cost. The resulting model is equivalent to the classical arc flow model for the CSP proposed by Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF].

The model with N KP -SSR is smaller than the original model, with O(|I|+W ) constraints instead of O(|I|W ), but its linear relaxation is weaker. Nonetheless, N KP -SSR was obtained by Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF] after reducing the DP network of the UKP, implying the graph of N KP -SSR is a subgraph of the underlying graph from a DP for the UKP. This implies that the linear relaxation of the model with N KP -SSR is at least as strong as the relaxation of the model by Gilmore and Gomory [START_REF] Gilmore | A linear programming approach to the cutting-stock problem[END_REF][START_REF] Gilmore | A linear programming approach to the cutting stock problem -part II[END_REF], whose sub-problem is the UKP. Thus, the resulting linear relaxation still follows the MIRUP conjecture, implying that it is still strong. In practice, the arc flow model by Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF], which is associated with N KP -SSR , is preferable than the model by Cambazard and O'Sullivan [START_REF] Cambazard | Propagating the bin packing constraint using linear programming[END_REF], which is associated with N KP , as its linear relaxation is still strong and it is substantially smaller. To exemplify, Figure 2 shows the network N KP -SSR obtained from the example of Figure 1. We conclude that state-space relaxation can be considered to reduce the size of pseudo-polynomial arc flow formulations and obtain models with a linear relaxation that is still strong. This modeling technique to derive smaller, but yet efficient, pseudo-polynomial models from the relaxation of pseudo-polynomial state spaces has been mainly used, even without mentioning it, to model oneand two-dimensional cutting and packing problems and scheduling problems (see Section 7).

Example on the State Space for the Capacitated Vehicle Routing Problem

In Section 3.2, we presented a DW decomposition for the CVRP that resulted in the path model ( 40)- [START_REF] Gilmore | A linear programming approach to the cutting stock problem -part II[END_REF], which is known to have a strong linear relaxation. Then, we presented the corresponding arc flow model ( 44)- [START_REF] Gualandi | Exact solution of graph coloring problems via constraint programming and column generation[END_REF], which is based on the network N ESP P RC for the ESPPRC and has exponential size. In the following, we present a state-space relaxation for N ESP P RC that leads to a pseudo-polynomial arc flow model for the CVRP.

A pseudo-polynomial state space N ESP P RC-SSR can be obtained from a state-space relaxation of N ESP P RC based on the mapping function g((S, i)) = ( j∈S r j , i), for every state (S, i) ∈ N ESP P RC . This mapping function (originally proposed by Christofides et al. [START_REF] Christofides | State-space relaxation procedures for the computation of bounds to routing problems[END_REF]) merges states with the same total load from the visited clients into a single state. The resulting network N ESP P RC-SSR , which has O(|I|W ) nodes and O(|I| 2 W ) arcs, preserves the resource constraints of the ESPPRC, but it may consider non-elementary paths (clients may be visited more than once).

In the exponential arc flow model ( 44)-( 47) for the CVRP, the side constraints guarantee that clients are visited exactly once. Hence, by changing network N ESP P RC by N ESP P RC-SSR in model ( 44)-( 47), the resulting model still solves the CVRP and has pseudo-polynomial size. This resulting model is often referred to as capacity-indexed formulation (see, e.g., Poggi and Uchoa [START_REF] Poggi | New exact algorithms for the capacitated vehicle routing problem[END_REF]), and it has been extensively studied as a layered graph formulation by Gouveia et al. [START_REF] Gouveia | Layered graph approaches for combinatorial optimization problems[END_REF].

This example shows how state-space relaxation derives pseudo-polynomial arc flow models from a network of exponential size. This kind of modeling technique is often used in vehicle routing problems, as the combinatorial structure of such problems usually leads to exponential state spaces in DW decompositions (see, e.g., Righini and Salani [START_REF] Righini | New dynamic programming algorithms for the resource constrained elementary shortest path problem[END_REF]). basic variables to generate different paths in column generation algorithms (see, e.g., Sadykov and Vanderbeck [89]). In the following, we provide a related perspective, based on a dual point of view, to present another competitive advantage of arc flow formulations over path formulations. Then, we give an example of the proposed perspective applied to the CSP.

On the Dual Space of Network Flow Formulations

Many state-of-the-art algorithms to solve LP models are based on iteratively pivoting from one vertex of the LP polytope to a better neighboring vertex until an optimal solution is found. An issue that may be critical for the computational time is degeneracy. A solution is degenerate when there are basic variables with a null value; in such cases, there may be degenerate pivots that lead to the same degenerate vertex, with no change in the primal solution, nor improvement in the objective function. Hard combinatorial optimization problems are often associated with highly degenerate models, and stalling, which is a sequence of degenerate pivots, occurs in practice (see, e.g., Bazaraa et al. [START_REF] Bazaraa | Linear programming and network flows[END_REF]).

In fact, in a degenerate pivot, there is no change in the primal solution, but the new set of basic variables yields a change in the dual solution, leading to an alternative dual solution, often with a high oscillation of the values of the dual variables. When comparing different LP models for the same problem, the one with a tighter description of the dual space eliminates alternative dual solutions, potentially reducing degeneracy. This concept has been used in column generation algorithms by adding dual cuts that preserve all dual optimal solutions or even at least just one dual optimal solution, leading to significant speed-ups and reductions in the number of degenerate pivots (see, e.g., Valério de Carvalho [START_REF] Valério De Carvalho | Using extra dual cuts to accelerate column generation[END_REF], Lübbecke and Desrosiers [START_REF] Lübbecke | Selected topics in column generation[END_REF], and Ben Amor et al. [START_REF] Ben Amor | Dual-optimal inequalities for stabilized column generation[END_REF]).

LP solvers rely on the dual solution to prove optimality, and each dual constraint is an optimality condition. In the following, we show that arc flow formulations provide a tighter description of the dual space than their corresponding path formulations, with a richer description of the optimality conditions of the LP models. For instance, consider the dual of the linear relaxation of the path formulation ( 12)-( 14), given by:

max k∈C d k β k , (49)
s.t.:

k∈C (u,v)∈A(p) k (u,v) β k ≤ cp , ∀p ∈ P(N ), (50)
β k ≥ 0, ∀k ∈ C, (51)
where dual variable β k correspond to the constraints [START_REF] Brandão | Bin packing and related problems: General arc-flow formulation with graph compression[END_REF]. Now, consider the dual of the linear relaxation of the corresponding arc flow formulation ( 15)-( 19), given by:

max k∈C d k β k , (52)
s.t.: α v -α u + k∈C k (u,v) β k ≤ c(u, v), ∀(u, v) ∈ A(N ), ( 53
)
α source -α sink ≤ 0, ( 54
)
α v ≥ 0, ∀v ∈ V(N ), ( 55
)
β k ≥ 0, ∀k ∈ C. ( 56
)
Each dual variable α v corresponds to the flow conservation of node v ∈ V(N ), and each dual variable β k corresponds to the side constraint k ∈ C. For a given path p ∈ P(N ), by performing a non-negative linear combination of the dual constraints (53) of every arc on A(p), we obtain:

(u,v)∈A(p) (α v -α u ) + (u,v)∈A(p) k∈C k (u,v) β k ≤ (u,v)∈A(p) c(u, v) = cp . ( 57
)
Note that, each node v ∈ p, except for v source and v sink , is the head of an arc (u, v) ∈ A(p) and the tail of an arc (v, w) ∈ A(p), producing in the first summation, respectively, the terms α v and -α v that cancel each other. Then, (57) can be rewritten as:

(α sink -α source ) + k∈C (u,v)∈A(p) k (u,v) β k ≤ cp , (58)
which is equivalent to the dual constraint from ( 50) for the path p, with an additional term (α sink -α source ). From [START_REF] Kramer | Scheduling jobs with release dates on identical parallel machines by minimizing the total weighted completion time[END_REF], we know that this term is always non-negative, implying in a tighter constraint. Thus, we conclude that every dual constraint of the path formulation is a redundant dual constraint for the arc flow formulation, implying that the arc flow formulation provides a tighter dual space than the path formulation.

Example on the Cutting Stock Problem

We present a numerical example to compare the dual of the classical arc flow model from Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF] (see Section 4.1) to solve the CSP and the dual of its corresponding path model. The dual of the linear relaxation of this arc flow model is given by:

max i∈I β i , (59)
s.t.: -α v + α v+w i + β i ≤ 0, ∀i ∈ I, (v, v + w i ) ∈ A i (N KP -SSR ), ( 60
)
α source -α sink ≤ 1, ( 61
)
α v ≥ 0, ∀v ∈ V(N KP -SSR ), ( 62
)
β i ≥ 0, ∀i ∈ I. ( 63
)
Variables α v are related to the flow conservation constraints of each v ∈ V(N KP -SSR ), and variables β i are related to the demand constraint of each i ∈ I. Constraints (60) are related to the arc variables, and constraint ( 61) is related to the flow variable. The dual of the linear relaxation corresponding path model is given by: max

i∈I β i , (64)
s.t.: i∈I a ip β i ≤ 1, ∀p ∈ P(N KP -SSR ), ( 65
)
β i ≥ 0, ∀i ∈ I. ( 66
)
The variables β i are related to the demand constraints of each i ∈ I, and constraints (65) are related to each path (cutting pattern) p of N KP -SSR , where a ip is an integer coefficient representing the number of times item i is cut from pattern p.

Consider again the example from Figure 2, with bin capacity 8 and three items having w 1 = 4, w 2 = 3, w 3 = 2, and 1 and2 present, respectively, model ( 59)-( 63) and ( 64)- [START_REF] Martinovic | Integer linear programming models for the skiving stock problem[END_REF] for this example. In the dual of the linear relaxation of the arc flow model, v source and v sink are represented by 0 and S, respectively. In this example, the path model is relatively smaller than the arc flow model, which is not common for practical instances, as the former may have exponentially more primal variables. However, our goal here is only to exemplify how the dual constraints (optimality conditions) of the path model are redundant dual constraints for the arc flow model. This can be observed as each dual constraint of the path model related to a pattern can be obtained by a non-negative linear sum of the dual constraints of the arc flow model related to the arcs that form this pattern. In particular: pattern {1, 2} can be formed by arcs (0, 4), (4, 7), (7, S) and (S, 0); pattern {1, 3} by arcs (0, 4), [START_REF] Bazaraa | Linear programming and network flows[END_REF][START_REF] Ben Amor | Dual-optimal inequalities for stabilized column generation[END_REF], (6, S) and (S, 0); pattern {2, 3} by arcs (0, 3), [START_REF] Boyd | A pseudopolynomial network flow formulation for exact knapsack separation[END_REF][START_REF] Bellman | Dynamic Programming[END_REF], (5, S) and (S, 0); pattern {1} by arcs (0, 4), (4, S) and (S, 0); pattern {2} by arcs (0, 3), (3, S) and (S, 0); pattern {3} by arcs (0, 2), (2, S) and (S, 0). Table 1: Example of a dual arc flow formulation for the CSP.

d 1 = d 2 = d 3 = 1. Tables
α 0 α 1 α 2 α 3 α 4 α 5 α 6 α 7 α 8 α S β 1 β 2 β 3 arc (0, 4) -1 1 1 ≤ 0 (0, 3) -1 1 1 ≤ 0 (4, 7) -1 1 1 ≤ 0 (0, 2) -1 1 1 ≤ 0 (3, 5) -1 1 1 ≤ 0 (4, 6) -1 1 1 ≤ 0 (0, S) -1 1 ≤ 0 (2, S) -1 1 ≤ 0 (3, S) -1 1 ≤ 0 (4, S) -1 1 ≤ 0 (5, S) -1 1 ≤ 0 (6, S) -1 1 ≤ 0 (7, S) -1 1 ≤ 0 flow (S, 0) 1 -1 ≤ 1 max 1 1 1
Table 2: Example of a dual path formulation for the CSP.

β 1 β 2 β 3 patterns {1, 2} 1 1 ≤ 1 {1, 3} 1 1 ≤ 1 {2, 3} 1 1 ≤ 1 {1} 1 ≤ 1 {2} 1 ≤ 1 {3} 1 ≤ 1 max 1 1 1

General Solution Methods

As previously discussed, an advantage of arc flow formulations over their equivalent path formulations is that they can be much smaller and often can be solved directly by a MILP solver (which is not practical for path models). However, pseudo-polynomial arc flow models can still be too large, depending on the size of the parameters of an instance. In such cases, one has to rely on more sophisticated methods to solve these models.

Column Generation

The column generation method (introduced in Section 3) is a popular tool to solve path models. The method was proposed by Ford and Fulkerson [START_REF] Ford | A suggested computation for maximal multi-commodity network flows[END_REF] to solve a path model for a maximal multicommodity network flow problem and three years later generalized by Dantzig and Wolfe [START_REF] Dantzig | The decomposition algorithm for linear programs[END_REF] to solve the models resulting from the DW-decomposition. Gilmore and Gomory [START_REF] Gilmore | A linear programming approach to the cutting-stock problem[END_REF][START_REF] Gilmore | A linear programming approach to the cutting stock problem -part II[END_REF] solved a path model for the CSP by a column generation algorithm and were the first to show the practical efficiency of the method. Since then, column generation has been the basis of several methods to solve path models. For references on column generation algorithms not strictly related to arc flow formulations, we refer the interested reader to the survey by Lübbecke and Desrosiers [START_REF] Lübbecke | Selected topics in column generation[END_REF] and the book by Desaulniers et al. [START_REF] Desaulniers | Column Generation[END_REF].

Column generation was applied to solve an arc flow model for the first time by Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF], where a column-and-row generation algorithm was proposed. In the context of arc flow models, column-and-row generation iteratively generates arcs to enter the simplex base, while the flow conservation constraints (rows) are restricted to vertices where there exists at least one incoming and one outgoing arc in the restricted problem. Sadykov and Vanderbeck [START_REF] Sadykov | Column generation for extended formulations[END_REF] studied the column-and-row generation method and experimentally compared the solution of path models by column generation, with the solution of equivalent arc flow models by column-and-row generation, and observed a faster convergence of the latter, which follows the discussion in Section 5.

In column generation algorithms (and lagrangian relaxations where only flow conservation constraints are left in the master) to solve arc flow models, an LPP on the underlying network is iteratively solved, and its computational efficiency is strictly related to the network size. In this context, when the network is too large, one may rely on dynamic graph generation methods to solve the LPP, as proposed by, e.g., Fischer and Helmberg [START_REF] Fischer | Dynamic graph generation for the shortest path problem in time expanded networks[END_REF], to solve LPPs that arise as sub-problems from arc flow models based on large-scale time-expanded networks.

Iterative Aggregation/Disaggregation Method

Several authors have studied state-space relaxation techniques to reduce the size of arc flow formulations (see, e.g., Macedo et al. [START_REF] Macedo | Solving exactly the vehicle routing problem with time windows and multiple routes using a pseudopolynomial model[END_REF], Clautiaux et al. [START_REF] Clautiaux | Iterative aggregation and disaggregation algorithm for pseudo-polynomial network flow models with side constraints[END_REF], Voge and Clautiaux [START_REF] Voge | Theoretical investigation of aggregation in pseudo-polynomial network-flow models[END_REF], Boland et al. [START_REF] Boland | The continuous-time service network design problem[END_REF], Boland and Savelsbergh [START_REF] Boland | Perspectives on integer programming for timedependent models[END_REF], Riedler et al. [START_REF] Riedler | Strategies for iteratively refining layered graph models[END_REF]). These techniques are equivalent to applying a surrogate relaxation to the flow conservation constraints related to subsets of nodes. Theoretically, this only reduces the number of constraints. Practically speaking, after an aggregation, many arcs (variables) associated with the same decision become equivalent in the reduced network and can be merged. From an initial relaxation, these methods use iterative techniques in which the relaxation is refined, typically by splitting nodes that have been aggregated, until the solution produced by the relaxation is feasible for the original problem, or its value is equal to a known primal bound.

Macedo et al. [START_REF] Macedo | Solving exactly the vehicle routing problem with time windows and multiple routes using a pseudopolynomial model[END_REF] were the first to use these techniques in pseudo-polynomial arc flow models. The authors used two aggregations: one produces a relaxation, the other a heuristic solution. These results were later generalized by Voge and Clautiaux [START_REF] Voge | Theoretical investigation of aggregation in pseudo-polynomial network-flow models[END_REF] and Clautiaux et al. [START_REF] Clautiaux | Iterative aggregation and disaggregation algorithm for pseudo-polynomial network flow models with side constraints[END_REF], who studied the difficulty of the different sub-problems and the performance ratio obtained by an aggregated model. More efficient refining strategies are studied in Riedler et al. [START_REF] Riedler | Strategies for iteratively refining layered graph models[END_REF]. The authors show that their path-based techniques are more effective and underline the importance of heuristic methods in the algorithm. In early works, the elements to be aggregated were decided beforehand. In Boland and Savelsbergh [START_REF] Boland | Perspectives on integer programming for timedependent models[END_REF], the authors introduced the paradigm of dynamic discretization discovery, in which the discretization is constructed on the fly, producing a better relaxation, by using information from the network construction process.

Such aggregation techniques have been generalized to flows in hypergraphs by Benkirane et al. [START_REF] Benkirane | A Hypergraph Model for the Rolling Stock Rotation Planning and Train Selection[END_REF] to solve a joint rolling-stock and train selection problem for the French railway company. The authors show that even for hypergraphs, one can safely use reduced-cost filtering on aggregated variables. Another type of relaxation is used in Nadarajah and Cire [START_REF] Nadarajah | Network-based approximate linear programming for discrete optimization[END_REF] to deal with problems where several constraints can be reformulated as network-flow constraints. In their model, a network is created for each constraint, and the flow conservation constraints of all networks but one are relaxed in a Lagrangian way.

Graph Reduction Methods

An important element of efficient solution methods for arc flow models is to determine arcs that can be removed from the network without losing optimality. Removing redundant arcs is important, as a smaller network may lead to a reduction in symmetry, a tighter relaxation, and a smaller branchand-bound tree. Usually, techniques to reduce the number of arcs are problem-dependent, and we discuss some of them in Section 7, under specific applications. Nonetheless, general reduction techniques have been used to enhance arc flow models, as, for instance, the reduced-cost variablefixing method (see, e.g., Pessoa et al. [START_REF] Pessoa | Exact algorithm over an arc-timeindexed formulation for parallel machine scheduling problems[END_REF] and Kramer et al. [START_REF] Kramer | Novel formulations and modeling enhancements for the dynamic berth allocation problem[END_REF]).

The reduced-cost variable-fixing method consists of: given an optimal linear solution, with value z lb , for a MILP model and an upper bound value z ub for the integer problem, the integer variables with a reduced cost that exceeds z ub -z lb can be removed without losing optimality. Irnich et al. [START_REF] Irnich | Path-reduced costs for eliminating arcs in routing and scheduling[END_REF] proposed an efficient reduced-cost variable fixing algorithm for network flow models that computes a bound on the reduced cost of the arcs in arc flow models based on a linear solution of its equivalent path model. This method was later extended by Desaulniers et al. [START_REF] Desaulniers | Variable fixing for two-arc sequences in branchprice-and-cut algorithms on path-based models[END_REF] to determine and efficiently handle pairs of sequential arcs that cannot be in the same path in an optimal solution.

Applications

In this section, we discuss the main applications of arc flow models, and discuss problem-dependent solution methods and reduction criteria.

Cutting and Packing Problems

Arc flow models have been used in a variety of cutting and packing problems, both in one and multiple dimensions.

One-dimensional Problems

The classical arc flow model for the CSP in Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF] has a node for each partial stock size, the arcs relate the items with cut positions (item arcs) or represent loss stock (loss arcs), and the combination of arcs into paths represent cutting patterns. To solve this model to integer optimality, Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF] proposed a branch-and-price algorithm based on column-androw generation. To accelerate the column generation's convergence, the pricing problem generates paths (instead of single arcs). Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF] proved that the arc flow model is equivalent to the path (set-covering) model by Gilmore and Gomory [START_REF] Gilmore | A linear programming approach to the cutting-stock problem[END_REF][START_REF] Gilmore | A linear programming approach to the cutting stock problem -part II[END_REF], whereas Martinovic et al. [START_REF] Martinovic | A comparative study of the arcflow model and the one-cut model for one-dimensional cutting stock problems[END_REF] and Delorme and Iori [START_REF] Delorme | Enhanced pseudo-polynomial formulations for bin packing and cutting stock problems[END_REF] proved that the arc flow model is equivalent to the one-cut model by Rao [START_REF] Rao | On the cutting stock problem[END_REF] and Dyckhoff [START_REF] Dyckhoff | A new linear programming approach to the cutting stock problem[END_REF]. The one-cut is a pseudo-polynomial model where variables represent cutting operations on the roll.

To reduce the number of arcs, Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF] constructs the graph considering that items of a single roll can always be ordered by non-increasing width. The resulting graph independently follows the state-space relaxation discussed in Section 4.1. To obtain even smaller networks, Côté and Iori [START_REF] Côté | The meet-in-the-middle principle for cutting and packing problems[END_REF] proposed the meet-in-the-middle technique: each path representing a cutting pattern can be transformed into an equivalent one by left aligning the items whose left border is at the left of a given threshold parameter t, and right aligning the remaining items.

Cambazard and O'Sullivan [START_REF] Cambazard | Propagating the bin packing constraint using linear programming[END_REF] proposed the DP-flow, an arc flow model for the CSP (already introduced in Section 3.1) based on the DP network of the KP. Differently from the classical arc flow model for the CSP, which considers a node for each partial stock size, the DP-flow considers a node for each pair of items and partial stock size. The network has a level for each item, and each feasible path visits the level of each item exactly once. Although this modeling technique can substantially increase the number of nodes, it allows one to consider only proper patterns. On the other hand, the classical arc flow model is smaller, but it cannot distinguish between proper and non-proper patterns, so its relaxation can be weaker than the one of the DP-flow.

A generalization of the classical arc flow model for the CSP was proposed by Brandão and Pedroso [START_REF] Brandão | Bin packing and related problems: General arc-flow formulation with graph compression[END_REF]. This generalization can model related problems, such as the vector BPP, the BPP with conflicts, the cardinality constrained BPP and CSP, and the graph coloring problem. The resulting network may be significantly large, but several techniques (referred to as graph compression) are proposed to reduce the network size. To break symmetry, the authors proposed a modeling technique similar to the graph construction of the DP-flow, considering an extra dimension, related to the items, on the nodes.

Delorme and Iori [START_REF] Delorme | Enhanced pseudo-polynomial formulations for bin packing and cutting stock problems[END_REF] proposed the reflect formulation, a pseudo-polynomial model for the CSP that considers nodes and arcs only from half of the stock size. In practice, it is significantly smaller than the classical arc flow model. Besides, the reflect formulation has been proven to be as strong as the classical arc flow model without reduction criteria. Other than the CSP, Delorme and Iori [START_REF] Delorme | Enhanced pseudo-polynomial formulations for bin packing and cutting stock problems[END_REF] extended the reflect formulation to solve the variable-sized BPP and the BPP with item fragmentation. Dell'Amico et al. [START_REF] Dell'amico | Mathematical models and decomposition methods for the multiple knapsack problem[END_REF] adapted the reflect formulation to solve a feasibility problem in a Benders' decomposition algorithm for the multiple knapsack problem.

Alves and Valério de Carvalho [START_REF] Alves | A stabilized branch-and-price-and-cut algorithm for the multiple length cutting stock problem[END_REF] presented a branch-and-price-and-cut algorithm for the multiple length CSP that solves the Gilmore and Gomory [START_REF] Gilmore | A linear programming approach to the cutting stock problem -part II[END_REF] machine balance model, which is a path formulation, using the original arc flow model to generate attractive columns in a single subproblem and the variables of the arc flow model to implement a branching scheme, by expressing the branching constraints in terms of the Gilmore and Gomory model variables. The equivalence of the path and arc flow models ensures a correct transferral of dual information. Valid dual inequalities are used to stabilize and accelerate the search in the entire branch-and-bound tree.

Recently, arc flow models were proposed for the skiving stock problem (SSP), which is strongly related to the dual BPP. In the SSP, we are given a set of items, each having a length and a maximum number of copies, to be combined into the maximum number of larger items of minimum length W . Martinovic and Scheithauer [START_REF] Martinovic | Integer linear programming models for the skiving stock problem[END_REF] proposed an arc flow model for the SPP where nodes represent the length sum of combinations of items, arcs represent the positioning of the items in a combination, and paths represent a combination of items. This model, which is similar to the classical arc flow model for the CSP, cannot distinguish between proper and non-proper patterns. Martinovic and Scheithauer [START_REF] Martinovic | The proper relaxation and the proper gap of the skiving stock problem[END_REF] proposed an arc flow model that considers only proper patterns, which, similarly to the DP-flow model, considers a node for each pair of items and possible length sum, and the network has a level for each item. Martinovic et al. [START_REF] Martinovic | Improved flow-based formulations for the skiving stock problem[END_REF] proposed two arc flow models for the SSP: one considers reversed loss arcs, which lead to a reduction of the worst-case number of nodes from 2W to W , and the other is based on the reflect model for the CSP.

Multi-dimensional Problems

Macedo et al. [START_REF] Macedo | Arc-flow model for the two-dimensional guillotine cutting stock problem[END_REF] extended the classical arc flow model to minimize the number of bins in the two-stage two-dimensional guillotine CSP. Their model has a one-dimensional arc flow graph for the first stage cuts (which cut the bins to obtain strips), and a one-dimensional arc flow graph for each possible strip size to determine the second stage cuts (which produce the items from the strips, possibly admitting a final trim loss cut). To reduce symmetry, the flow in the second stage graph of a given strip size is equal to the sum of the flows for that strip size in the first stage graph. Note that these strips may belong to the same bin or different bins. Procedures to reduce the size of the graph and a new family of cutting planes based on the height of the items were proposed. The arc flow model in [START_REF] Macedo | Arc-flow model for the two-dimensional guillotine cutting stock problem[END_REF] was later adapted by Mrad [START_REF] Mrad | An arc flow-based optimization approach for the two-stage guillotine strip cutting problem[END_REF] to solve the two-stage two-dimensional guillotine strip packing problem.

Nesello et al. [START_REF] Nesello | Mathematical models and decomposition algorithms for makespan minimization in plastic rolls production[END_REF] proposed an arc flow model, similar to the one by Macedo et al. [START_REF] Macedo | Arc-flow model for the two-dimensional guillotine cutting stock problem[END_REF], to solve a three-stage two-dimensional strip packing problem where a limit is imposed on the number of shelves and setup times between items must be taken into account. Delorme et al. [START_REF] Delorme | Logic based Benders' decomposition for orthogonal stock cutting problems[END_REF] adapted the classical arc flow model for the CSP to solve the one-dimensional contiguous bin packing problem, which often appears as a sub-problem in two-dimensional cutting and packing solution methods. The authors used it to solve the sub-problem of a Benders' decomposition algorithm for the twodimensional strip packing with item rotations and for the pallet loading problem.

Clautiaux et al. [START_REF] Clautiaux | Combining dynamic programming with filtering to solve a four-stage two-dimensional guillotine-cut bounded knapsack problem[END_REF] solved the four-stage two-dimensional guillotine bounded knapsack problem with a network flow model based on a directed acyclic hypergraph. They compared the efficiency of several algorithms based on this representation, including a MILP model and an iterative statespace relaxation based on the corresponding DP.

Scheduling Problems

In the scheduling field, both time-indexed (see, e.g., Sousa and Wolsey [START_REF] Sousa | A time indexed formulation of non-preemptive single machine scheduling problems[END_REF]) and path-based (see, e.g., van den Akker et al. [START_REF] Van Den Akker | Time-indexed formulations for machine scheduling problems: Column generation[END_REF]) formulations have been widely used to solve a variety of optimization problems. Arc flow formulations have been only adopted, instead, during the last decade.

Pessoa et al. [START_REF] Pessoa | Exact algorithm over an arc-timeindexed formulation for parallel machine scheduling problems[END_REF] developed a branch-and-cut-and-price algorithm for the problem of minimizing weighted tardiness on identical parallel machines (denoted as P || w j T j in the three-field classification of Graham et al. [START_REF] Graham | Optimization and approximation in deterministic sequencing and scheduling: a survey[END_REF]). Their algorithm is based on an arc-time-indexed formulation and is improved with a number of combinatorial techniques, including variable fixing by reduced costs, extended capacity cuts, dual stabilization, and the direct solution of the formulation by a MILP solver if the fixing procedure had consistently reduced the number of variables. The method in [START_REF] Pessoa | Exact algorithm over an arc-timeindexed formulation for parallel machine scheduling problems[END_REF] was later extended by Bulhões et al. [START_REF] Bulhões | On the exact solution of a large class of parallel machine scheduling problems[END_REF], who proposed a branch-and-cut-and-price algorithm to solve a path formulation for parallel machine scheduling in which the branching is based on the variables of the arc flow model.

Lancia et al. [START_REF] Lancia | A time-indexed LP-based approach for min-sum job-shop problems[END_REF] developed a branch-and-price algorithm for the job shop problem with a general min-sum objective function. Their algorithm is based on the linear solution of an arc flow model in which a path has to be chosen for each job (which is composed of multiple operations). The model was strengthened by clique inequalities.

Ratli et al. [START_REF] Ratli | Mathematical programming and heuristics for scheduling problems with early and tardy penalties[END_REF] presented a comprehensive list of mathematical models for scheduling jobs on a single machine by minimizing weighted earliness and tardiness. The problem, denoted as 1|| α j E j + β j T j , is relevant in the context of just-in-time production. In computational tests on random instances, the arc flow model achieved the lowest optimality gaps.

Mrad and Souayah [START_REF] Mrad | An arc-flow model for the makespan minimization problem on identical parallel machines[END_REF] presented a direct extension of the arc flow formulation by Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF] to the problem of scheduling jobs on identical parallel machines with the objective of minimizing the makespan (P ||C max ). Kramer et al. [START_REF] Kramer | Enhanced arc-flow formulations to minimize weighted completion time on identical parallel machines[END_REF] considered again the problem of scheduling jobs on identical parallel machines, but focused on the minimization of the weighted sum of the completion times (P || w j C j ). They presented an arc flow model, and then enhanced it by grouping jobs having the same weight and processing time and creating time windows for each group by considering job priorities. A computational comparison showed that the enhanced arc flow performed very well compared to other time-indexed, convex integer quadratic programming, and path-based models.

Kramer et al. [START_REF] Kramer | Mathematical formulations for scheduling jobs on identical parallel machines with family setup times and total weighted completion time minimization[END_REF] extended the work in [START_REF] Kramer | Enhanced arc-flow formulations to minimize weighted completion time on identical parallel machines[END_REF] to deal with the case of family setup times (P |s i | w j C j ). The authors proposed three different arc flow models. In the most efficient one, the network is divided into a set of layers, one layer per family. Arcs within the same layer considered only the processing time of a job, whereas arcs connecting two layers considered both setup and processing times. Computational results showed that setup times worsens the linear relaxation value of the arc flow models, which outperformed a path-based model only on a handful of instances.

A further generalization of [START_REF] Kramer | Enhanced arc-flow formulations to minimize weighted completion time on identical parallel machines[END_REF] was provided in Kramer et al. [START_REF] Kramer | Scheduling jobs with release dates on identical parallel machines by minimizing the total weighted completion time[END_REF], who considered the case of release dates (P |r j | w j C j ) and obtained stricter time windows for the jobs. The resulting arc flow model obtained better results than a branch-and-price based on the path-based formulation on instances having jobs of small and moderate processing time.

We also mention that interesting integrations between scheduling and other combinatorial problems have been tackled in the literature. Cappanera and Scutellà [START_REF] Cappanera | Joint assignment, scheduling, and routing models to home care optimization: a pattern-based approach[END_REF] considered a joint assignment, scheduling, and routing problem arising in home care optimization. An arc flow model was used for the generation of patterns, which represent feasible combinations of the three decision levels of the problem. Cire et al. [START_REF] Cire | A network-based formulation for scheduling clinical rotations[END_REF] proposed an arc flow formulation for a rotation assignment and scheduling problem arising in the context of clinical rotations. They demonstrate that the network model was computationally superior to a classical MILP model on a real-world set of instances.

Braga et al. [START_REF] Braga | Combined cutting stock and scheduling: a matheuristic approach[END_REF] compared two formulations for a combined cutting stock and scheduling problem: a compact formulation strengthened with knapsack inequalities and an arc flow formulation. Using a revised version of the latter formulation based on aggregated time periods, they derived a heuristic solution procedure that proved to be effective for the solution of medium size instances. Rietz et al. [START_REF] Rietz | An exact approach based on a new pseudo-polynomial network flow model for integrated planning and scheduling[END_REF] proposed and analyzed an arc flow formulation for a combined cutting stock and scheduling problem on parallel machines. Different strategies to simplify the formulation by reducing the number of arcs were presented.

Trindade [START_REF] Trindade | Modelling Batch Processing Machines Problems with Symmetry Breaking and Arc Flow Formulation[END_REF] solved scheduling problems with batch processing machines. In such problems, the jobs are grouped into batches to be scheduled in machines, where the batches have a capacity to be respected by the size of its grouped items. The author proposed arc flow models where nodes represent a discretization of the capacity of a batch and arcs represent either a scheduled job in a batch or an unused capacity.

Routing Problems

In routing problems, the input is usually based on a network, where clients and depots are given as nodes and arcs are related to transportation between the nodes (see, e.g., Toth and Vigo [START_REF] Toth | Vehicle Routing: Problems, Methods, and Applications[END_REF]). For such problems, arc flow models based on the input network lead to compact models that are small but may have weak relaxations and too much symmetry to be solved in practice. Examples of such compact models are the classical MTZ model by Miller et al. [START_REF] Miller | Integer programming formulation of traveling salesman problems[END_REF] for the traveling salesman problem (TSP) and the three-index formulation (see Section 3.2) for the CVRP. In many routing problems, the ability to avoid non-elementary routes is an important aspect to determine the strength of a relaxation. For this reason, the best solution methods for many variants, especially the ones with multiple vehicles, are usually based on path formulations (see, e.g., Poggi and Uchoa [START_REF] Poggi | New exact algorithms for the capacitated vehicle routing problem[END_REF] and Pessoa et al. [START_REF] Pessoa | A generic exact solver for vehicle routing and related problems[END_REF]), as they can handle non-elementary routes more easily than arc flow formulations. However, pseudo-polynomial arc flow formulations have still been used to solve open problems of a number of variants, and to enhance state-of-the-art methods based on path formulations.

Pseudo-polynomial arc flow formulations for vehicle routing problems were first introduced by Godinho et al. [START_REF] Godinho | On time-dependent models for unit demand vehicle routing problems[END_REF] and Pessoa et al. [START_REF] Pessoa | Robust branch-cut-and-price algorithms for vehicle routing problems[END_REF], which, inspired by the early work by Picard and Queyranne [START_REF] Picard | The time-dependent traveling salesman problem and its application to the tardiness problem in one-machine scheduling[END_REF] for single machine scheduling with minimum tardiness, proposed the capacityindexed formulation for the CVRP. The capacity-indexed formulation, which follows the network from the state-space relaxation in Section 4.2, has a node (i, q) for each pair of client (or depot) i and partial capacity q, where the partial capacities group the nodes into levels (layers). Then, each path arriving at a node (i, q) represents a route that finishes in client i and has total load q.

The capacity-indexed formulation is based on a network where paths may be associated to non-elementary routes (which weakens its linear relaxation), and may be too large to be solved in practice (see, e.g., Pessoa et al. [START_REF] Pessoa | Robust branch-cut-and-price algorithms for vehicle routing problems[END_REF]). The main interest in this formulation is that its variables can be used to define cutting planes (e.g., the extended capacity cuts) to strengthen path formulations for vehicle routing problems (see, e.g., Poggi and Uchoa [START_REF] Poggi | New exact algorithms for the capacitated vehicle routing problem[END_REF]). According to Uchoa [START_REF] Uchoa | Cuts over extended formulations by flow discretization[END_REF], cutting planes based on the capacity-indexed formulation have been successfully used in other vehicle routing problems, and even in parallel machine scheduling problems.

Macedo et al. [START_REF] Macedo | Solving exactly the vehicle routing problem with time windows and multiple routes using a pseudopolynomial model[END_REF] proposed an iterative aggregation/disaggregation algorithm to solve an arc flow formulation for the vehicle routing problem with time windows and multiple routes. In the underlying network, each node corresponds to a time instant, and each arc corresponds to a possible subtour. Aggregation based on rounding procedures was used to make the routes with non-integer travel times fit the model's graph. Whenever an infeasible solution was found, the nodes involved in the infeasibility were disaggregated, and the resulting model was solved again.

Braga et al. [START_REF] Braga | Exact solution of the multi-trip inventory routing problem using a pseudo-polynomial model[END_REF] proposed an arc flow formulation for the multi-trip inventory routing problem where vehicles can perform more than a single route per time period. Following Macedo et al. [START_REF] Macedo | Solving exactly the vehicle routing problem with time windows and multiple routes using a pseudopolynomial model[END_REF], nodes and arcs of the underlying network correspond to, respectively, time instants and routes that may be assigned to a vehicle.

Algorithms based on iterative aggregation/disaggregation were later proposed to solve timeexpanded arc flow formulations for the TSP with time windows (TSPTW). The network of timeexpanded formulations has a node (i, t) for each client i and time instant t. Each path from the source to a node (i, t) represents a path arriving at client i at time t. Boland et al. [START_REF] Boland | Solving the traveling salesman problem with time windows through dynamically generated time-expanded networks[END_REF] and Riedler et al. [START_REF] Riedler | Strategies for iteratively refining layered graph models[END_REF] proposed iterative aggregation/disaggregation algorithms to solve a time-expanded model for the TSPTW, starting with a reduced network that is sufficient to produce a bound for the problem and is iteratively refined to find an optimal solution. The method in Boland et al. [START_REF] Boland | Solving the traveling salesman problem with time windows through dynamically generated time-expanded networks[END_REF] was later extended by Vu et al. [START_REF] Vu | Dynamic discretization discovery for solving the time-dependent traveling salesman problem with time windows[END_REF] to solve the generalization where travel times are time-dependent. This kind of approach was also used by Boland et al. [START_REF] Boland | The continuous-time service network design problem[END_REF] to solve a continuous-time service network design problem without the need to approximate the solution by a discretization of the time-horizon.

Miscellaneous

Earth Observation Satellite scheduling is to determine the pictures to be taken by a set of satellites in a given time period, so as to satisfy side constraints and optimize an objective function. Pseudopolynomial arc flow models have been proposed to solve such problems by Gabrel and Murat [START_REF] Gabrel | Mathematical programming for earth observation satellite mission planning[END_REF] and Wang et al. [START_REF] Wang | Agile earth observation satellite scheduling over 20 years: formulations, methods and future directions[END_REF]. In these models, the nodes are related to a discretization of the time horizon, and the arcs are related to the decisions on the pictures to be taken.

Kramer et al. [START_REF] Kramer | Novel formulations and modeling enhancements for the dynamic berth allocation problem[END_REF] solved the dynamic berth allocation problem, which aims at allocating vessels into quays that are divided into berths, while optimizing an objective function based on the service time of each vessel. The authors proposed an arc flow model where nodes are associated with time instants and arcs are related to vessels serving. Problem-dependent reduction criteria and a reduced-cost variable-fixing algorithm were proposed to improve the solution time.

In the capacitated p-center problem, a set of customers must be attributed to capacitated facility locations, minimizing the maximum distance between each client and its facility. To solve this problem, Kramer et al. [START_REF] Kramer | Mathematical models and search algorithms for the capacitated-center problem[END_REF] proposed an arc flow model where the underlying graph has a component for each location, in which nodes correspond to partial filling of the facility capacity, and arcs correspond to customers and unused capacity.

Ramos et al. [START_REF] Ramos | An arc flow formulation to the multitrip production, inventory, distribution, and routing problem with time windows[END_REF] described an arc flow formulation for the multi-trip production, inventory, distribution, and routing problem with time windows. Nodes and arcs represent time instants and vehicle routes, respectively.

Train timetabling problems are to determine a periodic timetable for a set of trains that satisfies operational constraints and optimizes an objective function (see, e.g., Cacchiani and Toth [START_REF] Cacchiani | Nominal and robust train timetabling problems[END_REF]). The input for such problems is based on a graph where nodes represent stations and arcs represent tracks between stations. Train timetabling problems have been successfully solved by arc flow models based on time-expanded networks by Caprara et al. [START_REF] Caprara | Modeling and solving the train timetabling problem[END_REF] and Fischer and Helmberg [START_REF] Fischer | Dynamic graph generation for the shortest path problem in time expanded networks[END_REF].

Recently, van Hoeve [START_REF] Van Hoeve | Graph coloring lower bounds from decision diagrams[END_REF] proposed an arc flow model to solve the graph coloring problem, which asks to partition a graph into the minimum number of independent sets. The proposed arc flow model is based on decision diagrams, which are closely related to DP (see, e.g., Hooker [START_REF] Hooker | Decision diagrams and dynamic programming[END_REF]) and result in acyclic graphs. The resulting network in [START_REF] Van Hoeve | Graph coloring lower bounds from decision diagrams[END_REF] is equivalent to a DP network to solve the maximum independent set problem, which is usually the pricing problem of path (set-partitioning) formulations for the graph coloring problem (see, e.g., Gualandi and Malucelli [START_REF] Gualandi | Exact solution of graph coloring problems via constraint programming and column generation[END_REF]). An iterative refinement method is proposed by the authors to deal with the exponential size of the model.

Conclusion and Future Research Directions

In this survey, we reviewed over one hundred papers related to arc flow formulations. Many of these papers present arc flow models having pseudo-polynomial size and a strong linear relaxation. The number of applications of pseudo-polynomial arc flow formulations has grown considerably since the work by Valério de Carvalho [START_REF] Valério De Carvalho | Exact solution of bin-packing problems using column generation and branch-and-bound[END_REF], making them a valid alternative to path formulations. For many combinatorial optimization problems, path formulations are still the best alternative, because they can embed difficult constraints in the subproblem solved to build the paths. However, arc flow formulations have many positive aspects, among which we highlight that: they are powerful modeling tools that allow one to model complex issues from real systems; pseudo-polynomial arc flow models are often related to DW decompositions, providing strong linear relaxations; differently from path formulations, they provide models that usually have a number of variables which allows practical solutions directly by general MILP solvers, avoiding complex implementations; compared to equivalent path formulations, they have a richer description of the dual space, leading to a faster convergence of simplex-based methods; pseudo-polynomial arc flow models can be derived from state-space relaxations from the underlying DP network from path models.

This survey is a contribution to a systematic study of arc flow formulations, but we would like to point out that there are many open questions and research lines to be pursued. Some of them are the following.

One of the advantages of arc flow formulations is that they provide a tighter description of the dual feasible space keeping the primal strength. Besides the methodologies presented in this paper, are there any general hints on how to do both primal and dual strengthening in arc flow models? For example, in extended formulations, using new sets of variables may strengthen the primal model and, as new (primal) variables are dual cuts, there is also a richer description of the dual feasible space. Models presented in this survey explore solution spaces that are convex combinations of flows, each corresponding to an s -t path, which is a sequence of arcs and vertices. Are there other types of structures (e.g., involving sequences of operations) that also lead to models with strong bounds? In fact, there are pseudo-polynomial models that, instead of using a sequence of arcs to form a path (which is an extremal solution), use a sequence of operations to form a solution that is extremal. Examples are Dyckhoff [START_REF] Dyckhoff | A new linear programming approach to the cutting stock problem[END_REF] for the CSP, and Silva et al. [START_REF] Silva | An integer programming model for twoand three-stage two-dimensional cutting stock problems[END_REF] and Furini et al. [START_REF] Furini | Modeling two-dimensional guillotine cutting problems via integer programming[END_REF] for the two-dimensional CSP with guillotine cuts. In these cases, one-cut operations are/have to be combined to form a cutting pattern (the extremal solution).

There are pseudo-polynomial models that do not provide LP lower bounds as strong as those of column generation (e.g., position indexed models for two-dimensional non-guillotine CSP). Is there any structural (extremal) property, in these cases, that can be explored and may lead to models with stronger bounds?

Several solution methods for large-scale arc flow models, like the ones presented in Section 6, are general and can be applied to any arc flow model based on DP. A general framework to solve large-scale arc flow models, containing such general tools, would be an interesting contribution to the optimization and operations research community.

  (a) Every directed path with a positive flow connects the source to the sink. (b) At most |V| + |A| paths and cycles have nonzero flow; out of these, at most |A| cycles have nonzero flow.

Figure 1 :

 1 Figure 1: Example of network N KP for the knapsack problem.

Figure 2 :

 2 Figure 2: Example of network N KP -SSR obtained from a state-space relaxation of N KP .

Dual InsightOther than the considerably smaller size, arc flow formulations present more advantages over path formulations. From a primal point of view, one of such advantages is the possible recombination of

Acknowledgement

The first and fourth authors have been supported by FAPESP -Fundação de Amparo à Pesquisa do Estado de São Paulo (under grant numbers 2017/11831-1 and 2019/12728-5). The second and the fifth authors have been supported by FCT -Fundação para a Ciência e Tecnologia within the R&D Units Project Scope: UIDB/00319/2020.