Fast Computation of Small Cuts via Cycle Space Sampling

We describe a new sampling-based method to determine cuts in an undirected graph. For a graph (V, E), its cycle space is the family of all subsets of E that have even degree at each vertex. We prove that with high probability, sampling the cycle space identifies the cuts of a graph. This leads to simple new linear-time sequential algorithms for finding all cut edges and cut pairs (a set of 2 edges that form a cut) of a graph. In the model of distributed computing in a graph G=(V, E) with O(log V)-bit messages, our approach yields faster algorithms for several problems. The diameter of G is denoted by Diam, and the maximum degree by Delta. We obtain simple O(Diam)-time distributed algorithms to find all cut edges, 2-edge-connected components, and cut pairs, matching or improving upon previous time bounds. Under natural conditions these new algorithms are universally optimal --- i.e. a Omega(Diam)-time lower bound holds on every graph. We obtain a O(Diam+Delta/log V)-time distributed algorithm for finding cut vertices; this is faster than the best previous algorithm when Delta, Diam = O(sqrt(V)). A simple extension of our work yields the first distributed algorithm with sub-linear time for 3-edge-connected components. The basic distributed algorithms are Monte Carlo, but they can be made Las Vegas without increasing the asymptotic complexity. In the model of parallel computing on the EREW PRAM our approach yields a simple algorithm with optimal time complexity O(log V) for finding cut pairs and 3-edge-connected components.Comment: Previous version appeared in Proc. 35th ICALP, pages 145--160, 200

Tight Bounds For Distributed MST Verification

This paper establishes tight bounds for the Minimum-weight Spanning Tree (MST) verification problem in the distributed setting. Specifically, we provide an MST verification algorithm that achieves {\em simultaneously} $\tilde{O}(|E|)$ messages and $\tilde{O}(\sqrt{n} + D)$ time, where $|E|$ is the number of edges in the given graph $G$ and $D$ is $G$'s diameter. On the negative side, we show that any MST verification algorithm must send $\Omega(|E|)$ messages and incur $\tilde{\Omega}(\sqrt{n} + D)$ time in worst case. Our upper bound result appears to indicate that the verification of an MST may be easier than its construction, since for MST construction, both lower bounds of $\Omega(|E|)$ messages and $\Omega(\sqrt{n} + D)$ time hold, but at the moment there is no known distributed algorithm that constructs an MST and achieves {\em simultaneously} $\tilde{O}(|E|)$ messages and $\tilde{O}(\sqrt{n} + D)$ time. Specifically, the best known time-optimal algorithm (using \tO(\sqrt{n} + D) time) requires $O(|E|+n^{3/2})$ messages, and the best known message-optimal algorithm (using \tO(|E|) messages) requires $O(n)$ time. On the other hand, our lower bound results indicate that the verification of an MST is not significantly easier than its construction

Algorithms for All Single Deletions in a Minimum Apanning Tree, Simulataneously

Coordinated Science Laboratory was formerly known as Control Systems LaboratoryNational Science Foundation / NSF CCR-931569

Algorithms for graphs of small treewidth

