Priority Matching in Graphs

• The paper introduces a lexicographic maximum priority matching framework that prioritizes matching high-priority vertices in graphs.
• It extends Edmonds’ augmenting-path algorithm with priority-aware paths and blossom shrinking to maintain lexicographic optimality while achieving maximum matching size.
• The approach computes matchings in O(mn) time and finds applications in scheduling problems such as crossbar switch routing for high-priority traffic.

Maximum priority matching is a graph-matching problem in which vertices, rather than edges, carry an ordered importance level, and the objective is to maximize matched coverage lexicographically across those priority classes. Given an undirected graph $G=(V,E)$ with $|V|=n$, $|E|=m$, and a priority map $\rho:V\to[1,n]$ where $1$ is highest priority, a matching $M\subseteq E$ is evaluated by the vector of matched-vertex counts

$\bigl(c_1(M),c_2(M),\dots,c_n(M)\bigr),$

where $c_i(M)$ is the number of matched vertices of priority $i$. A maximum priority matching is one whose priority score is lexicographically maximum: first maximize $c_1$, then $|V|=n$0 subject to that, then $|V|=n$1, and so on. The central result is a variation of Edmonds’ augmenting-path algorithm, including blossom shrinking for general graphs, that computes such a matching in $|V|=n$2 time; the resulting matching is also a maximum size matching (Turner, 2015).

1. Problem formulation and lexicographic objective

The underlying graph model is the standard one for matchings. A matching $|V|=n$3 is a set of edges with no shared endpoints, so every vertex is incident to at most one matched edge. A vertex is matched if some edge of $|V|=n$4 is incident to it and unmatched otherwise. Each vertex $|V|=n$5 is assigned an integer priority $|V|=n$6, with smaller values denoting higher importance (Turner, 2015).

For each priority level $|V|=n$7,

$|V|=n$8

The priority score of $|V|=n$9 may be viewed either as the vector $|E|=m$0 or as an $|E|=m$1-digit base-$|E|=m$2 integer whose $|E|=m$3-th most significant digit is $|E|=m$4. The optimization criterion is lexicographic. A matching $|E|=m$5 is preferred to $|E|=m$6 if, at the smallest index $|E|=m$7 where they differ, $|E|=m$8. This imposes strict dominance of higher-priority classes over lower-priority ones: matching one additional priority-1 vertex is worth more than any change involving only lower priorities (Turner, 2015).

The paper also defines the $|E|=m$9-score of a matching as $\rho:V\to[1,n]$0. This supports a staged interpretation of the objective: maximize the 1-score, then maximize the 2-score without reducing the 1-score, and continue through all priorities. Conceptually, this places maximum priority matching within lexicographic multi-criteria optimization, with one criterion per priority class.

This objective differs from ordinary maximum cardinality matching, which maximizes only $\rho:V\to[1,n]$1. A maximum-cardinality matching can ignore high-priority vertices in favor of matching more lower-priority ones, whereas a maximum-priority matching is defined by the lexicographic counts. The paper nonetheless proves that the final maximum priority matching is also a maximum size matching, so lexicographic optimality does not ultimately sacrifice cardinality in the final solution (Turner, 2015).

2. Priority-aware augmenting paths

The algorithmic core is a modification of the augmenting-path method. In classical matching, an augmenting path alternates between unmatched and matched edges and has both endpoints unmatched; flipping its edges increases the matching size by one. For priority matchings, the relevant augmenting paths are constrained so that they improve a specific priority class without worsening any higher class (Turner, 2015).

The paper first isolates the two-priority case. Let $\rho:V\to[1,n]$2, and suppose the goal is to maximize the number of matched vertices in $\rho:V\to[1,n]$3. An augmenting path with respect to $\rho:V\to[1,n]$4 is a path

$\rho:V\to[1,n]$5

such that edges alternate between non-$\rho:V\to[1,n]$6 and $\rho:V\to[1,n]$7, $\rho:V\to[1,n]$8 is unmatched and belongs to $\rho:V\to[1,n]$9, and if $1$0 is matched then $1$1. Flipping along such a path matches at least one new vertex of $1$2 and never causes a previously matched vertex of $1$3 to become unmatched. The paper proves the analogue of Edmonds’ theorem for this setting: if $1$4 does not attain the maximum possible number of matched vertices in $1$5, then such a path exists. The proof uses the symmetric difference between $1$6 and an optimal matching $1$7, whose components are alternating paths and cycles; one path must witness the improvement in matched $1$8-vertices (Turner, 2015).

