Recent from talks
Contribute something
Nothing was collected or created yet.
Generalized assignment problem
View on WikipediaIn applied mathematics, the maximum generalized assignment problem is a problem in combinatorial optimization. This problem is a generalization of the assignment problem in which both tasks and agents have a size. Moreover, the size of each task might vary from one agent to the other.
This problem in its most general form is as follows: There are a number of agents and a number of tasks. Any agent can be assigned to perform any task, incurring some cost and profit that may vary depending on the agent-task assignment. Moreover, each agent has a budget and the sum of the costs of tasks assigned to it cannot exceed this budget. It is required to find an assignment in which all agents do not exceed their budget and total profit of the assignment is maximized.
In special cases
[edit]In the special case in which all the agents' budgets and all tasks' costs are equal to 1, this problem reduces to the assignment problem. When the costs and profits of all tasks do not vary between different agents, this problem reduces to the multiple knapsack problem. If there is a single agent, then, this problem reduces to the knapsack problem.
Explanation of definition
[edit]In the following, we have n kinds of items, through and m kinds of bins through . Each bin is associated with a budget . For a bin , each item has a profit and a weight . A solution is an assignment from items to bins. A feasible solution is a solution in which for each bin the total weight of assigned items is at most . The solution's profit is the sum of profits for each item-bin assignment. The goal is to find a maximum profit feasible solution.
Mathematically the generalized assignment problem can be formulated as an integer program:
Complexity
[edit]The generalized assignment problem is NP-hard.[1] However, there are linear-programming relaxations which give a -approximation.[2]
Greedy approximation algorithm
[edit]For the problem variant in which not every item must be assigned to a bin, there is a family of algorithms for solving the GAP by using a combinatorial translation of any algorithm for the knapsack problem into an approximation algorithm for the GAP.[3]
Using any -approximation algorithm ALG for the knapsack problem, it is possible to construct a ()-approximation for the generalized assignment problem in a greedy manner using a residual profit concept. The algorithm constructs a schedule in iterations, where during iteration a tentative selection of items to bin is selected. The selection for bin might change as items might be reselected in a later iteration for other bins. The residual profit of an item for bin is if is not selected for any other bin or – if is selected for bin .
Formally: We use a vector to indicate the tentative schedule during the algorithm. Specifically, means the item is scheduled on bin and means that item is not scheduled. The residual profit in iteration is denoted by , where if item is not scheduled (i.e. ) and if item is scheduled on bin (i.e. ).
Formally:
- Set
- For do:
- Call ALG to find a solution to bin using the residual profit function . Denote the selected items by .
- Update using , i.e., for all .
See also
[edit]References
[edit]- ^ Özbakir, Lale; Baykasoğlu, Adil; Tapkan, Pınar (2010), Bees algorithm for generalized assignment problem, Applied Mathematics and Computation, vol. 215, Elsevier, pp. 3782–3795, doi:10.1016/j.amc.2009.11.018.
- ^ Fleischer, Lisa; Goemans, Michel X.; Mirrokni, Vahab S.; Sviridenko, Maxim (2006). Tight approximation algorithms for maximum general assignment problems. Proceedings of the seventeenth annual ACM-SIAM symposium on Discrete algorithm - SODA '06. pp. 611–620.
- ^ Cohen, Reuven; Katzir, Liran; Raz, Danny (2006). "An efficient approximation for the Generalized Assignment Problem". Information Processing Letters. 100 (4): 162–166. CiteSeerX 10.1.1.159.1947. doi:10.1016/j.ipl.2006.06.003.
Further reading
[edit]- Kellerer, Hans; Pferschy, Ulrich; Pisinger, David (2013-03-19). Knapsack Problems. Springer. ISBN 978-3-540-24777-7.
Generalized assignment problem
View on GrokipediaOverview
Definition
The generalized assignment problem (GAP) is a combinatorial optimization problem that involves assigning a set of tasks to agents, where each agent has a limited resource capacity , and assigning task to agent incurs a cost and consumes a resource amount .[11] The goal is to find an assignment that minimizes the total cost while ensuring that each task is assigned to exactly one agent and the total resource consumption for each agent does not exceed its capacity.[12] In this framework, the key decision variables are binary indicators , where if task is assigned to agent , and otherwise.[11] This setup generalizes the classical assignment problem by incorporating resource constraints on the agents, making it applicable to scenarios where assignments must respect limited capacities, such as production planning or resource allocation.[10] An informal example of the GAP is assigning jobs to machines in a manufacturing setting, where each machine has a total processing capacity limit, jobs vary in processing time depending on the machine, and the objective is to minimize overall operational costs while ensuring no machine is overloaded and every job is processed on exactly one machine.[11]Historical Development
The generalized assignment problem (GAP) originated in the field of operations research during the 1970s, building upon the classical assignment problem that had been formalized earlier through methods like the Hungarian algorithm. The problem formulation was first formally studied in 1973 by V. Srinivasan and G. L. Thompson as a special class of transportation problems.[3] The term "generalized assignment problem" and a branch-and-bound algorithm for solving it were introduced in 1975 by G. T. Ross and R. M. Soland, establishing it as a key model for resource allocation scenarios in combinatorial optimization.[13] By the late 1970s, the GAP's computational challenges were formally acknowledged in theoretical computer science. In their 1979 book Computers and Intractability: A Guide to the Theory of NP-Completeness, Michael R. Garey and David S. Johnson discussed the NP-completeness of related problems, proving the hardness of the GAP even for restricted cases and influencing subsequent research on approximation and exact methods. This classification spurred algorithmic developments in the 1980s, including an enumerative algorithm by Silvano Martello and Paolo Toth in 1981, which improved upon early branch-and-bound approaches for practical instances.[14] The 1990s saw comprehensive surveys that synthesized progress, such as the 1992 review by Dirk G. Cattrysse and Luk N. Van Wassenhove, which categorized exact, heuristic, and Lagrangian relaxation techniques for the GAP, highlighting its applications in production planning and facility location.[15] Post-1980s evolution extended the static model to dynamic variants, particularly in scheduling literature; for example, Kogan and Shtub introduced the dynamic GAP in 1997, incorporating time-dependent task arrivals and due dates to model evolving resource demands.[16] A broader historical overview in David W. Pentico's 2007 survey on assignment problems underscored the GAP's growth from a niche extension to a foundational model in optimization, with ongoing refinements in multi-objective and stochastic forms.[17]Mathematical Formulation
Integer Linear Programming Model
The Generalized Assignment Problem (GAP) is commonly modeled as an integer linear program to minimize the total assignment cost while respecting capacity constraints on agents and ensuring each task is assigned exactly once. This formulation captures the core structure of the problem, where agents have limited resources measured in processing times or similar units. Consider a set of agents indexed by and a set of tasks indexed by . The parameters include the assignment cost for assigning task to agent , the processing requirement of task on agent , and the capacity of agent . The decision variables are binary indicators , where if task is assigned to agent , and 0 otherwise. This standard formulation was first introduced by Srinivasan and Thompson in their study of a special class of transportation problems.[3] The complete integer linear programming model is given by: The first set of constraints ensures that every task is assigned to exactly one agent, while the second set enforces the capacity limits on each agent. The objective minimizes the total cost of the assignment. This model is widely adopted in optimization literature for exact solution methods such as branch-and-bound.[15] To obtain lower bounds for bounding procedures in branch-and-bound algorithms, a key relaxation is the linear programming (LP) relaxation, which replaces the binary constraints with for all . Solving this LP yields a lower bound on the optimal integer solution value, and computational studies have demonstrated that it often provides tight bounds, facilitating efficient enumeration of the search tree.[4]Network Flow Representation
The Generalized Assignment Problem (GAP) can be modeled as a minimum cost flow problem in a flow network derived from a bipartite graph structure. The network includes a source node , a sink node , agent nodes corresponding to the set of agents , and task nodes corresponding to the set of tasks . Arcs connect the source to each agent node with capacity (the resource capacity of agent ) and cost 0. From each agent node to each task node , there is an arc with capacity 1 and cost (the assignment cost of task to agent ). Finally, arcs connect each task node to the sink with capacity 1 and cost 0. The goal is to send a flow of value (assuming ) from to at minimum total cost, ensuring each task is assigned exactly once while respecting agent capacities. This formulation assumes unit processing times for all , where the flow value represents the number of tasks assigned to each agent.[18] The network diagram features the source at the top, connected downward to the agent nodes arranged in a layer. Each agent node branches to all task nodes in a second layer below, forming the bipartite connections. The task nodes then connect downward to the sink at the bottom. Capacities and costs are labeled on the arcs: on source-to-agent arcs, on agent-to-task arcs, and 1 on task-to-sink arcs. This structure leverages the bipartite nature of the assignment, transforming the combinatorial problem into a capacitated transportation network solvable via flow algorithms.[18] For the general case with arbitrary processing times , the unit-flow model no longer suffices because the resource consumption at agent from assigning task varies. One approach is to formulate the GAP as a minimum cost multicommodity flow problem, where each task represents a distinct commodity with unit flow demand (supply 1 at , demand 1 at ). The flow for commodity must route through exactly one agent , using arcs , with cost on the arc. Node capacities at agents enforce , where is the flow of commodity through agent (either 0 or 1). This captures the heterogeneous resource usage while ensuring integral flows for binary assignments.[10] To address general using single-commodity minimum cost flow, techniques such as layered networks can be applied. In a layered construction for agent , multiple copies of the task nodes are created, layered according to cumulative resource levels up to , with arcs between layers enforcing incremental assignments and costs. Alternatively, convex cost functions can be imposed on the agent-to-sink arcs to model the piecewise linear or separable costs arising from discrete assignments and varying , allowing polynomial-time algorithms for convex objectives. These extensions maintain the graphical structure but increase complexity for exact solutions.[19][20] The primary advantage of the network flow representation is its compatibility with established minimum cost flow algorithms, such as the successive shortest path algorithm with node potentials, which exploits reduced costs and Dijkstra's algorithm for efficiency. This enables exact solutions in polynomial time for the unit processing time case and provides a foundation for heuristics or relaxations in the general case, often outperforming direct integer programming for medium-sized instances.Special Cases and Relations
Connection to Classical Assignment Problem
The classical assignment problem (CAP), also known as the linear sum assignment problem, emerges as a special case of the generalized assignment problem (GAP) under specific parameter settings. In the CAP, there are equal numbers of jobs and agents (n = m), each job requires unit resource consumption regardless of the agent (w_{ij} = 1 for all i, j), and each agent has a unit capacity (b_i = 1 for all i). These conditions ensure that the capacity constraints in the GAP formulation—∑j w{ij} x_{ij} ≤ b_i for each agent i—simplify to at most one job per agent, while the requirement that each job is assigned exactly once (∑i x{ij} = 1 for each job j) forces exactly one job per agent, yielding the minimum-cost perfect bipartite matching.[21] This reduction transforms the GAP into the CAP, which can be solved in polynomial time using specialized algorithms such as the Hungarian method or the Jonker-Volgenant algorithm. The Hungarian method, originally developed for the CAP, iteratively finds optimal dual variables to solve the problem via augmenting paths in O(n^3) time, while the Jonker-Volgenant algorithm improves efficiency through cost-scaling and shortest-path techniques, often achieving practical speeds for instances up to n=1000. These methods exploit the balanced, unit-demand structure absent in the general GAP.[21] A representative example is assigning n jobs to n machines where each job takes unit time on any machine and each machine can process exactly one job, minimizing total processing cost. Without the unit capacities and uniform resource demands of the GAP, such balanced assignments would allow overloads or underutilization, but the special case enforces the one-to-one matching central to the CAP.[21] The GAP generalizes the CAP by incorporating heterogeneous agent capacities (varying b_i) and job-specific resource requirements (varying w_{ij}), which introduce the packing-like constraints that render the problem NP-hard in general while preserving the assignment core.[21]Links to Bin Packing and Knapsack Problems
The Generalized Assignment Problem (GAP) exhibits strong connections to classical packing problems, particularly through analogies and special-case reductions that highlight its capacity-constrained nature. In the bin packing analogy, agents are interpreted as heterogeneous bins each with a fixed capacity , while tasks represent items whose sizes may vary depending on the specific agent they are assigned to, and the assignment incurs a cost analogous to a packing penalty or profit. This framing positions the GAP as a generalized form of bin packing where item sizes are not fixed but agent-dependent, and the objective involves minimizing total cost rather than solely minimizing the number of bins used.[22] A direct reduction establishes the bin packing problem as a special case of the decision version of the GAP. Specifically, when all agent capacities are identical, task resource consumptions are independent of the agent i, and the problem checks whether all tasks can be feasibly assigned without exceeding capacities, this is equivalent to the classical bin packing decision problem. This reduction underscores how the GAP extends bin packing by incorporating variable costs and heterogeneous capacities.[22] The GAP also links closely to the knapsack problem family, with the multiple knapsack problem emerging as a key special case. When task resource consumptions and costs are independent of the agent , the GAP reduces to the multiple knapsack problem, where tasks are assigned to multiple knapsacks of capacities to maximize total profit without exceeding capacities. In the single-agent case (), this further simplifies to the classical 0-1 knapsack problem, focusing on selecting a subset of tasks for the single agent's capacity to optimize profit. These reductions arise naturally when agent-task interactions are uniform, bridging the GAP to unconstrained selection in knapsack variants.[22][23] An illustrative example of these links appears in scheduling tasks on limited-resource servers, where servers act as capacitated agents (bins) and tasks as items to be packed, with resource usage reflecting server-specific demands like CPU or memory. This setup mirrors bin packing for feasibility checks or multiple knapsack for profit maximization under uniform task values, common in cloud computing resource allocation.[24] Through these reductions and analogies, the GAP inherits the NP-hardness of bin packing and multiple knapsack problems, as solving the general case encompasses these NP-complete special instances. This shared complexity motivates similar approximation techniques across the problems, though the GAP's agent-dependent parameters amplify the challenge.[22]Computational Complexity
NP-Hardness Proofs
The decision version of the Generalized Assignment Problem (GAP), which determines whether there exists an assignment of all jobs to agents such that the total assignment cost is at most some bound while respecting the capacity constraints on agents, is NP-complete.[25] This NP-completeness follows directly from a reduction from the partition problem, a classic NP-complete problem. Specifically, consider a partition instance consisting of a set of positive integers with total sum ; the corresponding GAP instance has two agents each with capacity (), one job per integer with processing requirement equal to the integer value for both agents, and assignment costs set to the integer value and (with ). A feasible assignment achieving cost at most exists if and only if the integers can be partitioned into two subsets each summing to . This establishes the basic NP-hardness of GAP.[21][25] GAP is in fact strongly NP-hard, meaning it remains NP-hard even when all numerical parameters (costs, processing times, and capacities) are encoded in unary. This is shown by a polynomial-time reduction from the 3-partition problem, which is strongly NP-complete. Given a 3-partition instance with positive integers such that and for each (ensuring each subset has exactly three elements), construct a GAP instance with agents each having capacity , jobs with processing times for the corresponding job and all agents , and uniform costs (with ). An assignment respecting capacities exists if and only if the integers can be partitioned into triplets each summing to , as the size bounds prevent subsets of other cardinalities from fitting. This reduction preserves strong NP-hardness since the input sizes remain polynomial in unary encoding.[25][22] Even in the special case of uniform costs (where for all ), GAP is strongly NP-hard, as minimizing total cost reduces to feasibility of assignment under capacities, which is equivalent to the decision version of the bin packing problem (determining if all items can be packed into at most bins of capacity ). The latter is strongly NP-complete via a direct reduction from 3-partition, mirroring the construction above but interpreting agents as bins.[25][26] These hardness results are cataloged in the comprehensive classification of NP-complete problems, where GAP appears as [MP9] and its variants align with multiple knapsack problems under [KPn].[25]Parameterized Complexity
The parameterized complexity of the Generalized Assignment Problem (GAP) examines its solvability when analyzed with respect to specific parameters beyond the input size, such as the number of agents , the number of tasks , bounds on capacities , or profit thresholds. These analyses reveal that while GAP remains intractable under some natural parameters, it admits fixed-parameter tractable (FPT) algorithms and kernelizations for others, often leveraging dynamic programming (DP) techniques adapted from related problems like the multiple knapsack problem (MKP), a special case of GAP where profits are uniform.[27] When parameterized by the number of agents , GAP is W[28]-hard, indicating that no FPT algorithm exists unless the parameterized hierarchy collapses, a result following from the corresponding hardness of MKP under the same parameter. In contrast, for the parameter consisting of the maximum capacity , GAP admits a pseudo-polynomial time DP algorithm that runs in time , filling tables that track feasible assignments and profits for subsets of tasks per agent; this approach is FPT when combined with other small parameters like . Kernelization results further support tractability: for the number of tasks , a kernel of size exists via reduction rules that prune redundant tasks based on profit-to-size ratios, while for capacity vectors , a constant-size kernel is achievable through bounding and equivalence transformations.[27][27][27] For instances where the profit threshold (the target total profit in the decision version) is small, GAP is FPT with a running time of , employing a DP over subsets of high-profit tasks combined with greedy filling for the remainder. Although direct results for bounded treewidth are less explicit for GAP, its formulation as an integer linear program with bounded-width constraint matrices implies FPT solvability via monadic second-order logic encodings on tree decompositions, aligning with general results for packing problems. Post-2010 advances, such as refined kernelization for multi-dimensional variants, have extended these techniques to budgeted GAP extensions where agents have multiple resource budgets, yielding FPT algorithms parameterized by the number of budget types.[27][29]Solution Approaches
Exact Solution Methods
Exact solution methods for the Generalized Assignment Problem (GAP) aim to find optimal assignments guaranteeing minimality of the total cost while respecting capacity constraints, typically employing integer programming techniques due to the problem's NP-hard nature. These methods are suitable for moderate-sized instances where computational resources allow exhaustive enumeration or tight bounding. Common approaches include branch-and-bound algorithms enhanced with relaxations, dynamic programming for small-scale problems, and cutting-plane procedures to strengthen formulations, often integrated into mixed-integer programming (MIP) solvers. Branch-and-bound methods form the cornerstone of exact solvers for GAP, systematically exploring the solution space by branching on assignment variables (indicating whether task is assigned to agent ) while using lower bounds to prune suboptimal branches. Lagrangian relaxation is frequently employed to derive these bounds by dualizing the assignment constraints (ensuring each task is assigned exactly once), transforming the problem into separable subproblems solvable via dynamic programming or greedy methods, yielding a Lagrangian dual that provides a tight lower bound through subgradient optimization. For instance, relaxing the assignment constraints allows computing reduced costs for variable fixing, enabling early pruning of infeasible or suboptimal branches in a depth-first search. Seminal implementations, such as those combining Lagrangian relaxation with feasible-solution generators, have demonstrated effectiveness on instances with up to 3,000 binary variables, corresponding to approximately 30 agents and 100 tasks. Dynamic programming offers an exact approach for small instances, particularly when the number of agents or tasks is limited, by defining states that track the set of assigned tasks and the remaining capacities of agents. A pseudo-polynomial time algorithm can be formulated by processing tasks sequentially, with the state space comprising the current remaining capacities of the agents, computing the minimum cost recursively while ensuring feasibility. This method is viable for or , as the state complexity grows exponentially with the number of agents but polynomially with capacities if they are bounded. Cutting-plane methods enhance exact solvers by generating valid inequalities to tighten the linear programming relaxation of the MIP formulation, focusing on the knapsack-like capacity constraints for each agent. Cover inequalities, derived from the bin-packing structure of agent capacities, exclude fractional solutions by identifying subsets of tasks whose total resource demand exceeds available capacity unless properly assigned. Exact separation procedures for these knapsack polytopes, implemented via dynamic programming, have been integrated into branch-and-cut frameworks, significantly reducing the branch-and-bound tree size for GAP instances. Integration with commercial MIP solvers like CPLEX facilitates practical exact solutions by modeling GAP as a binary integer program and leveraging built-in branch-and-cut capabilities, augmented with GAP-specific enhancements such as custom Lagrangian bounds or user-defined cuts. These solvers apply preprocessing, presolving, and advanced branching strategies tailored to the assignment structure, often outperforming pure custom implementations for instances up to moderate sizes. Empirical performance of these exact methods on benchmark instances, such as Beasley's OR-Library datasets, shows solvability to optimality for problems with up to 50 tasks and 100 agents within reasonable time limits (e.g., hours on modern hardware), though larger instances require significant computation due to the combinatorial explosion. For example, branch-and-bound with variable fixing and Lagrangian relaxation solves all instances with 20 agents and 100 tasks exactly, highlighting the scalability limits for dense, tightly capacitated problems. Recent advances include network flow-based algorithms that reformulate GAP for efficient exact solving on larger instances using min-cost flow techniques.[18]Approximation and Heuristic Algorithms
The generalized assignment problem (GAP) admits several approximation algorithms with guaranteed performance ratios, particularly for the maximization variant where the goal is to maximize profit subject to capacity constraints. A seminal (1 - 1/e)-approximation algorithm, due to Shmoys and Tardos, solves a linear programming relaxation of the problem and rounds the fractional solution using a greedy procedure that assigns items to bins (agents) based on their marginal profit contributions.[30] This approach achieves an approximation ratio of approximately 0.632 and runs in polynomial time, making it suitable for instances where exact solutions are intractable.[30] Greedy algorithms for GAP typically prioritize assignments based on measures of efficiency, such as profit density (profit per unit resource for maximization) or cost density (cost per unit resource for minimization). In one class of such algorithms, jobs are ordered by decreasing desirability, defined via weight functions that evaluate the pseudo-cost or pseudo-profit of assigning a job to a machine, and assigned sequentially to the most suitable feasible machine.[31] Romeijn and Romero Morales analyze a family of these greedy methods and show that, under probabilistic assumptions on instance generation, they are asymptotically optimal relative to the LP relaxation, with performance improving as instance size grows.[31] For instances with a constant number of agents, a polynomial-time approximation scheme (PTAS) exists based on dynamic programming for related problems like class-constrained packing, with similar techniques applying to GAP. The running time is polynomial in the number of tasks but exponential in the number of agents, limiting its practicality to small m. Heuristic methods, such as local search and metaheuristics, are widely used for large-scale GAP instances to obtain near-optimal solutions efficiently. Local search explores neighborhoods defined by swaps (exchanging tasks between agents) and relocations (moving a task to another agent), accepting improving or non-worsening moves to escape local optima.[32] Tabu search enhances this by maintaining a tabu list to forbid recent moves, preventing cycling, and has been shown to achieve average optimality gaps of less than 1% on benchmark instances from the OR-Library and Yagiura datasets, even for problems with up to 100 agents and 1000 tasks.[32] Yagiura et al. further refine this with ejection chains in the neighborhood structure for better exploration.[33] Auction-based algorithms, originally developed by Bertsekas for the classical assignment problem, have been extended to GAP by incorporating capacity constraints through iterative bidding and price adjustments. In these extensions, unassigned tasks "bid" on agents based on cost reductions, with agents selecting the highest bidder until capacities are filled, yielding near-optimal assignments with ε-optimality guarantees for a tunable parameter ε.[34][35] Such methods are particularly effective in distributed settings, like multi-robot task allocation, where they converge quickly to solutions within 5-10% of optimality on large instances.[36] Emerging approaches include graph neural networks for approximating solutions to related assignment problems, showing promise for scalable heuristics in GAP variants as of 2024.[37]Applications and Extensions
Real-World Applications
The Generalized Assignment Problem (GAP) is widely applied in real-world scenarios across multiple industries, where it optimizes the allocation of tasks to resources under capacity and cost constraints, often leading to improved efficiency and reduced operational expenses. In logistics and computing sectors, GAP models help balance workloads while adhering to heterogeneous resource limits, such as time, memory, or personnel availability. These applications leverage exact and heuristic solution methods to handle large-scale instances, enabling practical decision-making in dynamic environments.[8] In job shop scheduling, GAP assigns tasks to machines, treating processing times as assignment costs and machine availability as capacity limits to minimize total completion time or setup overheads. This approach decomposes complex scheduling into subproblems solvable via GAP variants, enhancing robustness against uncertainties like machine breakdowns. For instance, decomposition heuristics based on GAP have been used to generate feasible schedules in manufacturing settings with multiple constraints.[38] Resource allocation in cloud computing employs GAP to assign virtual machines to physical servers, incorporating CPU, memory, and bandwidth capacities as resource bounds while minimizing energy costs or migration overheads. This formulation ensures efficient utilization of heterogeneous infrastructure, supporting scalable deployments in data centers. A joint allocation system for cloud environments has demonstrated how GAP heuristics can balance load distribution across servers to achieve cost-effective provisioning.[39] In transportation, particularly for vehicle routing with heterogeneous fleets, GAP assigns loads or customers to vehicles, using capacity constraints for cargo volume and costs for routing distances to optimize delivery efficiency. This application is crucial for logistics firms managing mixed vehicle types, where GAP-based heuristics provide near-optimal routes. The classic generalized assignment heuristic for vehicle routing, developed by Fisher and Jaikumar, has been foundational, yielding solutions within 2-5% of optimality in practical distribution networks.[40] Healthcare applications of GAP focus on nurse scheduling, assigning personnel to shifts based on skill levels, preferences, and ward capacities to ensure full coverage while minimizing overtime or dissatisfaction costs. This models nurses as agents with limited shift slots and patients/shifts as tasks with varying demands, often extended via goal programming for multi-objective balance. Case studies highlight GAP's impact in high-stakes sectors. In airline crew assignment, GAP formulations assign pilots and cabin staff to flight pairings under legal rest and qualification constraints, reducing payroll and deadhead travel expenses. Optimization techniques rooted in GAP have contributed to substantial savings; for example, as of 1993, crew scheduling enhancements at United Airlines yielded annual cost reductions of $16 million on a $600 million pilot payroll base.[41] In manufacturing line balancing, GAP allocates tasks to assembly workstations to equalize workloads and respect ergonomic or tool capacities, shortening cycle times and boosting throughput. A task bottleneck variant of GAP in inspection processes reported manufacturing cost and delivery time savings by optimizing supervisor assignments to stages.[42][43]Variants and Generalizations
The multi-objective generalized assignment problem (MO-GAP) extends the standard formulation by incorporating multiple conflicting objectives, such as minimizing total assignment cost while simultaneously balancing agent loads to avoid overloads. This variant seeks Pareto-optimal solutions, where no objective can be improved without degrading another, often addressed through scalarization techniques like weighted sums that combine objectives into a single function or epsilon-constraint methods that optimize one objective subject to bounds on others. For instance, in a bi-objective setting with linear cost and nonlinear completion time objectives, iterative reallocation procedures generate the non-dominated set by prioritizing assignments and applying time penalties.[44] The stochastic generalized assignment problem (S-GAP) introduces uncertainty, typically in job demands or processing requirements modeled as random variables, such as Bernoulli-distributed subsets of jobs requiring execution. Solutions employ recourse actions, like reassignments or penalties for unprocessed jobs, formulated as two-stage stochastic programs and solved via branch-and-bound with convex approximations of the recourse function for exact optimality. Scenario-based programming aggregates multiple realizations of uncertain parameters to derive robust assignments, ensuring feasibility across probable outcomes.[45] In the nonlinear generalized assignment problem (NL-GAP), capacity constraints incorporate nonlinear interactions among assigned tasks, such as convex or concave cost functions reflecting economies of scale or diminishing returns, which links to quadratic assignment variants through mutual task dependencies. This extension arises in production planning where agent capacities exhibit subadditive effects, solved using branch-and-bound algorithms that integrate nonlinear programming relaxations with GAP-specific bounds; recent advances provide tighter lower and upper bounds via reformulations for continuous relaxations.[46][47] The dynamic generalized assignment problem (D-GAP) accounts for time-varying task arrivals or demands, often under stochastic conditions, requiring online algorithms that make irrevocable decisions as tasks appear sequentially. In settings with stochastic unit demands, pseudo-polynomial dynamic programming reduces the problem to deterministic assignments at discrete time points, converging to global optima as time discretization refines, with applications in real-time scheduling. Online variants, assuming bounded item sizes, achieve competitive ratios through adaptive thresholds that balance immediate costs against future uncertainties.[48][24] Recent variants emphasize sustainability, integrating environmental costs like carbon emissions into the objective function alongside traditional costs, particularly in logistics where assignments to facilities minimize both economic and ecological impacts. Multi-objective models in sustainable location problems allocate customers to agents using emission-based rules, solved via evolutionary algorithms like NSGA-II, revealing that distance heuristics provide near-optimal trade-offs with substantial computational savings.[49]References
- The generalized assignment problem (GAP) is that of finding a maximum profit assignment from n tasks to m machines such that each task is assigned to precisely ...
