Assignment Problem Calculator (Hungarian Method)

What the assignment problem solves

The assignment problem answers a question that recurs across operations: given a set of agents and a set of tasks, where each agent can perform each task at a known cost or with a known value, how do you pair them one-to-one so the total is best? Every agent takes exactly one task and every task goes to exactly one agent, and the aim is either to minimize total cost, of time, money, or distance, or to maximize total value, of profit, output, or preference. It is the model behind rostering workers to jobs, machines to orders, crews to routes, projects to teams, and even players to positions, wherever the pairing is exclusive and each combination carries its own number.

What makes the problem clean is the exclusivity of the pairing. Because each agent and each task is used once, the decision is a permutation, a matching, and the best matching can be found exactly and quickly rather than searched by trial and error. The number of possible assignments grows explosively with size, so checking them all is hopeless even for modest problems, but the special structure means a dedicated algorithm, the Hungarian method, cuts straight to the optimum. And like its parent the transportation problem, the assignment problem always returns a clean whole assignment, never a fractional one, because that same network structure guarantees integer solutions.

This calculator finds the optimal one-to-one assignment for any cost or value matrix you enter. Type one agent per line with a cost for each task, choose whether to minimize or maximize, and it returns which agent takes which task, the optimal total, and, when the numbers of agents and tasks differ, which agents or tasks are left unassigned. It highlights the chosen cells in the matrix, charts the value of each pairing, and handles rectangular problems automatically. Everything runs in your browser, and nothing you enter is stored.

How this calculator works, step by step

Start by choosing the objective. Select minimize when the matrix holds costs, times, or distances you want as small as possible, and maximize when it holds profits, scores, or outputs you want as large as possible. Then enter the matrix: one agent per line, and on each line the cost or value of that agent doing each task, separated by spaces or commas, with the tasks in the same order across lines. The calculator opens with a worked four-agent, four-task minimization already filled in, so you can see a complete optimal assignment and its total before changing anything.

As soon as the matrix is valid the tool solves it with the Hungarian method. If the matrix is not square, it pads it to square with dummy agents or tasks at zero cost so the algorithm can run, then strips the dummies out of the reported answer. For a maximization it first converts the values to an equivalent cost form, solves, and translates back, so the total it reports is in the units you entered. The whole computation is instant and re-runs live as you edit, so you can see how changing a single cost reshuffles the optimal pairing.

The result panel headlines the optimal total, then shows the cost matrix with the chosen cells highlighted, so you can read the assignment at a glance: each highlighted cell is an agent-to-task pairing in the optimal plan. Below, a note states whether it minimized or maximized and lists any agents or tasks left unassigned when the problem is unbalanced. A chart shows the cost or value of each chosen pairing, which points to the most and least expensive matches. Download a PDF or CSV of the assignment or share it; all of it happens locally.

How the Hungarian method reaches the optimum

The engine behind this calculator is the Hungarian method, the algorithm designed specifically for the assignment problem, and its logic is elegant enough to follow even though the calculator does the arithmetic. It rests on a simple observation: subtracting a constant from every entry in a row, or in a column, does not change which assignment is optimal, because every complete assignment uses exactly one cell from that row or column and so is reduced by the same constant. The method uses that freedom to create zeros. It subtracts the smallest entry in each row from that row, then the smallest in each column from that column, so that every row and column has at least one zero.

With zeros exposed, the goal becomes finding a complete assignment that uses only zero-cost cells, which would then be optimal in the reduced matrix and therefore in the original. If such an assignment exists, the method is done.

If not, it covers all the zeros with the fewest possible lines through rows and columns, finds the smallest uncovered entry, subtracts it from all uncovered entries and adds it to entries covered twice, which creates new zeros without losing the old structure, and tries again.

Each round brings a complete zero-cost assignment closer, and the process is guaranteed to terminate at the optimum in a number of steps that grows only as the cube of the matrix size. This calculator implements an efficient cubic-time version of exactly this procedure, so it returns the proven optimal assignment quickly even for large matrices.

