net.automatalib.util.graphs.ShortestPaths Maven / Gradle / Ivy
Show all versions of automata-util Show documentation
/* Copyright (C) 2013-2019 TU Dortmund
* This file is part of AutomataLib, http://www.automatalib.net/.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.automatalib.util.graphs;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.Objects;
import java.util.function.Predicate;
import javax.annotation.Nullable;
import javax.annotation.ParametersAreNonnullByDefault;
import net.automatalib.graphs.IndefiniteGraph;
/**
* Unweighted shortest path search in graphs.
*
* This class offers an iterator-style approach to shortest path search: the methods in this class generally return
* either an {@link Iterator} or an {@link Iterable} wrapped around an iterator which allows for enumerating all
* shortest paths to the given set of target nodes. The iterators implement this lazily, i.e., a call to the {@link
* Iterator#next() next()} method of an iterator will continue the shortest path search on an as-needed basis.
*
* @author Malte Isberner
*/
@ParametersAreNonnullByDefault
public final class ShortestPaths {
private ShortestPaths() {
throw new AssertionError("Constructor should not be invoked");
}
public static Iterable> shortestPaths(IndefiniteGraph graph,
@Nullable N start,
int limit,
N target) {
return shortestPaths(graph, start, limit, (Predicate) n -> Objects.equals(n, target));
}
public static Iterable> shortestPaths(IndefiniteGraph graph,
@Nullable N start,
int limit,
Predicate targetPred) {
return shortestPaths(graph, Collections.singleton(start), limit, targetPred);
}
public static Iterable> shortestPaths(final IndefiniteGraph graph,
final Collection start,
final int limit,
final Predicate targetPred) {
Objects.requireNonNull(graph);
Objects.requireNonNull(start);
Objects.requireNonNull(targetPred);
return () -> shortestPathsIterator(graph, start, limit, targetPred);
}
public static Iterable> shortestPaths(IndefiniteGraph graph,
@Nullable N start,
int limit,
Collection targets) {
return shortestPaths(graph, start, limit, (Predicate) targets::contains);
}
public static Iterable> shortestPaths(IndefiniteGraph graph,
Collection start,
int limit,
@Nullable N target) {
return shortestPaths(graph, start, limit, (Predicate) n -> Objects.equals(n, target));
}
public static Iterable> shortestPaths(IndefiniteGraph graph,
Collection start,
int limit,
Collection targets) {
return shortestPaths(graph, start, limit, (Predicate) targets::contains);
}
public static Path shortestPath(IndefiniteGraph graph,
@Nullable N start,
int limit,
Collection targets) {
return shortestPath(graph, start, limit, (Predicate) targets::contains);
}
public static Path shortestPath(IndefiniteGraph graph,
@Nullable N start,
int limit,
Predicate targetPred) {
return shortestPath(graph, Collections.singleton(start), limit, targetPred);
}
public static Path shortestPath(IndefiniteGraph graph,
Collection start,
int limit,
Predicate targetPred) {
Iterator> spIt = shortestPathsIterator(graph, start, limit, targetPred);
return spIt.hasNext() ? spIt.next() : null;
}
public static Path shortestPath(IndefiniteGraph graph,
@Nullable N start,
int limit,
@Nullable N target) {
return shortestPath(graph, start, limit, (Predicate) n -> Objects.equals(n, target));
}
public static Path shortestPath(IndefiniteGraph graph,
Collection start,
int limit,
Collection targets) {
return shortestPath(graph, start, limit, (Predicate) targets::contains);
}
public static Path shortestPath(IndefiniteGraph graph,
Collection start,
int limit,
@Nullable N target) {
return shortestPath(graph, start, limit, (Predicate) n -> Objects.equals(n, target));
}
public static Iterator> shortestPathsIterator(IndefiniteGraph graph,
Collection start,
int limit,
Predicate targetPred) {
return new FindShortestPathsIterator<>(graph, start, limit, targetPred);
}
}