We present an algorithm that finds a maximum cardinality f-matching of a simple graph in time O(n(2/3)m). Here, f: V -> N is a given function and an f-matching is a subgraph wherein each vertex v is an element of V has degree <= f(v). This result generalizes a string of algorithms that concentrate on simple bipartite graphs. The bipartite case is based on the notion of level graph, introduced by Dinic for network flow. In general graphs this notion breaks down: Vertices no longer have unique levels, and there are too many levels to analyze the corresponding level graph like bipartite graphs (Theta(n(2)) vs. n). We use "natural" levels to prove properties of shortest augmenting trails (e.g., formulas for trail length). We use "shortened" levels to derive the algorithm's time bound. The algorithm, unmodified, is also efficient on multigraphs, achieving time O(min{root f(V),n} m) for f(V) = & sum;(v)f(v). The special case f equivalent to 1 shows the algorithm duplicates the classic time bound for maximum cardinality matching, O(root nm).

We present an algorithm that finds a maximum cardinality \(f\) -matching of a simple graph in time \(O(n^{2/3}m)\) . Here \(f:V\to\mathbb{N}\) is a given function and an \(f\) -matching is a subgraph wherein each vertex \(v\in V\) has degree \(\leq f(v)\) . This result generalizes a string of algorithms that concentrate on simple bipartite graphs. The bipartite case is based on the notion of level graph, introduced by Dinic for network flow. In general graphs this notion breaks down: Vertices no longer have unique levels, and there are too many levels to analyze the corresponding level graph like bipartite graphs ( \(\Theta(n^{2})\) vs. \(n\) ). We use “natural” levels to prove properties of shortest augmenting trails (e.g., formulas for trail length). We use “shortened” levels to derive the algorithm's time bound. The algorithm, unmodified, is also efficient on multigraphs, achieving time \(O(\min\{\sqrt{f(V)},n\} m)\) for \(f(V)=\sum_{v}f(v)\) . The special case \(f\equiv 1\) shows the algorithm duplicates the classic time bound for maximum cardinality matching, \(O(\sqrt{n} m)\) .