It is worth appreciating how much that efficiency matters, because the alternative is hopeless. A brute-force search would try every possible one-to-one matching, and the number of those grows as the factorial of the matrix size: a five-by-five problem has 120 assignments, a ten-by-ten has over three million, and a fifteen-by-fifteen has more than a trillion, beyond any practical enumeration.

The Hungarian method sidesteps that explosion entirely by working on the cost structure rather than the assignments, reaching the optimum in a number of operations that grows only with the cube of the size, so doubling the problem multiplies the work by about eight rather than by an astronomical factor.

That gap between factorial and cubic is precisely why a dedicated algorithm exists and why the assignment problem is considered solved in a way that many superficially similar combinatorial problems are not.

Five worked examples you can follow

Example 1: the default four-by-four

The calculator opens minimizing a four-agent, four-task cost matrix, and the optimal assignment has a total cost of 49. Reading the highlighted cells shows which agent is matched to which task, and you can confirm that every agent has exactly one task and every task exactly one agent. This is the canonical form of the problem: a square matrix, a minimization, and a unique-looking optimum, and it is a good starting point for changing a single cost to watch the whole assignment rearrange in response, which is often surprising.

Example 2: maximizing instead

Switch the objective to maximize and read the same matrix as values, say a table of the profit each salesperson would generate in each territory. Now the calculator finds the one-to-one assignment with the greatest total, matching people to territories to maximize combined profit. The switch is a single control, and it demonstrates that the model is agnostic about direction: cost to minimize or value to maximize, the Hungarian method solves both, and the result is reported in the units you entered so the total reads directly as dollars, hours, or points.

Example 3: more agents than tasks

Enter a matrix with more rows than columns, say five workers but only three jobs. The calculator pads the matrix with dummy tasks at zero cost, solves, and reports the three optimal worker-to-job pairings plus the two workers left unassigned. Those unassigned agents are the practical answer to who is idle this round under the cheapest plan, which matters when you are deciding not only how to assign but whom to keep on standby, and it is information the raw matrix does not hand you until the problem is solved.

Example 4: more tasks than agents

The reverse case is just as common: more jobs than people to do them. Enter more columns than rows, and the calculator pads with dummy agents, solves, and reports which tasks go undone in the optimal plan. This tells you not just how to deploy the people you have for greatest effect, but exactly which work will not be covered, so you can decide whether to hire, defer, or outsource the leftover tasks. Making the shortfall explicit is one of the quiet strengths of solving the model rather than assigning by hand.

Example 5: a hand-checkable case

Try a small three-by-three matrix where you can verify the answer yourself, for instance costs that make one pairing obviously cheapest. With only six possible assignments in a three-by-three problem, you can enumerate them on paper and confirm the calculator picks the minimum, which builds confidence before you trust it on a larger matrix where enumeration is impossible. A tie, where two different assignments share the lowest total, is worth trying too: the calculator returns one of them, and seeing that a different equally optimal answer is not wrong is a useful lesson.

Three expert tips for a clean solve

Minimize or maximize: the same model, two directions

One of the assignment model’s conveniences is that it handles both minimization and maximization with no change to the method, only a transformation of the numbers. When you want the cheapest or fastest pairing, you feed in costs or times and minimize directly.

When you want the most profitable or highest-scoring pairing, you feed in values and maximize, and the standard trick is to convert the maximization into a minimization by subtracting every value from the largest value in the matrix.

That flips the problem so that the most valuable pairings become the lowest-cost cells, the Hungarian method minimizes as usual, and the assignment it finds is exactly the one that maximizes the original total.

This calculator does that conversion for you when you select maximize, and it reports the answer back in your original units, so the total you see is the real maximum profit or score, not the transformed figure.

The practical upshot is that a single tool covers a wide range of real decisions that look different but share the same structure: assigning workers to jobs to minimize labour cost, assigning salespeople to regions to maximize revenue, assigning machines to orders to minimize setup time, assigning graduates to postings to maximize preference satisfaction.

