Enabling Scalability: Graph Hierarchies and Fault Tolerance

In this dissertation, we explore approaches to two techniques for building scalable algorithms. First, we look at different graph problems. We show how to exploit the input graph\u27s inherent hierarchy for scalable graph algorithms. The second technique takes a step back from concrete algorithmic problems. Here, we consider the case of node failures in large distributed systems and present techniques to quickly recover from these. In the first part of the dissertation, we investigate how hierarchies in graphs can be used to scale algorithms to large inputs. We develop algorithms for three graph problems based on two approaches to build hierarchies. The first approach reduces instance sizes for NP-hard problems by applying so-called reduction rules. These rules can be applied in polynomial time. They either find parts of the input that can be solved in polynomial time, or they identify structures that can be contracted (reduced) into smaller structures without loss of information for the specific problem. After solving the reduced instance using an exponential-time algorithm, these previously contracted structures can be uncontracted to obtain an exact solution for the original input. In addition to a simple preprocessing procedure, reduction rules can also be used in branch-and-reduce algorithms where they are successively applied after each branching step to build a hierarchy of problem kernels of increasing computational hardness. We develop reduction-based algorithms for the classical NP-hard problems Maximum Independent Set and Maximum Cut. The second approach is used for route planning in road networks where we build a hierarchy of road segments based on their importance for long distance shortest paths. By only considering important road segments when we are far away from the source and destination, we can substantially speed up shortest path queries. In the second part of this dissertation, we take a step back from concrete graph problems and look at more general problems in high performance computing (HPC). Here, due to the ever increasing size and complexity of HPC clusters, we expect hardware and software failures to become more common in massively parallel computations. We present two techniques for applications to recover from failures and resume computation. Both techniques are based on in-memory storage of redundant information and a data distribution that enables fast recovery. The first technique can be used for general purpose distributed processing frameworks: We identify data that is redundantly available on multiple machines and only introduce additional work for the remaining data that is only available on one machine. The second technique is a checkpointing library engineered for fast recovery using a data distribution method that achieves balanced communication loads. Both our techniques have in common that they work in settings where computation after a failure is continued with less machines than before. This is in contrast to many previous approaches that---in particular for checkpointing---focus on systems that keep spare resources available to replace failed machines. Overall, we present different techniques that enable scalable algorithms. While some of these techniques are specific to graph problems, we also present tools for fault tolerant algorithms and applications in a distributed setting. To show that those can be helpful in many different domains, we evaluate them for graph problems and other applications like phylogenetic tree inference

Algorithms for Graph Connectivity and Cut Problems - Connectivity Augmentation, All-Pairs Minimum Cut, and Cut-Based Clustering

We address a collection of related connectivity and cut problems in simple graphs that reach from the augmentation of planar graphs to be k-regular and c-connected to new data structures representing minimum separating cuts and algorithms that smoothly maintain Gomory-Hu trees in evolving graphs, and finally to an analysis of the cut-based clustering approach of Flake et al. and its adaption to dynamic scenarios

Approximation algorithms for network design and cut problems in bounded-treewidth

This thesis explores two optimization problems, the group Steiner tree and firefighter problems, which are known to be NP-hard even on trees. We study the approximability of these problems on trees and bounded-treewidth graphs. In the group Steiner tree, the input is a graph and sets of vertices called groups; the goal is to choose one representative from each group and connect all the representatives with minimum cost. We show an O(log^2 n)-approximation algorithm for bounded-treewidth graphs, matching the known lower bound for trees, and improving the best possible result using previous techniques. We also show improved approximation results for group Steiner forest, directed Steiner forest, and a fault-tolerant version of group Steiner tree. In the firefighter problem, we are given a graph and a vertex which is burning. At each time step, we can protect one vertex that is not burning; fire then spreads to all unprotected neighbors of burning vertices. The goal is to maximize the number of vertices that the fire does not reach. On trees, a classic (1-1/e)-approximation algorithm is known via LP rounding. We prove that the integrality gap of the LP matches this approximation, and show significant evidence that additional constraints may improve its integrality gap. On bounded-treewidth graphs, we show that it is NP-hard to find a subpolynomial approximation even on graphs of treewidth 5. We complement this result with an O(1)-approximation on outerplanar graphs.Diese Arbeit untersucht zwei Optimierungsprobleme, von welchen wir wissen, dass sie selbst in Bäumen NP-schwer sind. Wir analysieren Approximationen für diese Probleme in Bäumen und Graphen mit begrenzter Baumweite. Im Gruppensteinerbaumproblem, sind ein Graph und Mengen von Knoten (Gruppen) gegeben; das Ziel ist es, einen Knoten von jeder Gruppe mit minimalen Kosten zu verbinden. Wir beschreiben einen O(log^2 n)-Approximationsalgorithmus für Graphen mit beschränkter Baumweite, dies entspricht der zuvor bekannten unteren Schranke für Bäume und ist zudem eine Verbesserung über die bestmöglichen Resultate die auf anderen Techniken beruhen. Darüber hinaus zeigen wir verbesserte Approximationsresultate für andere Gruppensteinerprobleme. Im Feuerwehrproblem sind ein Graph zusammen mit einem brennenden Knoten gegeben. In jedem Zeitschritt können wir einen Knoten der noch nicht brennt auswählen und diesen vor dem Feuer beschützen. Das Feuer breitet sich anschließend zu allen Nachbarn aus. Das Ziel ist es die Anzahl der Knoten die vom Feuer unberührt bleiben zu maximieren. In Bäumen existiert ein lang bekannter (1-1/e)-Approximationsalgorithmus der auf LP Rundung basiert. Wir zeigen, dass die Ganzzahligkeitslücke des LP tatsächlich dieser Approximation entspricht, und dass weitere Einschränkungen die Ganzzahligkeitslücke möglicherweise verbessern könnten. Für Graphen mit beschränkter Baumweite zeigen wir, dass es NP-schwer ist, eine sub-polynomielle Approximation zu finden