Generalized assignment problem

From Wikipedia, the free encyclopedia
Jump to: navigation, search

In 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.

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 maximum assignment problem. When the costs and profits of all agents-task assignment are equal, this problem reduces to the multiple knapsack problem. If there is a single agent, then, this problem reduces to the Knapsack problem.

Definition[edit]

In the following, we have n kinds of items, x_1 through x_n and m kinds of bins b_1 through b_m. Each bin b_i is associated with a budget w_i. For a bin b_i, each item x_j has a profit p_{ij} and a weight w_{ij}. A solution is a subset of items U and an assignment from U to the bins. A feasible solution is a solution in which for each bin b_i the total weight of assigned items is at most w_i. 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:

maximize \sum_{i=1}^m\sum_{j=1}^n p_{ij} x_{ij}.
subject to \sum_{j=1}^n w_{ij} x_{ij} \le w_i \qquad i=1, \ldots, m;
 \sum_{i=1}^m x_{ij} \leq 1 \qquad j=1, \ldots, n;
 x_{ij} \in \{0,1\} \qquad i=1, \ldots, m, \quad j=1, \ldots, n;

The generalized assignment problem is NP-hard, and it is even APX-hard to approximate it. Recently it was shown that an extension of it is e/(e-1) - \varepsilon hard to approximate for every \varepsilon.[citation needed]

Greedy approximation algorithm[edit]

Using any algorithm ALG  \alpha-approximation algorithm for the knapsack problem, it is possible to construct a ( \alpha+1)-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 j a tentative selection of items to bin b_j is selected. The selection for bin b_j might change as items might be reselected in a later iteration for other bins. The residual profit of an item x_i for bin b_j is p_{ij} if x_i is not selected for any other bin or  p_{ij}p_{ik} if x_i is selected for bin b_k.

Formally: We use a vector T to indicate the tentative schedule during the algorithm. Specifically, T[i]=j means the item x_i is scheduled on bin b_j and T[i]=-1 means that item x_i is not scheduled. The residual profit in iteration j is denoted by P_j, where P_j[i]=p_{ij} if item x_i is not scheduled (i.e. T[i]=-1) and P_j[i]=p_{ij}-p_{ik} if item x_i is scheduled on bin b_k (i.e. T[i]=k).

Formally:

Set T[i]=-1 for all i = 1\ldots n
For j=1...m do:
Call ALG to find a solution to bin b_j using the residual profit function P_j. Denote the selected items by S_j.
Update T using S_j, i.e., T[i]=j for all i \in S_j.

See also[edit]

References[edit]

External links[edit]