What unites them is the one-to-one exclusivity and an additive total, and once a problem fits that shape, choosing minimize or maximize is the only decision you need to make about direction. Getting that toggle right matters, because minimizing a profit matrix or maximizing a cost matrix produces a valid-looking but exactly wrong answer.

A special case of the transportation problem

The assignment problem is not a separate species from the transportation problem; it is the transportation problem with every supply and every demand set to one. Each agent is a source with one unit to give, each task is a destination needing one unit, and the cost of shipping that unit is the cost of the pairing.

Seen this way, an assignment problem could be handed to the transportation calculator or even the general linear program, and the answer would be identical.

The reason it gets its own tool and its own algorithm is efficiency: the all-ones structure is so special that the Hungarian method exploits it to solve the problem faster than the transportation method would, which itself beats the general simplex.

That lineage carries a valuable guarantee. Because the assignment problem is a network-structured linear program, it inherits the integrality property: with any cost matrix, the optimal solution is automatically a clean one-to-one matching, never a fraction of an agent split across tasks. This is why you never have to round the result, and it is the same property that makes the transportation problem return whole shipments. The kinship also clarifies when to reach for which tool.

If your problem genuinely pairs equal-sized sets one-to-one, the assignment calculator and the Hungarian method are the sharpest instrument; if it ships divisible quantities from sources to destinations, the transportation calculator fits; and if it has a more general structure, the linear programming calculator is the fallback.

All three live in the optimization cluster of the Operations Research hub precisely because they are variations on the same theme.

There is a practical reason the specialization is worth caring about beyond raw speed. Because the assignment problem is the tightest of the three models, framing a decision as an assignment forces a useful discipline: it makes you state the exclusivity explicitly, one agent to one task, and confront whether that is really true before solving. That framing often clarifies the decision itself.

A manager who casually says “assign the team to the projects” may discover, in building the matrix, that two people are needed on one project or that one person will straddle two, and that discovery, prompted by the model’s strict shape, is itself valuable because it reveals the real structure of the problem.

When the one-to-one frame does fit, its tightness pays off in a fast, unambiguous, whole-number answer; when it does not, the attempt to force it is the signal to step up to the transportation or general linear model, and the calculator’s family of tools is arranged so that stepping up is a short move rather than a restart.

Common mistakes to avoid

A handful of errors recur and produce wrong or misleading assignments. Watch for these.

• Wrong objective direction. Minimizing a profit table or maximizing a cost table gives a precise answer to the opposite question. Set the toggle to match what the numbers mean.
• Misaligned rows. Each agent’s row must list one cost per task in the same order. A shifted or missing entry solves a different matrix with no warning.
• Ignoring the unassigned list. On an unbalanced problem the idle agents or uncovered tasks are the point, not leftovers to discard; they are who is spare or what is undone.
• Forcing a square matrix by hand. You do not need to pad the matrix yourself; the tool does it correctly. Adding your own dummy rows with guessed costs can distort the optimum.
• Assuming the optimum is unique. Ties are common when costs repeat. A different assignment with the same total is equally optimal, not an error.
• Non-additive value. The model assumes the value of a pairing does not depend on the other pairings. If assigning A to task 1 changes what B is worth on task 2, the simple assignment model does not apply.
• Blocking impossible pairings with a blank. If an agent cannot do a task, give that cell a very large cost (for minimize) so the optimizer avoids it, rather than leaving it empty.

Where this model fits in the toolkit

The assignment problem sits in the optimization cluster of operations research, the smallest and sharpest of the three network models the Operations Research hub groups together.

It is the one-to-one special case of the transportation problem, which in turn is a structured linear program, so the three form a family from most specific to most general: use assignment when the pairing is exclusive and equal-sized, transportation when divisible quantities flow from sources to destinations, and linear programming when the structure is arbitrary.

Choosing the most specific tool that fits gives the fastest, cleanest answer, which is why the assignment calculator exists alongside the others rather than being folded into them.