Veel problemen uit de praktijk kunnen worden gemodelleerd als optimaliserings- of beslis-singsproblemen op grafen. Denk bijvoorbeeld aan het probleem waarbij een koerier een aantal pakketjes moet afleveren op verschillende adressen in het land. De manager van de koerier wil dat hij een zo kort mogelijke route aflegt die begint en eindigt bij het koeriers-bedrijf, en die alle adressen aandoet. Het probleem om zo n kortste route te vinden is het zogenaamde handelsreizigersprobleem. De invoer kan worden gemodelleerd als een graaf, waarbij elke knoop in de graaf een adres vertegenwoordigt en elke kant tussen twee knopen de weg tussen de corresponderende adressen. Elke kant heeft een gewicht dat aangeeft hoe lang de corresponderende weg is. Het probleem is dan om een cykel in de graaf te vinden die alle knopen bevat en waarvoor de som van de gewichten van alle kanten in de cykel minimaal is. Helaas is het zo dat de meeste problemen op grafen die praktische problemen modelleren lastig zijn in die zin, dat er waarschijnlijk geen effici¨ ente algoritmen zijn die deze problemen oplossen. Formeel gezegd zijn deze problemen NP-lastig. Het handelsreizigersprobleem is een voorbeeld hiervan. Een manier om hiermee om te gaan is om te kijken of er in het probleem uit de praktijk een structuur zit die maakt dat het probleem effici¨ enter is op te lossen. Het kan bijvoorbeeld zo zijn dat het gegeven probleem in het algemeen lastig is, maar dat de grafen die in de praktijk voorkomen een dusdanige structuur hebben dat er wel een effici¨ ent algoritme voor het probleem bestaat. Een voorbeeld van een prettige graafstructuur is de boomstructuur: het blijkt dat veel graafproblemen die in het algemeen lastig zijn, een effici¨ ent algoritme hebben wanneer de graaf een boom is. Helaas is de boomstructuur erg beperkt: er zijn maar weinig praktische problemen die kunnen worden gemodelleerd als problemen op bomen. In dit proefschrift kij-ken we daarom naar een generalisatie van deze structuur, en dat is de boomachtige structuur: we kijken naar grafen met boombreedte hooguit k of padbreedte hooguit k, waarbij k een positief geheel getal is. Intu¨itief gezien geeft de boombreedte van een graaf de mate aan waarin de graaf op een boom lijkt: hoe groter de gelijkenis, hoe kleiner de boombreedte. Met een graaf van boom-breedte k kan een boom worden geassocieerd waarbij elke knoop van de boom correspondeert met een deelgraaf van de graaf op een zodanige manier dat elke knoop en elke kant van de graaf in tenminste een knoop van de boom voorkomt, en voor elke knoop v in de graaf geldt dat de knopen in de boom die v bevatten een verbonden deelboom vormen. Zo n boom bestaande uit deelgrafen wordt een boomdecompositie van de graaf genoemd. De breedte van de boomdecompositie is het maximaal aantal knopen van de graaf dat in ´ e´ en 233?Samenvatting knoop van de boomdecompositie voorkomt, min ´ e´ en. De boombreedte van een graaf is de minimale breedte over alle boomdecomposities van de graaf (een boom heeft boombreedte ´ e´ en). Een paddecompositie van een graaf is een boomdecompositie die de vorm heeft van een pad. De padbreedte van een graaf is de minimale breedte over alle paddecomposities van de graaf. Dus de boombreedte van een graaf is altijd ten hoogste gelijk aan z n padbreedte. Voor veel problemen zoals het handelsreizigersprobleem is er een effici¨ ent algoritme op grafen met kleine boombreedte. Het blijkt dat er veel praktische graafproblemen zijn waar-voor de invoergraaf een kleine boombreedte heeft. Bij al deze problemen helpt dit gegeven bij het vinden van een effici¨ enter algoritme. Deze algoritmen maken meestal gebruik van een boomdecompositie van de graaf met kleine breedte. Daarom is het nodig om eerst zo n boomdecompositie van de graaf te vinden. Hiervoor zijn effici¨ ente algoritmen beschikbaar, zowel sequentieel als parallel. Helaas is het zo dat veel algoritmen op grafen met een kleine boombreedte alleen in theorie efficient zijn: de looptijd van de algoritmen is vaak exponentieel in de boombreedte van de graaf. Dit geldt bijvoorbeeld voor de algoritmen voor het vinden van een boom- of paddecompositie van breedte hooguit k van een graaf, waarbij k constant is. Het doel van dit proefschrift is om effici¨ ente sequenti¨ ele en parallelle algoritmen te ont-werpen voor problemen op grafen met een kleine boom- of padbreedte. Het doel is om algoritmen te ontwerpen die niet alleen theoretisch effici¨ ent zijn, maar die ook in praktische toepassingen effici¨ ent kunnen zijn. Het proefschrift is als volgt georganiseerd. Hoofdstuk 1 geeft een inleiding. In hoofd-stuk 2 worden formele definities van boom- en padbreedte gegeven, en wordt een aantal ei-genschappen en bekende resultaten over grafen met een kleine boom- en padbreedte gegeven. Verder worden definities gegeven die worden gebruikt in de rest van het proefschrift. In hoofdstuk 3 geven we een volledige karakterisatie van grafen met padbreedte twee. Deze karakterisatie wordt vervolgens gebruikt voor een effici¨ ent sequentieel algoritme dat beslist of een graaf padbreedte ten hoogste twee heeft en, als dat zo is, een paddecompositie van minimale breedte vindt. De karakterisatie wordt ook gebruikt in de algoritmen die zijn beschreven in hoofdstuk 4. Hoofdstuk 4 gaat over twee problemen welke hun oorsprong vinden in de moleculaire biologie. In beide problemen bestaat de invoer uit een aantal copie¨ en van een DNA string welke in fragmenten zijn opgedeeld. Voor elk paar van fragmenten is informatie beschikbaar over de overlap tussen die twee fragmenten: ´ of we weten dat de fragmenten zeker overlappen, ´ of we weten dat ze zeker niet overlappen, ´ of we weten niets. Met behulp van deze informatie moet de volledige overlap informatie tussen elk tweetal fragmenten worden berekend, dat wil zeggen dat voor elk tweetal fragmenten moet worden berekend of ze wel of niet overlappen. Dit probleem heet k-INTERVALIZING SANDWICH GRAPHS of k-ISG, waarbij k het aantal copie¨ en is dat is gefragmenteerd. In de tweede variant is ook nog bekend dat alle fragmenten gelijke lengte hebben. Deze variant heet k-UNIT-INTERVALIZING SANDWICH GRAPHS of k-UISG. De invoer van beide problemen kan worden gemodelleerd als een graaf. Het blijkt dat de volledige overlap informatie alleen kan worden berekend wanneer die graaf padbreedte ten hoogste k heeft, waarbij k weer het aantal copie¨ en is. In Hoofdstuk 4 geven we een 234?Samenvatting kwadratisch algoritme voor 3-ISG, en we bewijzen dat k-ISG NP-moeilijk is wanneer k 4. Verder geven we een lineair algoritme voor 3-UISG. Hoofstukken 5 9 gaan over een speciaal soort algoritmen, namelijk reductie algorit-men. Een reductie algoritme is een algoritme waarin een reeks reducties wordt uitgevoerd op de invoergraaf. Het gedrag van de reducties is beschreven in een verzameling van reductie regels, welke afhangen van het probleem waarvoor het algoritme is. Wanneer de reductie re-gels aan bepaalde voorwaarden voldoen kan het reductie algoritme lineaire tijd gebruiken (of logaritmische tijd in het geval van een parallel reductie algoritme). De reductie algoritmen zijn eenvoudig: de moeilijkheden van het probleem zitten verstopt in de verzameling reductie regels, en niet in het algoritme. Er zijn hele klassen van problemen op grafen met begrensde boombreedte waarvoor een verzameling van reductie regels kan worden geconstrueerd. Het voordeel van reductie algo-ritmen voor het oplossen van problemen op grafen met begrensde boombreedte is dat er geen boomdecompositie van de graaf nodig is: de algoritmen werken direct op de graaf. In hoofdstuk 5 geven we een overzicht van de bestaande theorie¨ en over reductie algorit-men. We combineren verschillende bestaande idee¨ en en presenteren ze als een geheel. Dit hoofdstuk is tevens een inleiding voor hoofdstukken 6 9. Reductie algoritmen hebben als nadeel dat ze alleen optimaliserings- en beslissingspro-blemen kunnen oplossen: bij een optimaliseringsprobleem wordt alleen de optimale waarde teruggegeven, maar niet een oplossing waarvoor de waarde optimaal is. Bij beslissingspro-blemen wordt alleen het antwoord ja of nee gegeven, maar als het antwoord ja is wordt geen oplossing gegeven. In hoofdstuk 6 breiden we de theorie van reductie algoritmen uit naar constructieve reductie algoritmen welke ook een (optimale) oplossing teruggeven, mits er een is. We laten zien dat voor veel problemen op grafen met begrensde boombreedte waar-voor reductie algoritmen kunnen worden toegepast, ook de constructieve reductie algoritmen kunnen worden toegepast. In hoofdstuk 7 passen we de theorie¨ en welke zijn gepresenteerd in hoofdstukken 5 en 6 toe op een aantal optimaliseringsproblemen. In hoofdstukken 8 en 9 gebruiken we de theorie¨ en uit hoofdstuk 6, aangevuld met nieuwe idee¨ en, om effici¨ ente, constructieve parallelle reductie algoritmen te verkrijgen voor de vol-gende twee aanverwante problemen: gegeven een graaf, bepaal of hij series-parallel is, en zo ja, vind dan een sp-boom van de graaf, gegeven een graaf, bepaal of hij boombreedte hooguit twee heeft, en zo ja, maak een boomdecompositie van breedte twee van de graaf. In hoofdstuk 10 vatten we de resultaten uit dit proefschrift nog eens samen, en geven we wat richtingen aan voor verder onderzoek. Appendix A bevat een opsomming van definities van alle graafproblemen welke worden gebruikt in het proefschrift. 235?Samenvatting 23