In bipartite graphs, the search uses alternating forests rooted at unmatched vertices in $1$9. Vertices are labeled even, odd, or unreached, according to parity in the alternating trees. Eligible edges are processed from even vertices. The search distinguishes the standard cases: extending the tree through a matched unreached vertex, finding an unmatched unreached vertex, joining two even vertices in different trees to obtain an augmenting path, or ignoring edges to odd vertices. The essential change from classical breadth-first search is the endpoint condition: the search accepts paths that improve the targeted priority count rather than merely size (Turner, 2015).

For the full hierarchy of priorities, the paper defines an $M\subseteq E$0-augmenting path for a matching $M\subseteq E$1 that already has maximum $M\subseteq E$2-score. Such a path

$M\subseteq E$3

alternates between unmatched and matched edges, starts at an unmatched vertex with $M\subseteq E$4, and, if $M\subseteq E$5 is matched, ends at a vertex of priority strictly worse than $M\subseteq E$6, namely $M\subseteq E$7. Flipping an $M\subseteq E$8-augmenting path strictly increases the number of matched priority-$M\subseteq E$9 vertices and does not reduce the number of matched vertices of any priority $\bigl(c_1(M),c_2(M),\dots,c_n(M)\bigr),$0 (Turner, 2015).

3. General graphs, blossoms, and search structure

In general graphs, odd cycles obstruct a direct alternating-tree search. The algorithm therefore adopts blossom shrinking exactly in the spirit of Edmonds’ method, but with priority-aware stopping and shrinking conditions (Turner, 2015).

A blossom is an odd-length cycle encountered during search that satisfies the usual structural conditions. The notation $\bigl(c_1(M),c_2(M),\dots,c_n(M)\bigr),$1 denotes the largest blossom containing $\bigl(c_1(M),c_2(M),\dots,c_n(M)\bigr),$2; for vertices not inside any nontrivial blossom, $\bigl(c_1(M),c_2(M),\dots,c_n(M)\bigr),$3. Every blossom has a distinguished base vertex, the unique vertex in the blossom not matched inside the blossom. When a blossom is shrunk, it becomes a single super-vertex in the contracted graph, and search continues there.

For a fixed priority level $\bigl(c_1(M),c_2(M),\dots,c_n(M)\bigr),$4, the search is rooted at unmatched vertices of priority exactly $\bigl(c_1(M),c_2(M),\dots,c_n(M)\bigr),$5. Eligible edges are processed from even blossom-vertices. The paper distinguishes five cases. If the edge reaches an unreached matched vertex, the tree is extended through that vertex and its matching mate; if the mate has priority greater than $\bigl(c_1(M),c_2(M),\dots,c_n(M)\bigr),$6, an $\bigl(c_1(M),c_2(M),\dots,c_n(M)\bigr),$7-augmenting path has been found. If the edge reaches an unreached unmatched vertex, the root-to-even path plus the edge yields an augmenting path. If it reaches an even vertex in a different tree, the two tree paths together with the edge give an augmenting path. If it reaches an even vertex in the same tree, an odd cycle is detected; if some odd vertex on that cycle has priority greater than $\bigl(c_1(M),c_2(M),\dots,c_n(M)\bigr),$8, the cycle itself yields an augmenting path, otherwise the cycle is shrunk as a blossom. If the edge reaches an odd vertex, it is ignored (Turner, 2015).

This search mechanism is the direct generalization of the two-priority case to arbitrary priorities. Priority enters in exactly two places: which roots are used, and whether a reached vertex or blossom immediately certifies an $\bigl(c_1(M),c_2(M),\dots,c_n(M)\bigr),$9-augmenting path. If not, the structure is shrunk and search continues. The correctness proof follows the classical Edmonds-Tarjan pattern, relying on parity, blossom structure, and contraction invariants, but with the lexicographic constraints folded into the endpoint conditions (Turner, 2015).