Beyond the optimization cluster, assignment decisions feed and draw on the rest of the toolkit. The costs in the matrix often come from time studies, rates, or capability scores measured elsewhere, and the resulting roster feeds scheduling and workforce plans. Where queuing theory sizes how many servers a system needs, the assignment problem decides which specific servers or people take which specific duties once that number is set.

In project and operations management the same model matches crews to jobs and equipment to sites, and its exclusivity assumption is exactly what makes it the right tool for those one-to-one decisions and the wrong one when tasks can be shared. Seen in context, it is the precise instrument for exclusive matching, one member of the optimization family you reach for when the pairing must be clean.

Return to the Operations Research hub for the full set of models.

The origin of the Hungarian method

The assignment problem and its famous algorithm have a genuinely international and layered history. The method was published in 1955 by the American mathematician Harold Kuhn, who named it the Hungarian method in tribute to the two Hungarian mathematicians whose earlier theorems it rests on: Denes Koenig, whose work on graph matchings supplied the combinatorial backbone, and Jeno Egervary, who generalized a key result. Kuhn built their ideas into a practical, polynomial-time procedure, and James Munkres later reviewed and refined it, which is why the algorithm is also called the Kuhn-Munkres algorithm.

There is a further twist that makes the story a favourite in the history of optimization: it later emerged that the essential method had been described decades earlier, in the 1890s, by the German mathematician Carl Gustav Jacobi, in work published posthumously in Latin and long overlooked. That rediscovery does not diminish Kuhn’s contribution, which made the method usable and connected it to the wider theory of linear programming and duality that was crystallizing in the 1950s.

The Hungarian method holds a special place because it was one of the first combinatorial optimization problems shown to be solvable in polynomial time, a landmark on the road to the modern theory of efficient algorithms.

That a clean, hand-followable procedure on a cost grid turned out to be both practically indispensable and theoretically deep is why the assignment problem remains a fixture of every operations research course and why a calculator that applies the Hungarian method to any matrix is a genuinely useful tool.

The method’s reach today is quietly enormous. The same algorithm that Kuhn wrote down for pairing people with jobs now runs inside tracking systems that match radar detections to objects frame by frame, inside ride-hailing platforms that pair drivers with riders, inside computer-vision pipelines that link points between images, and inside scheduling engines across manufacturing and logistics. Each of these is, underneath, the same cost matrix and the same search for the best one-to-one matching, which is a striking demonstration that a well-chosen abstraction outlives the problem that inspired it.

Setting up a real matching decision

Turning a real situation into an assignment model is mostly about naming the two sets cleanly and filling one honest number into each cell. The agents are whatever you have exactly one of to give per pairing, workers, machines, crews, vehicles, and the tasks are whatever each agent will be matched to, jobs, orders, routes, shifts. The defining test is exclusivity: one agent takes one task and no more, and one task is done by one agent and no more. If that is not literally true, if a worker can take two jobs, or a job needs two people, the plain assignment model is the wrong shape and a richer model is needed, so it is worth checking the exclusivity before anything else.

Each cell holds the cost or value of that specific pairing, and getting these comparable is the real work. Every entry must be in the same unit and must genuinely be the cost of that agent doing that task in isolation, the hours it would take, the money it would cost, the revenue it would earn, the preference score it would satisfy. If two of these matter at once, say cost and quality, you have to combine them into a single number per cell first, perhaps a weighted score, because the method optimizes one total. Decide the direction to match: minimize for costs, times, and distances; maximize for profits, outputs, and satisfaction scores.

Two practical situations come up often enough to plan for. When a particular agent simply cannot do a particular task, do not leave the cell blank; enter a prohibitively large cost (for a minimization) or a very low value (for a maximization) so the optimizer treats the pairing as available in principle but never worth choosing.

And when the two sets are different sizes, enter the rectangular matrix as it stands and let the tool balance it rather than inventing your own dummy rows, because the padding must be done at a neutral cost to avoid distorting the optimum.

With the sets named, the cells filled consistently, the impossible pairings blocked, and the direction chosen, the model is a faithful picture of the decision, and the solver does the rest.

When one-to-one is the wrong shape