Efficient Algorithms and Data Structures for Massive Data Sets

For many algorithmic problems, traditional algorithms that optimise on the number of instructions executed prove expensive on I/Os. Novel and very different design techniques, when applied to these problems, can produce algorithms that are I/O efficient. This thesis adds to the growing chorus of such results. The computational models we use are the external memory model and the W-Stream model. On the external memory model, we obtain the following results. (1) An I/O efficient algorithm for computing minimum spanning trees of graphs that improves on the performance of the best known algorithm. (2) The first external memory version of soft heap, an approximate meldable priority queue. (3) Hard heap, the first meldable external memory priority queue that matches the amortised I/O performance of the known external memory priority queues, while allowing a meld operation at the same amortised cost. (4) I/O efficient exact, approximate and randomised algorithms for the minimum cut problem, which has not been explored before on the external memory model. (5) Some lower and upper bounds on I/Os for interval graphs. On the W-Stream model, we obtain the following results. (1) Algorithms for various tree problems and list ranking that match the performance of the best known algorithms and are easier to implement than them. (2) Pass efficient algorithms for sorting, and the maximal independent set problems, that improve on the best known algorithms. (3) Pass efficient algorithms for the graphs problems of finding vertex-colouring, approximate single source shortest paths, maximal matching, and approximate weighted vertex cover. (4) Lower bounds on passes for list ranking and maximal matching. We propose two variants of the W-Stream model, and design algorithms for the maximal independent set, vertex-colouring, and planar graph single source shortest paths problems on those models.Comment: PhD Thesis (144 pages

On the Design, Analysis, and Implementation of Algorithms for Selected Problems in Graphs and Networks

This thesis studies three problems in network optimization, viz., the minimum spanning tree verification (MSTV) problem, the undirected negative cost cycle detection (UNCCD) problem, and the negative cost girth (NCG) problem. These problems find applications in several domains including program verification, proof theory, real-time scheduling, social networking, and operations research.;The MSTV problem is defined as follows: Given an undirected graph G = (V,E) and a spanning tree T, is T a minimum spanning tree of G? We focus on the case where the number of distinct edge weights is bounded. Using a bucketed data structure to organize the edge weights, we present an efficient algorithm for the MSTV problem, which runs in O (| E| + |V| · K) time, where K is the number of distinct edge weights. When K is a fixed constant, this algorithm runs in linear time. We also profile our MSTV algorithm with the current fastest known MSTV implementation. Our results demonstrate the superiority of our algorithm when K ≤ 24.;The UNCCD problem is defined as follows: Given an undirected graph G = (V,E) with arbitrarily weighted edges, does G contain a negative cost cycle? We discuss two polynomial time algorithms for solving the UNCCD problem: the b-matching approach and the T-join approach. We obtain new results for the case where the edge costs are integers in the range {lcub}--K ·· K{rcub}, where K is a positive constant. We also provide the first extensive empirical study that profiles the discussed UNCCD algorithms for various graph types, sizes, and experiments.;The NCG problem is defined as follows: Given a directed graph G = (V,E) with arbitrarily weighted edges, find the length, or number of edges, of the negative cost cycle having the least number of edges. We discuss three strongly polynomial NCG algorithms. The first NCG algorithm is known as the matrix multiplication approach in the literature. We present two new NCG algorithms that are asymptotically and empirically superior to the matrix multiplication approach for sparse graphs. We also provide a parallel implementation of the matrix multiplication approach that runs in polylogarithmic parallel time using a polynomial number of processors. We include an implementation profile to demonstrate the efficiency of the parallel implementation as we increase the graph size and number of processors. We also present an NCG algorithm for planar graphs that is asymptotically faster than the fastest topology-oblivious algorithm when restricted to planar graphs

Fairly Allocating Goods in Parallel

We initiate the study of parallel algorithms for fairly allocating indivisible goods among agents with additive preferences. We give fast parallel algorithms for various fundamental problems, such as finding a Pareto Optimal and EF1 allocation under restricted additive valuations, finding an EF1 allocation for up to three agents, and finding an envy-free allocation with subsidies. On the flip side, we show that fast parallel algorithms are unlikely to exist (formally, $CC$-hard) for the problem of computing Round-Robin EF1 allocations

Tight Bounds for Distributed Minimum-Weight Spanning Tree Verification

International audienceThis paper introduces the notion of distributed verification without preprocessing. It focuses on the Minimum-weight Spanning Tree (MST) verification problem and establishes tight upper and lower bounds for the time and message complexities of this problem. Specifically, we provide an MST verification algorithm that achieves simultaneously O(m) messages and O(√ n+D) time, where m is the number of edges in the given graph G, n is the number of nodes, and D is G's diameter. On the other hand, we show that any MST verification algorithm must send Ω(m) messages and incur Ω(√ n + D) time in worst case. Our upper bound result appears to indicate that the verification of an MST may be easier than its construction, since for MST construction, both lower bounds of Ω(m) messages and Ω(√ n+D) time hold, but at the moment there is no known distributed algorithm that constructs an MST and achieves simultaneously O(m) messages and O(√ n + D) time. Specifically, the best known time-optimal algorithm (using O(√ n + D) time) requires O(m + n 3/2) messages, and the best known message-optimal algorithm (using O(m) messages) requires O(n) time. On the other hand, our lower bound results indicate that the verification of an MST is not significantly easier than its construction