Greedy color PR

jgrapht-core/src/main/java/org/jgrapht/GraphTests.java

@@ -22,6 +22,7 @@
 import org.jgrapht.alg.connectivity.KosarajuStrongConnectivityInspector;
 import org.jgrapht.alg.cycle.ChordalityInspector;
 import org.jgrapht.alg.cycle.HierholzerEulerianCycle;
+import org.jgrapht.alg.intervalgraph.*;
 
 import java.util.*;
 import java.util.stream.Collectors;
@@ -495,6 +496,24 @@ public static <V, E> boolean isChordal(Graph<V, E> graph){
         Objects.requireNonNull(graph, GRAPH_CANNOT_BE_NULL);
         return new ChordalityInspector<>(graph).isChordal();
     }
+
+    /**
+     * Tests whether a graph is an interval graph. <a href="https://en.wikipedia.org/wiki/Interval_graph">
+     * Interval graphs</a> are a familiy of graphs, which can be represented as intersections of intervals.
+     * The vertices are intervals on the number line and two vertices are connected if and only if the intervals of
+     * these vertices intersect each other.
+     * 
+     * @param graph the input graph
+     * @param <V> the graph vertex type
+     * @param <E> the graph edge type
+     * @return true if the graph is an interval graph, false otherwise
+     * @see IntervalGraphRecognizer#isIntervalGraph()
+     * 
+     */
+    public static <V, E> boolean isIntervalGraph(Graph<V, E> graph) {
+        Objects.requireNonNull(graph, GRAPH_CANNOT_BE_NULL);
+        return new IntervalGraphRecognizer<>(graph).isIntervalGraph();
+    }
 
     /**
      * Tests whether an undirected graph meets Ore's condition to be Hamiltonian.

jgrapht-core/src/main/java/org/jgrapht/alg/color/DecompositionTreeColour.java

@@ -0,0 +1,115 @@
+package org.jgrapht.alg.color;
+
+import java.util.Collections;
+import org.jgrapht.Graph;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.jgrapht.alg.interfaces.VertexColoringAlgorithm;
+
+/**
+ * Colouring of decomposition trees (currently done for interval graphs). This
+ * algorithm iterates over lists of vertices and assigns the smallest colour to
+ * each of the vertices such that the no vertex in the same list has the same
+ * colour.
+ * 
+ * @author Suchanda Bhattacharyya (dia007)
+ *
+ * @param <V>
+ *            The type of graph vertex
+ * @param <E>
+ *            The type of graph edge
+ */
+
+public class DecompositionTreeColour<V, E> implements VertexColoringAlgorithm<V> {
+
+    /**
+     * The input graph
+     */
+    private Graph<Integer, E> graph;
+    /**
+     * The map of the vertices in the input graph to it's interval sets
+     */
+    private Map<Integer, Set<V>> decompositionMap;
+
+    /**
+     * 
+     * @param graph the input graph
+     * @param decompositionMap the input decomposition map
+     */
+    public DecompositionTreeColour(Graph<Integer, E> graph, Map<Integer, Set<V>> decompositionMap) {
+        this.graph = Objects.requireNonNull(graph, "Graph cannot be null");
+        this.decompositionMap = Objects.requireNonNull(decompositionMap, "there must be some decomposition present");
+    }
+
+    /**
+     * Getting the ordering for the vertices
+     * 
+     * @return the ordering of the vertices
+     */
+
+    protected Iterable<Integer> getVertexOrdering() {
+        return (Iterable<Integer>) graph.vertexSet();
+
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see org.jgrapht.alg.interfaces.VertexColoringAlgorithm#getColoring()
+     */
+    @Override
+    public Coloring<V> getColoring() {
+
+        Map<V, Integer> asssignedColors = new HashMap<>();
+        Set<Integer> used = new HashSet<>();
+        Set<V> free = new HashSet<>();
+
+        // self loops not allowed, repetitions of inner vertices not allowed
+
+        for (Integer vertex : getVertexOrdering()) {
+
+            // find the intervals corresponding to the vertex
+            // need to sort the vertices
+            List<V> intervalSet = decompositionMap.get(vertex).stream().sorted().collect(Collectors.toList());
+
+            for (V innerVertex : intervalSet) {
+                // first need to iterate over each innerVertex in the outerVertex to check that
+                // if there is any vertex with an already assigned colour
+                if (asssignedColors.containsKey(innerVertex)) {
+                    used.add(asssignedColors.get(innerVertex));
+
+                } else {
+                    // these are the vertices without any assigned colours
+                    free.add(innerVertex);
+
+                }
+            }
+
+            // here we assign colours to the free vertices
+
+            for (V freeVertex : free) {
+                int colourCandidate = 0;
+                while (used.contains(colourCandidate)) {
+                    colourCandidate++;
+                }
+
+                asssignedColors.put(freeVertex, colourCandidate);
+
+                used.add(colourCandidate);
+
+            }
+            free.clear();
+            used.clear();
+
+        }
+
+        int maxColourAssigned = Collections.max(asssignedColors.values());
+
+        return new ColoringImpl<>(asssignedColors, maxColourAssigned + 1);
+    }
+}

jgrapht-core/src/main/java/org/jgrapht/alg/decomposition/IntervalGraphNiceDecompositionBuilder.java

@@ -0,0 +1,207 @@
+package org.jgrapht.alg.decomposition;
+
+import java.util.*;
+import org.jgrapht.*;
+import org.jgrapht.alg.intervalgraph.IntervalGraphRecognizer;
+import org.jgrapht.intervalgraph.*;
+import org.jgrapht.intervalgraph.interval.*;
+
+/**
+ * Class for calculating the nice Tree Decomposition for interval graphs
+ *
+ * @param <T> the value type of the intervals of the interval graph
+ * @param <V> the type of the nodes of the input graph
+ *
+ * @author Ira Justus Fesefeldt (PhoenixIra)
+ * @since Mai 14, 2018
+ */
+public class IntervalGraphNiceDecompositionBuilder<T extends Comparable<T>, V> extends NiceDecompositionBuilder<V>
+{
+    // input to the algorithm, list of sorted intervals
+    private List<Interval<T>> startSort, endSort;
+    private Map<Interval<T>, V> intervalToVertexMap;
+    private Map<V, Interval<T>> vertexToIntervalMap;
+
+    // helper attributes
+    private Integer currentVertex = null;
+
+    /**
+     * Private constructor for the factory methods, which changes the inputs
+     * 
+     * @param sortedByStartPoint the intervals sorted after the starting points
+     * @param sortedByEndPoint the intervals sorted after the ending points
+     * @param intervalToVertexMap maps intervals to the vertices of the graph (may be the same)
+     */
+    private IntervalGraphNiceDecompositionBuilder(
+        List<Interval<T>> sortedByStartPoint, List<Interval<T>> sortedByEndPoint,
+        Map<Interval<T>, V> intervalToVertexMap, Map<V, Interval<T>> vertexToIntervalMap)
+    {
+        super();
+
+        this.startSort = sortedByStartPoint;
+        this.endSort = sortedByEndPoint;
+        this.intervalToVertexMap = intervalToVertexMap;
+        this.vertexToIntervalMap = vertexToIntervalMap;
+
+        computeNiceDecomposition();
+    }
+
+    /**
+     * Factory method for creating a nice tree decomposition for interval graphs. This factory
+     * method uses general graphs and the IntervalGraphRecognizer to generate a list of intervals
+     * sorted by starting and ending points. The complexity of this method depends on the sorting
+     * algorithm in IntervalGraphRecognizer (probably quasi linear in the number of intervals)
+     * 
+     * @param graph the graph which should transformed to an interval graph and then into a
+     *        corresponding nice tree decomposition
+     * @param <V> the vertex type of the graph
+     * @param <E> the edge type of the graph
+     * @return the algorithm for the computation of the nice tree decomposition, returns null if
+     *         graph was no interval graph
+     * @see IntervalGraphRecognizer
+     */
+    public static <V, E> IntervalGraphNiceDecompositionBuilder<Integer, V> create(Graph<V, E> graph)
+    {
+        IntervalGraphRecognizer<V, E> recog = new IntervalGraphRecognizer<>(graph);
+
+        HashMap<V, Interval<Integer>> vertexToIntegerMap =
+            new HashMap<>(recog.getVertexToIntervalMap().size());
+
+        Map<V,IntervalVertexInterface<V, Integer>> vertexToIntervalVertexMap = recog.getVertexToIntervalMap();
+        for (V key : vertexToIntervalVertexMap.keySet())
+            vertexToIntegerMap.put(key, vertexToIntervalVertexMap.get(key).getInterval());
+
+        if (recog.isIntervalGraph())
+            return new IntervalGraphNiceDecompositionBuilder<Integer, V>(
+                recog.getIntervalsSortedByStartingPoint(),
+                recog.getIntervalsSortedByEndingPoint(), recog.getIntervalToVertexMap(),
+                vertexToIntegerMap);
+        else
+            return null;
+    }
+
+    /**
+     * Factory method for creating a nice tree decomposition for interval graphs. This factory
+     * method extracts the intervals from the interval graph and uses them as an input for the
+     * computation. The complexity of this method depends on the sorting algorithm of ArrayList
+     * (probably O(|V| log(|V|))
+     * 
+     * @param intervalGraph the input for which a nice tree decomposition should be computed
+     * @param <V> the IntervalVertex Type of the interval graph
+     * @param <E> the edge type of the interval graph
+     * @param <VertexType> the vertex type of the graph
+     * @param <T> the value of the intervals
+     * @return the algorithm for the computation of the nice tree decomposition
+     * @see ArrayList#sort(Comparator)
+     */
+    public static <V extends IntervalVertexInterface<VertexType, T>, E, VertexType,
+        T extends Comparable<T>> IntervalGraphNiceDecompositionBuilder<T, V> create(
+            IntervalGraph<V, E, VertexType, T> intervalGraph)
+    {
+        Set<V> vertexSet = intervalGraph.vertexSet();
+        List<Interval<T>> intervals = new ArrayList<Interval<T>>(vertexSet.size());
+        Map<Interval<T>, V> intervalToVertexMap = new HashMap<>(vertexSet.size());
+        Map<V, Interval<T>> vertexToIntervalMap = new HashMap<>(vertexSet.size());
+        for (V iv : vertexSet) {
+            intervals.add(iv.getInterval());
+            intervalToVertexMap.put(iv.getInterval(), iv);
+            vertexToIntervalMap.put(iv, iv.getInterval());
+        }
+        ArrayList<Interval<T>> startSort = new ArrayList<>(intervals);
+        ArrayList<Interval<T>> endSort = new ArrayList<>(intervals);
+        startSort.sort(Interval.<T> getStartingComparator());
+        endSort.sort(Interval.<T> getEndingComparator());
+        return new IntervalGraphNiceDecompositionBuilder<T, V>(
+            startSort, endSort, intervalToVertexMap, vertexToIntervalMap);
+    }
+
+    /**
+     * Factory method for creating a nice tree decomposition for interval graphs. This factory
+     * method needs to lists of intervals, the first sorted after starting points, the second after
+     * ending points The complexity of this method is linear in the number of intervals
+     * 
+     * @param sortedByStartPoint a list of all intervals sorted by the starting point
+     * @param sortedByEndPoint a list of all intervals sorted by the ending point
+     * @param <T> the value of the intervals
+     * @return the algorithm for the computation of the nice tree decomposition
+     */
+    public static <T extends Comparable<T>> IntervalGraphNiceDecompositionBuilder<T, Interval<T>> create(
+        List<Interval<T>> sortedByStartPoint, List<Interval<T>> sortedByEndPoint)
+    {
+        HashMap<Interval<T>, Interval<T>> identity = new HashMap<>(sortedByStartPoint.size());
+        for (Interval<T> interval : sortedByStartPoint)
+            identity.put(interval, interval);
+        return new IntervalGraphNiceDecompositionBuilder<T, Interval<T>>(
+            new ArrayList<Interval<T>>(sortedByStartPoint),
+            new ArrayList<Interval<T>>(sortedByEndPoint), identity, identity);
+    }
+
+    /**
+     * Factory method for creating a nice tree decomposition for interval graphs. This factory
+     * method needs to lists of intervals, which then is sorted by ArrayList.sort(). The complexity
+     * of this method depends on the sorting Algorithm of ArrayList (probably O(|List| log(|List|))
+     * 
+     * @param intervals the (unsorted) list of all intervals
+     * @param <T> the values of the intervals
+     * @return the algorithm for the computation of the nice tree decomposition
+     * @see ArrayList#sort(Comparator)
+     */
+    public static <T extends Comparable<T>> IntervalGraphNiceDecompositionBuilder<T, Interval<T>> create(
+        List<Interval<T>> intervals)
+    {
+        ArrayList<Interval<T>> startSort = new ArrayList<>(intervals);
+        ArrayList<Interval<T>> endSort = new ArrayList<>(intervals);
+        startSort.sort(Interval.<T> getStartingComparator());
+        endSort.sort(Interval.<T> getEndingComparator());
+        return create(startSort, endSort);
+    }
+
+    /**
+     * Main method for computing the nice tree decomposition
+     */
+    private void computeNiceDecomposition()
+    {
+
+        // create all objects and set new root
+        currentVertex = getRoot();
+
+        int endIndex = 0;
+
+        // as long as intervals remain
+        for (Interval<T> current : startSort) {
+            // first forget until you need to introduce new nodes
+            while (endSort.get(endIndex).getEnd().compareTo(current.getStart()) < 0) {
+                V forgetElement = intervalToVertexMap.get(endSort.get(endIndex));
+                currentVertex = addForget(forgetElement, currentVertex);
+                endIndex++;
+            }            
+            V introduceElement = intervalToVertexMap.get(current);
+            currentVertex = addIntroduce(introduceElement, currentVertex);
+        }
+        // add the last forget nodes
+        while (endIndex < endSort.size()) {
+            V forgetElement = intervalToVertexMap.get(endSort.get(endIndex++));
+            currentVertex = addForget(forgetElement, currentVertex);
+        }
+    }
+
+    /**
+     * getter for interval to vertex Map
+     * 
+     * @return a map that maps intervals to vertices
+     */
+    public Map<Interval<T>, V> getIntervalToVertexMap()
+    {
+        return intervalToVertexMap;
+    }
+
+    /**
+     * getter for vertex to interval map
+     * 
+     * @return a map that maps vertices to intervals
+     */
+    public Map<V, Interval<T>> getVertexToIntervalMap()
+    {
+        return vertexToIntervalMap;
+    }
+}