The assignment model is deliberately narrow, and its narrowness is exactly the exclusivity that makes it fast and clean, so the honest boundary of the tool is the point where that exclusivity breaks.

The most common departure is capacity: if an agent can handle several tasks, or a task needs several agents, the problem becomes a generalized assignment problem, where each agent has a capacity and each task a requirement, and it needs integer-programming methods rather than the Hungarian algorithm.

Forcing such a problem into a one-to-one matrix, by splitting agents into copies, is sometimes a workable approximation but is easy to get subtly wrong, so it is better recognized as a different model.

A second departure is the objective. The plain assignment problem minimizes or maximizes a sum, which is right when the totals genuinely add, but some decisions care about the worst pairing rather than the total, for instance minimizing the latest finish time across all jobs rather than the sum of times. That is the bottleneck assignment problem, and it needs a different method because the objective is a maximum, not a sum.

Interacting values are a third departure: the plain model assumes the worth of pairing A with task 1 does not change what B is worth on task 2, and when synergies or conflicts between pairings exist, the additive assumption fails and a quadratic assignment model applies, which is far harder.

None of these is a reason to distrust the assignment calculator for the many decisions that truly are one-to-one with an additive total; they simply mark where you should reach for a more general model, and recognizing the shape of your problem before solving is what keeps the answer meaningful.

Beyond the total: ties, fairness, and second criteria

The optimal total is the headline, but a good matching decision often has to consider more than the single number, and understanding what the model does and does not settle keeps you from over-reading its output.

The most common subtlety is ties: when several costs are equal, more than one assignment can achieve the same optimal total, and the calculator returns one of them without implying the others are worse.

If you have a secondary preference, giving a particular worker a job they favour when the cost is identical, avoiding an assignment someone did last time, the model will not know it unless you encode it, which you can do by nudging the relevant cell by a tiny amount so the tie breaks in the direction you want without changing which assignment is genuinely cheapest.

Fairness is a related concern the plain total ignores. Minimizing the sum of costs can concentrate the unpleasant or expensive tasks on one agent while the total stays lowest, which may be efficient but not acceptable, and if balance across agents matters you either add a fairness term to each cell or check the per-pairing chart the calculator draws to see whether the load is lopsided. That chart, showing the cost or value of each chosen pairing, is the quickest way to spot an assignment that is optimal in total but uncomfortable in distribution, and it often prompts a small manual adjustment that trades a little total cost for a lot of balance.

Finally, treat the costs as estimates and sanity-check the plan. If the optimal assignment pairs an agent with a task that intuition says is a poor fit, that is worth investigating: either the cost was mis-entered, or the model is revealing a genuinely counter-intuitive but better matching, and both outcomes are valuable. The assignment calculator gives the mathematically optimal pairing for the numbers you provide; judging whether those numbers, and the one-to-one additive frame, capture the real decision is the analyst’s job, and reading the assignment critically rather than accepting it blindly is what turns the tool from an answer machine into a decision aid.

Input format and quick reference

Choose minimize or maximize, then enter the matrix with one agent per line and a cost or value for each task on that line, separated by spaces or commas, keeping tasks in the same order across lines. The matrix need not be square; the tool balances it and reports any unassigned agents or tasks. The reference below explains each part of the result.

Frequently asked questions

Sources, disclaimer, and editorial transparency

This calculator solves the assignment problem with the Hungarian (Kuhn-Munkres) algorithm, the standard operations research method, handling rectangular matrices by zero-cost padding and maximization by cost transformation. This calculator and guide are built and reviewed by the OpsCalculators team; see our Editorial Policy for how each tool is researched, built, and tested.

Results are accurate estimates for planning and education, not certified engineering advice, and assume one-to-one exclusive pairing with an additive total whose per-pairing values do not interact; problems with shared tasks or interacting values need a different model. Validate against your own data before committing assignments. See our full Disclaimer. OpsCalculators.com is operated by MAFHH INTERNATIONAL LTD. Your inputs are processed in your browser and are never stored; see our Privacy Policy.