4. Iterative optimization over priority classes

The full algorithm processes priorities in increasing numerical order:

1. initialize a matching $c_i(M)$0,
2. for $c_i(M)$1 to $c_i(M)$2, repeatedly augment along $c_i(M)$3-augmenting paths until none remain.

Once no more $c_i(M)$4-augmenting paths exist, the matching has maximum $c_i(M)$5-score. Repeating this for all $c_i(M)$6 yields a lexicographically maximum priority score (Turner, 2015).

The central theorem states: if $c_i(M)$7 has maximum $c_i(M)$8-score, then there exists an $c_i(M)$9-augmenting path if and only if $i$0 does not have maximum $i$1-score. The proof again uses symmetric difference with a matching that has better $i$2-score, decomposing the difference into paths and cycles and identifying a path whose endpoints satisfy the required priority conditions (Turner, 2015).

Several invariants drive the termination argument in the unlimited-priority setting. Every tree root is unmatched with priority $i$3. If no augmenting path is found, even and internal vertices in the search structure never have priority greater than $i$4. If an $i$5-augmenting path existed, its structure would violate these invariants. Hence termination without finding such a path certifies optimality of the $i$6-score (Turner, 2015).

A common misconception is that lexicographic optimization of matched high-priority vertices should force a sacrifice in total matching size. The paper distinguishes the conceptual tension from the final outcome. Intermediate steps may indeed reconfigure the matching in ways that appear to sacrifice lower-priority matches, but after all stages are complete, the resulting maximum priority matching is also a maximum size matching. The algorithm therefore refines maximum matching rather than replacing it with a weaker objective (Turner, 2015).

5. Complexity and algorithmic position

Each priority-aware augmenting-path search can be implemented in $i$7 time using data structures developed by Gabow and Tarjan for blossom handling and disjoint-set operations. Since the outer loop considers up to $i$8 priorities, the overall running time is

$i$9

This is the complexity claimed in the abstract and developed in the full analysis (Turner, 2015).

The resulting complexity is higher than the best known bounds for ordinary maximum matching. For general graphs, ordinary maximum matching can be solved in $c_1$0 time by the Micali–Vazirani algorithm, and in bipartite graphs maximum matching can be solved in $c_1$1 time by Hopcroft–Karp. The priority-ranking requirement therefore increases worst-case complexity in this construction from $c_1$2 to $c_1$3. The paper notes the possibility of adapting faster maximum-matching techniques such as Micali–Vazirani to the priority setting, but leaves this as an open direction (Turner, 2015).

From a methodological standpoint, the algorithm preserves the classical structure of augmenting-path matching algorithms. The novelty is not a separate optimization paradigm, but a modified notion of admissible augmentation combined with blossom logic that respects lexicographic priority constraints.

6. Generalizations, applications, and significance

The paper briefly points to weighted generalizations, including maximizing edge-weight subject to a minimum priority score, maximizing priority score subject to a minimum total weight, or combining priorities with weights on matched vertices. These are framed as multi-criterion extensions in which priority ranking interacts with numerical optimization criteria (Turner, 2015).

An explicit application given in the paper is a scheduling problem for crossbar switches in internet routers. There, different flows or packets may belong to different priority classes, and a matching represents a feasible switching schedule. Maximum priority matching arises as a subproblem in an approximation algorithm for an NP-complete scheduling problem for such switches, where high-priority traffic should be served as much as possible before lower-priority traffic (Turner, 2015).

More broadly, the formulation is relevant whenever resources are matched to tasks or users with an exogenous priority ordering. The paper’s discussion emphasizes that the framework gives an exact graph-theoretic way to implement policies of the form: maximize service to the most important class first, then optimize the next class subject to that, and continue downward. In this sense, maximum priority matching is a canonical example of lexicographic matching under vertex priorities rather than a mere variant of weighted matching (Turner, 2015).

Its significance lies in showing that this lexicographic objective remains algorithmically tractable in general graphs. By extending Edmonds’ augmenting-path and blossom framework, the paper establishes that strict priority ranking over vertices can be enforced exactly, with a clear theorem characterizing when further improvement is possible and with a final output that is simultaneously priority-optimal and cardinality-optimal.