private void ComponentsBFS(IVertexInterface root, Dictionary <IVertexInterface, int> vertexDictionary, int componentNumber) { // Variable Queue <IVertexInterface> vertexQueue = new Queue <IVertexInterface>(); List <IVertexInterface> neighboursVertexList; IVertexInterface dequeuedVertex; vertexQueue.Enqueue(root); vertexDictionary[root] = componentNumber; while (vertexQueue.Count != 0) { dequeuedVertex = vertexQueue.Dequeue(); neighboursVertexList = graph.Neighbours(dequeuedVertex); foreach (IVertexInterface vertex in neighboursVertexList) { if (vertexDictionary[vertex] == 0) { vertexDictionary[vertex] = componentNumber; vertexQueue.Enqueue(vertex); } } } }
/// <summary> /// Add a new vertex /// Deinitialize colored graph /// If the vertex exists in the graph throws GraphVertexAlreadyExistsException /// </summary> /// <param name="vertex">vertex</param> public void VertexAdd(IVertexInterface vertex) { // Vertex exists if (ExistsVertex(vertex) || ExistsUserName(vertex.GetUserName())) { throw new MyException.GraphException.GraphVertexAlreadyExistsException(); } VertexExtended vertexExtended = new VertexExtended(vertex.GetIdentifier()); vertexExtended.SetColor(vertex.GetColor()); vertexExtended.SetUserName(vertex.GetUserName()); SetCanDeIncreaseCountVertices(true); GetGraphProperty().IncrementCountVertices(); SetCanDeIncreaseCountVertices(false); AddVertexToAdjacencyList(vertexExtended); vertex = vertexExtended; // ColoredGraph coloredGraph.AddVertexInHashSets(vertex); if (coloredGraph.GetIsInitializedColoredGraph()) { coloredGraph.DeinitializationColoredGraph(); } // GraphProperty GetGraphProperty().VertexAdd(vertex); }
/// <summary> /// Change a vertex user name /// If the vertex doesn't exist throws GraphVertexDoesntExistException /// </summary> /// <param name="vertex">name</param> /// <param name="newUserName">user name</param> public void RenameVertexUserName(IVertexInterface vertex, string newUserName) { // Variable string oldUserName; VertexExtended vertexExtended = ConvertVertexToVertexExtended(vertex); if (ExistsUserName(newUserName)) { throw new MyException.GraphException.GraphVertexUserNameAlreadyExistsException(); } oldUserName = vertex.GetUserName(); mappingUserName.Remove(vertex.GetUserName()); vertexExtended.SetUserName(newUserName); mappingUserName.Add(newUserName, vertexExtended); // Change the name in components // The graph has more than one component => need to change vertex name in one of them. if (GetGraphProperty().GetIsInitializedComponent() && GetGraphProperty().GetCountComponents() > 1) { foreach (IGraphInterface componentGraph in GetGraphProperty().GetComponents()) { if (componentGraph.ExistsUserName(oldUserName)) { componentGraph.RenameVertexUserName(componentGraph.GetVertexByUserName(oldUserName), newUserName); break; } } } }
/// <summary> /// Remove a vertex /// Deinitialize colored graph /// If the vertex does not exist in the graph throws GraphVertexDoesntExistException /// If the graph has only one vertex throws GraphHasToHaveAtLeastOneVertexException /// Time complexity: O(V + E) /// </summary> /// <param name="removeVertex">vertex</param> public void VertexDelete(IVertexInterface removeVertex) { // Vertex doesn't exist if (!ExistsVertex(removeVertex)) { throw new MyException.GraphException.GraphVertexDoesntExistException(); } /* * if (GetGraphProperty().GetCountVertices() == 1) * throw new MyException.GraphException.GraphHasToHaveAtLeastOneVertexException(); */ // Variable int count = 0; HashSet <IVertexInterface> removeVertexList = new HashSet <IVertexInterface>(); adjacencyList.Remove(ConvertVertexToVertexExtended(removeVertex)); foreach (HashSet <VertexExtended> vertexExtendedHashSet in adjacencyList.Values) { foreach (VertexExtended vertexExtended in vertexExtendedHashSet) { if (vertexExtended.Equals(removeVertex)) { removeVertexList.Add(vertexExtended); break; } } count += removeVertexList.Count; vertexExtendedHashSet.RemoveWhere(x => removeVertexList.Contains(x)); removeVertexList.Clear(); } mapping.Remove(removeVertex.GetIdentifier()); mappingUserName.Remove(removeVertex.GetUserName()); DecrementRealCountVertices(); SetCanDeIncreaseCountVertices(true); GetGraphProperty().DecrementCountVertices(); SetCanDeIncreaseCountVertices(false); SetCanDeIncreaseCountEdges(true); GetGraphProperty().DecrementCountEdges(count); SetCanDeIncreaseCountEdges(false); // ColoredGraph coloredGraph.RemoveVertexInHashSets(removeVertex); if (coloredGraph.GetIsInitializedColoredGraph()) { coloredGraph.DeinitializationColoredGraph(); } // GraphProperty GetGraphProperty().VertexDelete(removeVertex); }
/// <summary> /// Return a list of neighbors /// If the graph is not initialized throwsGraphInitializationException /// </summary> /// <param name="vertex">vertex</param> /// <returns>list of neighbors</returns> public List <IVertexInterface> Neighbours(IVertexInterface vertex) { if (!isInitialized) { throw new MyException.GraphException.GraphNotInitializationException(); } return(new List <IVertexInterface> (adjacencyList[ConvertVertexToVertexExtended(vertex)])); }
/// <summary> /// Return count of neighbors /// If the graph is not initialized throwsGraphInitializationException /// </summary> /// <param name="vertex">vertex</param> /// <returns>count of neighbors</returns> public int CountNeighbours(IVertexInterface vertex) { if (!isInitialized) { throw new MyException.GraphException.GraphNotInitializationException(); } return(Neighbours(vertex).Count); }
/// <summary> /// Compare two vertices /// Return true if vertices are equal, otherwise false /// </summary> /// <param name="vertex">the second vertex</param> /// <returns>true if vertices are equal, otherwise false</returns> public bool Equals(IVertexInterface vertex) { if (identifier == vertex.GetIdentifier() && userName == vertex.GetUserName() && GetColor() == vertex.GetColor()) { return(true); } return(false); }
/// <summary> /// Determine the shortest cycle which contains the vertex /// If the cycle does not exist returns int.MaxValue /// </summary> /// <param name="root">vertex</param> /// <returns>the shortest cycle which contains the vertex</returns> private int CycleGirthBFS(IVertexInterface root) { // Variable int bestGirth = int.MaxValue; Queue <CycleNode> nodeBFSQueue = new Queue <CycleNode>(); Dictionary <IVertexInterface, int> nodeDictionary = new Dictionary <IVertexInterface, int>(); List <IVertexInterface> vertexNeighboursList = new List <IVertexInterface>(); CycleNode rootNode = new CycleNode(root, 0); nodeBFSQueue.Enqueue(rootNode); nodeDictionary.Add(rootNode.GetVertex(), rootNode.GetDepth()); while (nodeBFSQueue.Count != 0) { CycleNode node = nodeBFSQueue.Dequeue(); int depth = node.GetDepth() + 1; vertexNeighboursList = graph.Neighbours(node.GetVertex()); foreach (IVertexInterface vertexNeighbour in vertexNeighboursList) { // We have not seen this vertex yet if (!nodeDictionary.ContainsKey(vertexNeighbour)) { nodeBFSQueue.Enqueue(new CycleNode(vertexNeighbour, depth)); nodeDictionary.Add(vertexNeighbour, depth); } else { // Odd cycle if (nodeDictionary[vertexNeighbour] == depth - 1) { if (depth * 2 - 1 < bestGirth) { bestGirth = depth * 2 - 1; } } else { // Even cycle if (nodeDictionary[vertexNeighbour] == depth) { if (depth * 2 < bestGirth) { bestGirth = depth * 2; } } } } } } return(bestGirth); }
/// <summary> /// Return true if a vertex exists in the graph, otherwise false /// Time complexity: O(1) /// </summary> /// <param name="vertex">vertex</param> /// <returns>true if the vertex exists in the graph, otherwise false</returns> public bool ExistsVertex(IVertexInterface vertex) { try { return(adjacencyList.ContainsKey(ConvertVertexToVertexExtended(vertex))); } catch (MyException.GraphException.GraphVertexDoesntExistException) { return(false); } }
/// <summary> /// Convertor from Vertex to VertexExtended /// If the vertex does not exist in the graph throws GraphVertexDoesntExistException /// </summary> /// <param name="vertex">vertex</param> /// <returns>vertexExtended</returns> protected VertexExtended ConvertVertexToVertexExtended(IVertexInterface vertex) { try { return(mapping[vertex.GetIdentifier()]); } catch (KeyNotFoundException) { throw new MyException.GraphException.GraphVertexDoesntExistException(); } }
/// <summary> /// Determine if the graph is cyclic /// Change: isCyclic /// Using: Union-Find /// Time complexity: O(V^2 + E) /// Space complexity: O(V + E) /// </summary> private void CycleIsCyclicUnionFind() { // Variable List <IVertexInterface> allVerticesList; List <IVertexInterface> vertexNeighboursList; HashSet <IVertexInterface> expandedVerticesHashSet; cycleDisjointSetDictionary = new Dictionary <IVertexInterface, IVertexInterface>(GetCountVertices()); expandedVerticesHashSet = new HashSet <IVertexInterface>(); allVerticesList = graph.AllVertices(); // Create disjoint set foreach (IVertexInterface vertex in allVerticesList) { cycleDisjointSetDictionary.Add(vertex, vertex); } // Core algorithm isCyclic = false; foreach (IVertexInterface vertex in allVerticesList) { vertexNeighboursList = graph.Neighbours(vertex); foreach (IVertexInterface neighbourVertex in vertexNeighboursList) { if (expandedVerticesHashSet.Contains(neighbourVertex)) { continue; } IVertexInterface vertex1Representative = CycleFind(vertex); IVertexInterface vertex2Representative = CycleFind(neighbourVertex); if (vertex1Representative == vertex2Representative) { isCyclic = true; return; } CycleUnion(vertex, neighbourVertex); } expandedVerticesHashSet.Add(vertex); } }
/// <summary> /// Determine if the graph is cyclic /// Change: isCyclic /// Time complexity: O(V + E) /// Space complexity: O(V + E) /// </summary> protected void CycleIsCyclic() { // Variable Queue <IVertexInterface> verticesQueue; HashSet <IVertexInterface> visitedVerticesHashSet; Dictionary <IVertexInterface, IVertexInterface> parentsDictionary; verticesQueue = new Queue <IVertexInterface>(); visitedVerticesHashSet = new HashSet <IVertexInterface>(); parentsDictionary = new Dictionary <IVertexInterface, IVertexInterface>(); verticesQueue.Enqueue(graph.GetFirstVertex()); visitedVerticesHashSet.Add(graph.GetFirstVertex()); isCyclic = false; // Initialize parentsDictionary foreach (IVertexInterface vertex in graph.AllVertices()) { parentsDictionary.Add(vertex, null); } while (verticesQueue.Count != 0) { IVertexInterface vertex = verticesQueue.Dequeue(); foreach (IVertexInterface neighbor in graph.Neighbours(vertex)) { if (!visitedVerticesHashSet.Contains(neighbor)) { visitedVerticesHashSet.Add(neighbor); verticesQueue.Enqueue(neighbor); parentsDictionary[neighbor] = vertex; } else { if (parentsDictionary[vertex] != neighbor) { isCyclic = true; return; } } } } }
/// <summary> /// Expand a vertex /// Deinitialize colored graph /// If the vertex does not exist in the graph throws GraphVertexDoesntExistException /// </summary> /// <param name="vertex">vertex</param> public void VertexExpansion(IVertexInterface vertex) { if (!ExistsVertex(vertex)) { throw new MyException.GraphException.GraphVertexDoesntExistException(); } // Variable IVertexInterface vertex1, vertex2; List <IVertexInterface> neighboursList; neighboursList = Neighbours(vertex); vertex1 = new Vertex(vertex.GetUserName() + " (1)"); vertex2 = new Vertex(vertex.GetUserName() + " (2)"); VertexAdd(vertex1); VertexAdd(vertex2); VertexDelete(vertex); // ColoredGraph //coloredGraph.RemoveVertexInHashSets(vertex); // ColoredGraph coloredGraph.AddVertexInHashSets(vertex1); coloredGraph.AddVertexInHashSets(vertex2); foreach (IVertexInterface neighbour in neighboursList) { EdgeAdd(new Edge(vertex1, neighbour)); EdgeAdd(new Edge(vertex2, neighbour)); } EdgeAdd(new Edge(vertex1, vertex2)); // ColoredGraph if (coloredGraph.GetIsInitializedColoredGraph()) { coloredGraph.DeinitializationColoredGraph(); } // GraphProperty GetGraphProperty().VertexExpansion(vertex); }
/// <summary> /// Set potrentional Perfect elimination ordering. /// It is correct only if a graph is chordal! /// You can check it via IsPerfectEliminationOrderingParallel /// Change: perfectEliminationOrderingList /// Use lex-BFS algorithm /// Time complexity: O(V * log(V) + E) /// Space complexity: O(V) /// </summary> private void PerfectEliminationOrdering() { // Variable int countVertices = graph.GetRealCountVertices(); perfectEliminationOrderingList = new List <IVertexInterface>(countVertices); MyDataStructure.FibonacciHeap priorityQueue = new MyDataStructure.FibonacciHeap(countVertices); Dictionary <IVertexInterface, int> mappingVertexDictionary = new Dictionary <IVertexInterface, int>(); IVertexInterface[] mappingVertexArray = new IVertexInterface[countVertices]; // Initilize perfectEliminationOrderingList + mapping int help = 0; foreach (IVertexInterface vertex in graph.AllVertices()) { // Mapping mappingVertexDictionary.Add(vertex, help); mappingVertexArray[help] = vertex; help++; } // Add vertices to fibonacci heap foreach (IVertexInterface vertex in graph.AllVertices()) { priorityQueue.Insert(mappingVertexDictionary[vertex], countVertices); } for (int i = 0; i < countVertices; i++) { IVertexInterface selectedVertex = mappingVertexArray[priorityQueue.ExtractMin().GetIdentifier()]; foreach (IVertexInterface neighbour in graph.Neighbours(selectedVertex)) { int neighbourFibonacciIdentifier = mappingVertexDictionary[neighbour]; if (priorityQueue.ElementExists(neighbourFibonacciIdentifier)) { priorityQueue.Decrease(neighbourFibonacciIdentifier, priorityQueue.GetValue(neighbourFibonacciIdentifier) - 1); } } perfectEliminationOrderingList.Add(selectedVertex); } }
/// <summary> /// Union two components /// Time complexity: O(V) /// </summary> /// <param name="vertex1">first vertex</param> /// <param name="vertex2">second vertex</param> private void CycleUnion(IVertexInterface vertex1, IVertexInterface vertex2) { IVertexInterface vertex1Representative = CycleFind(vertex1); IVertexInterface vertex2Representative = CycleFind(vertex2); if (vertex1Representative == vertex2Representative) { return; } for (int i = 0; i < cycleDisjointSetDictionary.Count; i++) { IVertexInterface vertex = cycleDisjointSetDictionary.ElementAt(i).Key; if (cycleDisjointSetDictionary[vertex] == vertex2Representative) { cycleDisjointSetDictionary[vertex] = vertex1Representative; } } }
/// <summary> /// Get (BFS) spanning tree /// Change: spanningTreeBFS /// Time complexity: O(V + E) /// Space complexity: O(V + E) /// </summary> private void SpanningTreeBFS() { // Variable Queue <IVertexInterface> vertexBFSQueue = new Queue <IVertexInterface>(); HashSet <IVertexInterface> visitedVertexHashSet = new HashSet <IVertexInterface>(); List <IVertexInterface> vertexNeighboursList; int countVertex = graph.GetGraphProperty().GetCountVertices(); IVertexInterface root; spanningTreeBFS = new List <IEdgeInterface>(); root = graph.GetFirstVertex(); vertexBFSQueue.Enqueue(root); visitedVertexHashSet.Add(root); while (vertexBFSQueue.Count != 0) { IVertexInterface vertex = vertexBFSQueue.Dequeue(); vertexNeighboursList = graph.Neighbours(vertex); foreach (IVertexInterface vertexNeighbour in vertexNeighboursList) { if (visitedVertexHashSet.Contains(vertexNeighbour)) { continue; } vertexBFSQueue.Enqueue(vertexNeighbour); spanningTreeBFS.Add(new Edge(vertex, vertexNeighbour)); visitedVertexHashSet.Add(vertexNeighbour); if (spanningTreeBFS.Count == countVertex - 1) { return; } } } }
/// <summary> /// Add a new edge /// If any vertex does not exist throws GraphVertexDoesntExist /// If vertex1 = vertex2 throws GraphInvalidVertexException /// If the edge already exists throws GraphDupliciteEdge /// </summary> /// <param name="vertex1">first vertex</param> /// <param name="vertex2">second vertex</param> protected void AddEdgeToAdjacencyList(IEdgeInterface edge) { // Variable IVertexInterface vertex; IVertexInterface vertex1 = edge.GetVertex1(); IVertexInterface vertex2 = edge.GetVertex2(); // If vertex1 is vertex2 if (vertex1 == vertex2) { throw new MyException.GraphException.GraphInvalidVertexException(); } // Symmetry for (int i = 0; i < 2; i++) { if (!adjacencyList.TryGetValue(ConvertVertexToVertexExtended(vertex1), out HashSet <VertexExtended> adjacencyHashSetVertexExtended)) { throw new MyException.GraphException.GraphVertexDoesntExistException(); } if (adjacencyHashSetVertexExtended.Contains(ConvertVertexToVertexExtended(vertex2))) { return; } // throw new MyException.GraphDupliciteEdge(); adjacencyHashSetVertexExtended.Add(ConvertVertexToVertexExtended(vertex2)); // Swap variables vertex = vertex1; vertex1 = vertex2; vertex2 = vertex; } SetCanDeIncreaseCountEdges(true); graphProperty.IncrementCountEdges(); SetCanDeIncreaseCountEdges(false); }
/// <summary> /// Remove a vertex which has degree 2 /// Deinitialize colored graph /// If the vertex does not exist in the graph throws GraphVertexDoesntExistException /// If the vertex does not have degree 2 throws GraphInvalidDegreeVertex /// </summary> /// <param name="vertex">vertex</param> public void VertexSuppression(IVertexInterface vertex) { if (!ExistsVertex(vertex)) { throw new MyException.GraphException.GraphVertexDoesntExistException(); } if (CountNeighbours(vertex) != 2) { throw new MyException.GraphException.GraphInvalidDegreeVertex(); } // Variable IVertexInterface vertex1, vertex2; vertex1 = Neighbours(vertex).First(); vertex2 = Neighbours(vertex).Last(); VertexDelete(vertex); // ColoredGraph //coloredGraph.RemoveVertexInHashSets(vertex); if (!ExistsEdge(new Edge(vertex1, vertex2))) { EdgeAdd(new Edge(vertex1, vertex2)); } // ColoredGraph if (coloredGraph.GetIsInitializedColoredGraph()) { coloredGraph.DeinitializationColoredGraph(); } // GraphProperty GetGraphProperty().VertexSuppression(vertex); }
public void VertexDelete(IVertexInterface vertex) { // Component if (componentsList != null) { // More components => copies of components if (countComponents > 1) { // Get component which contains the vertex IVertexInterface myVertexComponent = null; IGraphInterface myComponentGraph = null; foreach (IGraphInterface componentGraph in componentsList) { if (componentGraph.ExistsUserName(vertex.GetUserName())) { myComponentGraph = componentGraph; myVertexComponent = myComponentGraph.GetVertexByUserName(vertex.GetUserName()); break; } } // The vertex is component if (myComponentGraph.CountNeighbours(myVertexComponent) == 0) { componentsList.Remove(myComponentGraph); countComponents--; isConnected = countComponents == 1 ? true : false; } // The vertex is in a component with another vertices else { componentsList = null; countComponents = null; isConnected = null; } } else { if (cutVertices != null && !cutVertices.Contains(vertex)) { //componentsList = componentsList; //countComponents = countComponents; //isConnected = isConnected; } else { componentsList = null; countComponents = null; isConnected = null; } } } // Properties if (isCyclic != null && (bool)isCyclic) { isCyclic = null; } if (isConnected != null && !(bool)isConnected) { isEulerian = EulerianGraphEnum.notEulerian; } else { isEulerian = EulerianGraphEnum.undefined; } // IntegralInvariants circuitRank = null; girth = null; cayleysFormula = null; // SequencesAndPolynomialsOthers if (isConnected != null && !(bool)isConnected) { spanningTreeBFS = spanningTreeBFS = new List <IEdgeInterface>(); } else { spanningTreeBFS = null; } matching = null; cutVertices = null; bridges = null; // DegreeSequence degreeSequence = null; maximumVertexDegree = null; minimumVertexDegree = null; averageVertexDegree = null; medianVertexDegree = null; isDegreeSequenceSorted = false; isRegular = null; // Chordal isChordal = null; perfectEliminationOrderingList = null; righNeighborhoodDictionary = null; // GraphClass graphClass = GraphClass.GraphClass.GraphClassEnum.undefined; }
/// <summary> /// Contract a vertex /// Deinitialize colored graph /// If the vertex does not exist in the graph throws GraphVertexDoesntExistException /// </summary> /// <param name="vertex">vertex</param> public void VertexContraction(IVertexInterface vertex) { if (!ExistsVertex(vertex)) { throw new MyException.GraphException.GraphVertexDoesntExistException(); } if (CountNeighbours(vertex) == 0) { return; } // Variable string nameNewVertex; List <IVertexInterface> neighboursVertexList, neighboursVertexUnionList, neighboursList; neighboursVertexUnionList = new List <IVertexInterface>(); neighboursList = Neighbours(vertex); VertexDelete(vertex); nameNewVertex = vertex.GetUserName(); foreach (IVertexInterface neighbour in neighboursList) { nameNewVertex += neighbour.GetUserName(); } IVertexInterface newVertex = new Vertex(nameNewVertex); foreach (IVertexInterface neighbour in neighboursList) { neighboursVertexList = Neighbours(neighbour); neighboursVertexUnionList = neighboursVertexUnionList.Union(neighboursVertexList).ToList(); } neighboursVertexUnionList = neighboursVertexUnionList.Except(neighboursList).ToList(); // Delete vertices foreach (IVertexInterface removeVertex in neighboursList) { VertexDelete(removeVertex); // ColoredGraph // coloredGraph.RemoveVertexInHashSets(removeVertex); } // Add vertex VertexAdd(newVertex); // ColoredGraph coloredGraph.AddVertexInHashSets(newVertex); // Add edges foreach (IVertexInterface neighbour in neighboursVertexUnionList) { EdgeAdd(new Edge(newVertex, neighbour)); } // ColoredGraph if (coloredGraph.GetIsInitializedColoredGraph()) { coloredGraph.DeinitializationColoredGraph(); } // GraphProperty GetGraphProperty().VertexContraction(vertex); }
public Edge(IVertexInterface vertex1, IVertexInterface vertex2) { this.vertex1 = vertex1; this.vertex2 = vertex2; }
private void BridgesCutVerticesRecursion(IVertexInterface vertex, HashSet <IVertexInterface> visitedVertexHashSet, Dictionary <IVertexInterface, int> discoveryTimesDictionary, Dictionary <IVertexInterface, int> lowDictionary, Dictionary <IVertexInterface, IVertexInterface> parentDictionary) { // Variable int children = 0; List <IVertexInterface> neighboursList = graph.Neighbours(vertex); visitedVertexHashSet.Add(vertex); if (!discoveryTimesDictionary.ContainsKey(vertex)) { discoveryTimesDictionary.Add(vertex, 0); } if (!lowDictionary.ContainsKey(vertex)) { lowDictionary.Add(vertex, 0); } discoveryTimesDictionary[vertex] = lowDictionary[vertex] = ++timeBridgesCutVertices; foreach (IVertexInterface neighbour in neighboursList) { if (!visitedVertexHashSet.Contains(neighbour)) { children++; if (!parentDictionary.ContainsKey(neighbour)) { parentDictionary.Add(neighbour, vertex); } else { parentDictionary[neighbour] = vertex; } BridgesCutVerticesRecursion(neighbour, visitedVertexHashSet, discoveryTimesDictionary, lowDictionary, parentDictionary); if (!lowDictionary.ContainsKey(neighbour)) { lowDictionary.Add(neighbour, 0); } lowDictionary[vertex] = Math.Min(lowDictionary[vertex], lowDictionary[neighbour]); if (!cutVertices.Contains(vertex) && !parentDictionary.ContainsKey(vertex) && children > 1) { cutVertices.Add(vertex); } if (!cutVertices.Contains(vertex) && parentDictionary.ContainsKey(vertex) && lowDictionary[neighbour] >= discoveryTimesDictionary[vertex]) { cutVertices.Add(vertex); } if (!bridges.Contains(new Edge(vertex, neighbour)) && lowDictionary[neighbour] > discoveryTimesDictionary[vertex]) { bridges.Add(new Edge(vertex, neighbour)); } } else { if (!parentDictionary.ContainsKey(vertex) || parentDictionary[vertex] != neighbour) { lowDictionary[vertex] = Math.Min(lowDictionary[vertex], discoveryTimesDictionary[neighbour]); } } } }
// Constructor public CycleNode(IVertexInterface vertex, int depth) { this.vertex = vertex; this.depth = depth; }
public void VertexExpansion(IVertexInterface vertex) { // Component if (componentsList != null) { // Need change => copies of component if (countComponents > 1) { // Get component which contains the vertex IVertexInterface myVertexComponent = null; IGraphInterface myComponentGraph = null; foreach (IGraphInterface componentGraph in componentsList) { if (componentGraph.ExistsUserName(vertex.GetUserName())) { myComponentGraph = componentGraph; myVertexComponent = myComponentGraph.GetVertexByUserName(vertex.GetUserName()); break; } } myComponentGraph.VertexExpansion(myVertexComponent); } //componentsList = componentsList; //countComponents = countComponents; //isConnected = isConnected; } // Properties isCyclic = null; isEulerian = EulerianGraphEnum.undefined; // IntegralInvariants circuitRank = null; girth = null; cayleysFormula = null; // SequencesAndPolynomialsOthers if (isConnected != null && !(bool)isConnected) { spanningTreeBFS = spanningTreeBFS = new List <IEdgeInterface>(); } else { spanningTreeBFS = null; } matching = null; cutVertices = null; bridges = null; // DegreeSequence degreeSequence = null; maximumVertexDegree = null; minimumVertexDegree = null; averageVertexDegree = null; medianVertexDegree = null; isDegreeSequenceSorted = false; isRegular = null; // Chordal if (isChordal.HasValue && (bool)isChordal) { isChordal = null; perfectEliminationOrderingList = null; righNeighborhoodDictionary = null; } // GraphClass graphClass = GraphClass.GraphClass.GraphClassEnum.undefined; }
public void EdgeDelete(IEdgeInterface edge) { // Variable IVertexInterface vertex1 = graph.GetVertexByUserName(edge.GetVertex1().GetUserName()); IVertexInterface vertex2 = graph.GetVertexByUserName(edge.GetVertex2().GetUserName()); // Component if (componentsList != null) { if (countComponents > 1) { // Get component which contains the vertex IGraphInterface myComponentGraph = null; foreach (IGraphInterface componentGraph in componentsList) { if (componentGraph.ExistsUserName(vertex1.GetUserName())) { myComponentGraph = componentGraph; break; } } myComponentGraph.EdgeDelete(new Edge(myComponentGraph.GetVertexByUserName(vertex1.GetUserName()), myComponentGraph.GetVertexByUserName(vertex2.GetUserName()))); componentsList = null; countComponents = null; isConnected = null; } else { if (bridges != null) { // The edge is a bridge if (bridges.Any(e => ((e.GetVertex1().Equals(vertex1) && e.GetVertex2().Equals(vertex2)) || (e.GetVertex1().Equals(vertex2) && e.GetVertex2().Equals(vertex1))))) { componentsList = null; countComponents = null; isConnected = null; } // The edge isn't a bridge else { //componentsList = componentsList; //countComponents = countComponents; //isConnected = isConnected; } } } } // Properties if (isCyclic != null && !(bool)isCyclic) { isCyclic = false; } else { isCyclic = null; } if (isEulerian == EulerianGraphEnum.eulerian) { isEulerian = EulerianGraphEnum.semiEulerian; } else { isEulerian = EulerianGraphEnum.undefined; } // IntegralInvariants circuitRank = null; if (girth != null && girth > 2) { girth = null; } //cayleysFormula = cayleysFormula; // SequencesAndPolynomialsOthers if (isConnected != null && !(bool)isConnected) { spanningTreeBFS = spanningTreeBFS = new List <IEdgeInterface>(); } else { spanningTreeBFS = null; } matching = null; cutVertices = null; bridges = null; // DegreeSequence if (degreeSequence != null) { int countNeighbourVertex1 = graph.CountNeighbours(vertex1); int countNeighbourVertex2 = graph.CountNeighbours(vertex2); if (!isDegreeSequenceSorted) { // Variable int index1, index2; index1 = degreeSequenceInt.FindIndex(i => i == (countNeighbourVertex1 + 1)); degreeSequenceInt[index1] = countNeighbourVertex1; index2 = degreeSequenceInt.FindIndex(i => i == (countNeighbourVertex2 + 1)); degreeSequenceInt[index2] = countNeighbourVertex2; index1 = degreeSequence.FindIndex(p => p.Key == vertex1); index2 = degreeSequence.FindIndex(p => p.Key == vertex2); degreeSequence[index1] = new KeyValuePair <IVertexInterface, int>(vertex1, countNeighbourVertex1); degreeSequence[index2] = new KeyValuePair <IVertexInterface, int>(vertex2, countNeighbourVertex2); } else { degreeSequence = null; degreeSequenceVertex = null; degreeSequenceInt = null; isDegreeSequenceSorted = false; } if (minimumVertexDegree.HasValue) { if (countNeighbourVertex1 < minimumVertexDegree) { minimumVertexDegree = countNeighbourVertex1; } if (countNeighbourVertex2 < minimumVertexDegree) { minimumVertexDegree = countNeighbourVertex2; } } if (maximumVertexDegree.HasValue) { if (((countNeighbourVertex1 + 1) == maximumVertexDegree) || ((countNeighbourVertex2 + 1) == maximumVertexDegree)) { maximumVertexDegree = null; } } averageVertexDegree = null; medianVertexDegree = null; isRegular = null; } // Chordal isChordal = null; perfectEliminationOrderingList = null; righNeighborhoodDictionary = null; // GraphClass graphClass = GraphClass.GraphClass.GraphClassEnum.undefined; }
public void VertexAdd(IVertexInterface vertex) { // Component if (componentsList != null) { if (countComponents > 2) { // Create a new component with the vertex IGraphEdgeListInterface newGraph = new GraphEdgeList(1); newGraph.AddVertex(vertex.GetUserName()); newGraph.InitializeGraph(); componentsList.Add(newGraph); countComponents++; isConnected = false; } else { componentsList = null; countComponents = null; isConnected = null; } } // Properties //isCyclic = isCyclic; isEulerian = EulerianGraphEnum.notEulerian; if (countComponents != order) { isRegular = false; } else { isRegular = true; } // IntegralInvariants //circuitRank = circuitRank; //girth = girth; cayleysFormula = null; // SequencesAndPolynomialsOthers spanningTreeBFS = spanningTreeBFS = new List <IEdgeInterface>(); //matching = matching; //cutVertices = cutVertices; //bridges = bridges; // DegreeSequence if (degreeSequence != null) { if (!isDegreeSequenceSorted) { degreeSequence.Add(new KeyValuePair <IVertexInterface, int>(vertex, 0)); degreeSequenceVertex.Add(vertex); degreeSequenceInt.Add(0); } else { degreeSequence = null; degreeSequenceVertex = null; degreeSequenceInt = null; isDegreeSequenceSorted = false; } if (0 < minimumVertexDegree) { minimumVertexDegree = 0; } //maximumVertexDegree = maximumVertexDegree; averageVertexDegree = null; medianVertexDegree = null; } // Chordal //isChordal = isChordal; if (isChordal.HasValue && (bool)isChordal) { perfectEliminationOrderingList.Add(vertex); } // GraphClass //graphClass = graphClass; }
/// <summary> /// Find a representant /// Time complexity: O(1) /// </summary> /// <param name="vertex">vertex</param> /// <returns>representant of the vertex</returns> private IVertexInterface CycleFind(IVertexInterface vertex) { return(cycleDisjointSetDictionary[vertex]); }
public void EdgeSubdivision(IEdgeInterface edge) { // Variable IVertexInterface vertex1 = graph.GetVertexByUserName(edge.GetVertex1().GetUserName()); IVertexInterface vertex2 = graph.GetVertexByUserName(edge.GetVertex2().GetUserName()); // Component if (componentsList != null) { if (countComponents > 1) { // Get component which contains the vertex IGraphInterface myComponentGraph = null; foreach (IGraphInterface componentGraph in componentsList) { if (componentGraph.ExistsUserName(vertex1.GetUserName())) { myComponentGraph = componentGraph; break; } } myComponentGraph.EdgeSubdivision(new Edge(myComponentGraph.GetVertexByUserName(vertex1.GetUserName()), myComponentGraph.GetVertexByUserName(vertex2.GetUserName()))); } else { //componentsList = componentsList; //countComponents = countComponents; //isConnected = isConnected; } } // Properties //isCyclic = isCyclic; //isEulerian = isEulerian; // IntegralInvariants //circuitRank = circuitRank; if (girth.HasValue && girth > 2) { girth = null; } cayleysFormula = null; // SequencesAndPolynomialsOthers if (isConnected != null && !(bool)isConnected) { spanningTreeBFS = spanningTreeBFS = new List <IEdgeInterface>(); } else { spanningTreeBFS = null; } matching = null; cutVertices = null; bridges = null; // DegreeSequence degreeSequence = null; maximumVertexDegree = null; minimumVertexDegree = null; averageVertexDegree = null; medianVertexDegree = null; isDegreeSequenceSorted = false; isRegular = null; // Chordal if (isChordal.HasValue && (bool)isChordal) { isChordal = null; perfectEliminationOrderingList = null; righNeighborhoodDictionary = null; } // GraphClass graphClass = GraphClass.GraphClass.GraphClassEnum.undefined; }
public Arc(IVertexInterface vertexFrom, IVertexInterface vertexTo) { this.vertexFrom = vertexFrom; this.vertexTo = vertexTo; }