Blocking flows were introduced by Dinic (Soviet Math Doklady 11: 1277–1280, 1970) to speed up the computation of maximum network flows. They have been used in algorithms for problems such as maximum cardinality matching of bipartite graphs Hopcroft and Karp (SIAM J Comput 2(4), 225–231, 1973) and general graphs Micali and Vazirani (in: Proceedings of the 21st Annual Symposium on Foundations of Computer Science, 17–27, 1980), maximum weight matching of general graphs Gabow and Tarjan (J ACM 38(4), 815–853, 1991), and many others. The blocking algorithm of Gabow and Tarjan (1991) for matching is based on depth-first search. We extend the depth-first search approach to find f-factors of general multigraphs. Here f is an arbitrary integral-valued function on vertices, an f-matching is a subgraph where every vertex x has degree ≤ f(x) , an f-factor has equality in every degree bound. A set of blocking trails for an f-matching M is a maximal collection 𝒜 of edge-disjoint augmenting trails such that M⊕ _A∈𝒜 A is a valid f-matching. Blocking trails are needed in efficient algorithms for maximum cardinality f-matching Huang and Pettie (Algorithmica 84(7): 1952–1992, 2022), maximum weight f-factors/matchings by scaling Duan et al. (In: Proceedings of the 47th International Colloquium on Automata, Languages, and Programming (ICALP 2020), Vol. 168 of LIPIcs, 41:1-41:17, 2020; Gabow (A weight-scaling algorithm for f-factors of multigraphs. arXiv:2010.01102 , 2020), and approximate maximum weight f-factors and f-edge covers Huang and Pettie (2022). Since these algorithms find many sets of blocking trails, the time to find blocking trails is a dominant factor in the running time. Our blocking trail algorithm runs in linear time O(m). In independent work and using a different approach, Huang and Pettie (2022) present a blocking trails algorithm using time O(mα (m,n)) . As examples of the time bounds for the above applications, an approximate maximum weight f-factor is found in time O(m α (m,n)) using Huang and Pettie (2022), and our algorithm eliminates the factor α (m,n) . Similarly a maximum weight f-factor is found in time O(√(ΦlogΦ) m α (m,n) log (Φ W)) using Huang and Pettie (2022) , ( Φ =∑ _v∈ V f(v) , W the maximum edge weight) and our algorithm eliminates the α (m,n) factor, making the time within a factor √(logΦ) of the bound for bipartite multigraphs. The technical difficulty for this work stems from the fact that a fixed vertex can occur many times in a given search. This does not occur in ordinary matching or in algorithms for maximum cardinality or maximum weight f-matching. These multiple occurrences can create a new variant of blossom, the “skew blossom”. Also they can make blossoms become “incomplete”, i.e., partially processed yet still relevant in future searches.

The challenge for graph matching algorithms is to extend known time bounds for bipartite graphs to general graphs. We discuss combinatorial algorithms for finding a maximum weight f-factor on an arbitrary multigraph, for given integral weights of magnitude at most W. (An f-factor is a subgraph whose degree function is the given function f:V→ℕ .) For simple bipartite graphs the best-known time bound for combinatorial algorithms is O(n^2/3 m log nW) [Gabow and Tarjan, SIAM J Comput 18(5):1013–1036, 1989; n and m are respectively the number of vertices and edges.] A recent algorithm of Duan et al. [in: Proc. of the 47th International Colloquium on Automata, Languages, and Programming (ICALP 2020), 2020] for f-factors of simple general graphs comes within logarithmic factors of this bound, O (n^2/3 m log W) . The best-known bound for bipartite multigraphs is O(√(Φ) m logΦ W) ( Φ≤ m is the size of the f-factor, Φ =∑ _v∈ Vf(v)/2 ). This bound is more general than the restriction to simple graphs, and is even superior on “small” simple graphs, i.e., Φ =o(n^4/3) . We present an algorithm that comes within a √(logΦ) factor of this bound, i.e., O(√(ΦlogΦ) m logΦ W) . The algorithm is a direct generalization of the algorithm of Gabow and Tarjan [J ACM 38(4):815–853, 1991] for the special case of ordinary matching ( f≡ 1 ). We present that algorithm first. Our analysis is a simplified and more concrete version of Gabow and Tarjan [J ACM 38(4):815–853, 1991] and has independent interest. Furthermore the algorithm and analysis are both incorporated, without modification, into the f-factor algorithm. To extend these ideas to f-factors, the first step is “expanding” edges (i.e., replacing an edge by a length 3 alternating path). Duan et al. [in: Proc. of the 47th International Colloquium on Automata, Languages, and Programming (ICALP 2020), 2020] uses a one-time expansion of the entire graph. In contrast, our algorithm keeps the graph small by only expanding selected edges (edges incident to blossoms, in “I(B) sets”). Expanded edges get “compressed” back to their source when no longer needed. Expansion necessitates using an alternate graph model for blossoms (we call them “e-blossoms”). Compression requires coordinating e-blossoms with standard blossoms.

Let $G=(V,E)$ be a weighted graph or multigraph, with $f$ or $b$ a function assigning a nonnegative integer to each vertex. An $f$-factor is a subgraph whose degree function is $f$; a perfect $b$-matching is a $b$-factor in the graph formed from $G$ by adding an unlimited number of copies of each edge. This two-part paper culminates in an efficient algebraic algorithm to find a maximum $f$-factor, i.e., $f$-factor with maximum weight. Along the way it presents simpler special cases of interest. Part II presents the maximum $f$-factor algorithm and the special case of shortest paths in conservative undirected graphs (negative edges allowed). Part I presents these results: An algebraic algorithm for maximum $b$-matching, i.e., maximum weight $b$-matching. It is almost identical to its special case $b\equiv 1$, ordinary weighted matching. The time is $O(Wb(V)^{\omega})$ for $W$ the maximum magnitude of an edge weight, $b(V)=\sum_{v\in V} b(v)$, and $\omega<2.373$ the exponent of matrix multiplication. An algebraic algorithm to find an $f$-factor. The time is $O(f(V)^{\omega})$ for $f(V)=\sum_{v\in V} f(v)$. The specialization of the $f$-factor algorithm to bipartite graphs and its extension to maximum/minimum bipartite $f$-factors. This improves the known complexity bounds for vertex capacitated max-flow and min-cost max-flow on a subclass of graphs. Each algorithm is randomized and has two versions achieving the above time bound: For worst-case time the algorithm is correct with high probability. For expected time the algorithm is Las Vegas.

For an undirected graph or multigraph $G=(V,E)$ and a function $f:V\to \mathbb{Z_+}$, an $f$-factor is a subgraph whose degree function is $f$. For integral edge weights of maximum magnitude $W$ our algorithm finds a maximum weight $f$-factor in time $\tilde{O}(Wf(V)^{\omega})$, where $f(V)=\sum_{v\in V} f(v)$ and $\omega$ is the exponent of matrix multiplication. The algorithm is randomized and has two versions. For worst-case time the algorithm is correct with high probability. For expected time the algorithm is Las Vegas. The algorithm is based on a detailed analysis of the structure of the optimum blossoms. A special case gives a representation for single-source shortest-paths in conservative undirected graphs, generalizing the standard shortest-path tree to a “tree of cycles”. The representation can be constructed by a randomized algorithm with the same time bound as above, or deterministically by an algorithm for maximum weight matching, achieving time $O(n(m + n \log n))$ or $O(\sqrt{n }\ m \log (nW))$.

This article shows the weighted matching problem on general graphs can be solved in time O(n(m + n log n)) for n and m the number of vertices and edges, respectively. This was previously known only for bipartite graphs. The crux is a data structure for blossom creation. It uses a dynamic nearest-common-ancestor algorithm to simplify blossom steps, so they involve only back edges rather than arbitrary nontree edges. The rest of the article presents direct extensions of Edmonds’ blossom algorithm to weighted b-matching and f-factors. Again, the time bound is the one previously known for bipartite graphs: for b-matching the time is O(min {b(V),n log n}(m + n log n)), and for f-factors the time is O(min { f(V), m log n}(m + n log n)), where b(V) and f(V) both denote the sum of all degree constraints. Several immediate applications of the f-factor algorithm are given: The generalized shortest path structure of Reference [19], i.e., the analog of the shortest-paths tree for conservative undirected graphs, is shown to be a version of the blossom structure for f-factors. This structure is found in time O(|N|(m+n log n)) for N, the set of negative edges (0 < |N| < n). A shortest T-join is found in time O(n(m + n log n)) or O(|T|(m + n log n)) when all costs are nonnegative. These bounds are all slight improvements of previously known ones, and are simply achieved by proper initialization of the f-factor algorithm.

Consider a forest that evolves via link operations that make the root of one tree the child of a node in another tree. Intermixed with link operations are nca operations, which return the nearest common ancestor of two given nodes when such exists. This article shows that a sequence of m such nca and link operations on a forest of n nodes can be processed online in time O ( m α ( m , n )+ n ). This was previously known only for a restricted type of link operation. The special case where a link only extends a tree by adding a new leaf occurs in Edmonds’ algorithm for finding a maximum weight matching on a general graph. Incorporating our algorithm into the implementation of Edmonds’ algorithm in [9] achieves time O ( n ( m + n log n )) for weighted matching, an arguably optimum asymptotic bound ( n and m are the number of vertices and edges, respectively). Our data structure also provides a simple alternative implementation of the incremental-tree set merging algorithm of Gabow and Tarjan [11].

Several papers have achieved time $O(\sqrt n m)$ for cardinality matching, starting from first principles. This results in a long derivation. We simplify the task by employing well-known concepts for maximum weight matching. We use Edmonds' algorithm to derive the structure of shortest augmenting paths. We extend this to a complete algorithm for maximum cardinality matching in time $O(\sqrt n m)$.

Various instances of the minimal-set poset (minset-poset for short) have been proposed in the literature, e.g., the representation of Picard and Queyranne for all st -minimum cuts of a flow network. We begin with an explanation of why this poset structure is common. We show any family of sets F that can be defined by a “labelling algorithm” (e.g., the Ford-Fulkerson labelling algorithm for maximum network flow) has an algorithm that constructs the minset poset for F . We implement this algorithm to efficiently find the nodes of the poset when F is the family of minimum edge cuts of an unweighted graph; we also give related algorithms to construct the entire poset for weighted graphs. The rest of the article discusses applications to edge- and vertex connectivity, both combinatorial and algorithmic, that we now describe. For digraphs, a natural interpretation of the minset poset represents all minimum edge cuts. In the special case of undirected graphs, the minset poset is proved to be a variant of the well-known cactus representation of all mincuts. We use the poset algorithms to construct the cactus representation for unweighted graphs in time O ( m +λ 2 n log (n/λ)) (λ is the edge connectivity) improving the previous bound O (λ n 2 ) for all but the densest graphs. We also construct the cactus representation for weighted graphs in time O ( nm log( n 2 / m )), the same bound as a previously known algorithm but in linear space O ( m ). The latter bound also holds for constructing the minset poset for any weighted digraph; the former bound also holds for constructing the nodes of that poset for any unweighted digraph. The poset is used in algorithms to increase the edge connectivity of a graph by adding the fewest edges possible. For directed and undirected graphs, weighted and unweighted, we achieve the time of the preceding two bounds, i.e., essentially the best-known bounds to compute the edge connectivity itself. Some constructions of minset posets for graph rigidity are also sketched. For vertex connectivity, the minset poset is proved to be a slight variant of the dominator tree. This leads to an algorithm to construct the dominator tree in time O ( m ) on a RAM. (The algorithm is included in the appendix, since other linear-time algorithms of similar simplicity have recently been presented.)

The algorithm of Micali and Vazirani \cite{MV} finds a maximum cardinality matching in time $O(\sqrt n m)$ if an efficient set-merging algorithm is used. The latter is provided by the incremental-tree set-merging algorithm of \cite{GabTar}. Details of this application to matching were omitted from \cite{GabTar} and are presented in this note.

We introduce the following elementary scheduling problem. We are given a collection of n jobs, where each job has an integer length as well as a set Ti of time intervals in which it can be feasibly scheduled. Given a parameter B, the processor can schedule up to B jobs at a timeslot t so long as it is "active" at t. The goal is to schedule all the jobs in the fewest number of active timeslots. The machine consumes a fixed amount of energy per active timeslot, regardless of the number of jobs scheduled in that slot (as long as the number of jobs is non-zero). In other words, subject to all units of each job being scheduled in its feasible region and at each slot at most B jobs being scheduled, we are interested in minimizing the total time during which the machine is active. We present a linear time algorithm for the case where jobs are unit length and each Ti is a single interval. For general Ti, we show that the problem is NP-complete even for B = 3. However when B = 2, we show that it can be efficiently solved. In addition, we consider a version of the problem where jobs have arbitrary lengths and can be preempted at any point in time. For general B, the problem can be solved by linear programming. For B = 2, the problem amounts to finding a triangle-free 2-matching on a special graph. We extend the algorithm of Babenko et. al. to handle our variant, and also to handle non-unit length jobs. This yields an O(sqrt(L)m) time algorithm to solve the preemptive scheduling problem for B = 2, where L is the sum of the job lengths. We also show that for B = 2 and unit length jobs, the optimal non-preemptive schedule has at most 4/3 times the active time of the optimal preemptive schedule; this bound extends to several versions of the problem when jobs have arbitrary length.

Let G=(V,E) be a graph with f:V\to Z_+ a function assigning degree bounds to vertices. We present the first efficient algebraic algorithm to find an f-factor. The time is \tilde{O}(f(V)^{\omega}). More generally for graphs with integral edge weights of maximum absolute value W we find a maximum weight f-factor in time \tilde{O}(Wf(V)^{\omega}). (The algorithms are randomized, correct with high probability and Las Vegas; the time bound is worst-case.) We also present three specializations of these algorithms: For maximum weight perfect f-matching the algorithm is considerably simpler (and almost identical to its special case of ordinary weighted matching). For the single-source shortest-path problem in undirected graphs with conservative edge weights, we present a generalization of the shortest-path tree, and we compute it in \tilde{O(Wn^{\omega}) time. For bipartite graphs, we improve the known complexity bounds for vertex capacitated max-flow and min-cost max-flow on a subclass of graphs.

We consider four weighted matching-type problems: the bipartite graph and general graph versions of matching and f -factors. The linear program duals for these problems are shown to be weights of certain subgraphs. Specifically the so-called y duals are the weights of certain maximum matchings or f -factors; z duals (used for general graphs) are the weights of certain 2-factors or 2f -factors. The y duals are canonical in a well-defined sense; z duals are canonical for matching and more generally for b-matchings (a special case of f -factors) but for f -factors their support can vary. As weights of combinatorial objects the duals are integral for given integral edge weights, and so they give new proofs that the linear programs for these problems are TDI.

Consider a directed or undirected graph with integral edge weights in [-W, W]. This paper introduces a general framework for solving problems on such graphs using matrix multiplication. The framework is based on the Baur-Strassen Theorem and Strojohann's determinant algorithm. For directed and undirected graphs without negative cycles we obtain simple Õ(Wnω) running time algorithms for finding a shortest cycle, computing the diameter or radius, and detecting a negative weight cycle. For each of these problems we unify and extend the class of graphs for which Õ(Wnω) time algorithms are known. In particular no such algorithms were known for any of these problems in undirected graphs with (potentially) negative weights. We also present an Õ(Wnω) time algorithm for minimum weight perfect matching. This resolves an open problem posed by Sankowski in 2006, who presented such an algorithm for bipartite graphs. Our algorithm uses a novel combinatorial interpretation of the linear program dual for minimum perfect matching. We believe this framework will find applications for finding larger spectra of related problems. As an example we give a simple Õ(Wnω) time algorithm to find all the vertices that lie on cycles of length at most t, for given t. This improves an Õ(Wnω) time algorithm of Yuster.

The linear program dual variables for weighted matching and its generalization to f-factors are shown to be the weights of certain subgraphs: y duals are the weights of certain maximum matchings or f-factors; z duals are the weights of certain 2-factors or 2f-factors. Similar interpretations have been given for the bipartite case of these problems, where only y duals occur, but our variant is included here for completeness. In all cases the y duals are canonical in a well-defined sense; z duals are canonical for matching and more generally for b-matchings (a special case of f-factors) but for f-factors their support can vary. As weights of combinatoric objects the duals are integral for given integral edge weights, and so they give new proofs that the linear programs for these problems are TDI.

We study the following pre-emptive scheduling problem. We are given a collection of n jobs, each job Ji has an integer length li and a set Ti of time intervals with integer boundaries in which it can be feasibly scheduled.(When Ti is one interval, this is equivalent to having a release time and deadline.) It is assumed that the sum of the lengths of intervals in Ti is at least li. For ease of notation, we may sometimes refer to job Ji as job i. Additionally, time is slotted and for a given parallelism parameter P, the system (or machine) can schedule up to P jobs at a time slot. One can think of P as the number of processors. If the machine satisfies any jobs at time slot t, we say that the machine is “active at time t”. The goal is to pre-emptively schedule all jobs, ie satisfy them completely within their feasible regions, while minimizing the number of slots during which the machine is active. The machine consumes a fixed amount of energy per active slot. In other words, subject to each job Ji being scheduled within its feasible region Ti, and subject to at most P jobs being scheduled at any time, we would like to minimize the total time spent satisfying the jobs. Note that there may be instances when there is no feasible schedule for all the jobs (however this case is easy to check).Motivation: Power management strategies have been widely studied in the scheduling literature. Many of the models are motivated by the energy consumption of the processor. Consider, alternatively, the energy consumed by the operation of large storage systems. Data is stored in memory which may turned on and off, and each task or job needs to access a subset of data items to run. At each …

A graph is connected if there is a path between any two of its vertices and k-connected if there are at least k disjoint paths between any two vertices. A graph is k-edge-connected if none of the k paths share any edges and k-vertex-connected (or k-connected) if they do not share any intermediate vertices. We examine some problems related to k-connectivity and an application. We have looked at the k-edge-connected spanning subgraph problem: given a k-edge-connected graph, find the smallest subgraph that includes all vertices and is still k-edge-connected. We improved two algorithms for approximating solutions to this problem. The first algorithm transforms the problem into an integer linear program, relaxes it into a real-valued linear program and solves it, then obtains an approximate solution to the original problem by rounding non-integer values. We have improved the approximation ratio by giving a better scheme for rounding the edges and bounding the number of fractional edges. The second algorithm finds a subgraph where every vertex has a minimum degree, then augments the subgraph by adding edges until it is k-edge-connected. We improve this algorithm by bounding the number of edges that could be added in the augmentation step. We have also applied the idea of k-connectivity to protein-protein interaction (PPI) networks, biological graphs where vertices represent proteins and edges represent experimentally determined physical interactions. Because few PPI networks are even 1-connected, we have looked for highly connected subgraphs of these graphs. We developed algorithms to find the most highly connected subgraphs of a graph. We applied our algorithms to a large network of yeast protein interactions and found that the most highly connected subgraph was a 16-connected subgraph of membrane proteins that had never before been identified as a module and is of interest to biologists. We also looked at graphs of proteins known to be co-complexed and found that a significant number contained 3-connected subgraphs, one of the features that most differentiated complexes from random graphs.

The smallest k-ECSS problem is, given a graph along with an integer k , find a spanning subgraph that is k -edge connected and contains the fewest possible number of edges. We examine a natural approximation algorithm based on rounding an LP solution. A tight bound on the approximation ratio is 1 + 3/ k for undirected graphs with k > 1 odd, 1 + 2/ k for undirected graphs with k even, and 1 + 2/ k for directed graphs with k arbitrary. Using iterated rounding improves the first upper bound to 1 + 2/ k . These results prove that the smallest k -ECSS problem gets easier to approximate as k tends to infinity. They also show the integrality gap of the natural linear program is at most 1 + 2/ k , for both directed and undirected graphs.