/// <summary> /// Determines whether the edge-weighted digraph <c>G</c> has a /// topological order and, if so, finds such a topological order.</summary> /// <param name="G">the digraph</param> /// public TopologicalX(EdgeWeightedDigraph G) { // indegrees of remaining vertices int[] indegree = new int[G.V]; for (int v = 0; v < G.V; v++) { indegree[v] = G.Indegree(v); } // initialize rank = new int[G.V]; order = new LinkedQueue <int>(); int count = 0; // initialize queue to contain all vertices with indegree = 0 LinkedQueue <int> queue = new LinkedQueue <int>(); for (int v = 0; v < G.V; v++) { if (indegree[v] == 0) { queue.Enqueue(v); } } for (int j = 0; !queue.IsEmpty; j++) { int v = queue.Dequeue(); order.Enqueue(v); rank[v] = count++; foreach (DirectedEdge e in G.Adj(v)) { int w = e.To; indegree[w]--; if (indegree[w] == 0) { queue.Enqueue(w); } } } // there is a directed cycle in subgraph of vertices with indegree >= 1. if (count != G.V) { order = null; } Debug.Assert(check(G)); }
private void bfs(Graph G, int s) { LinkedQueue <int> q = new LinkedQueue <int>(); color[s] = WHITE; marked[s] = true; q.Enqueue(s); while (!q.IsEmpty) { int v = q.Dequeue(); foreach (int w in G.Adj(v)) { if (!marked[w]) { marked[w] = true; edgeTo[w] = v; color[w] = !color[v]; q.Enqueue(w); } else if (color[w] == color[v]) { isBipartite = false; // to form odd cycle, consider s-v path and s-w path // and let x be closest node to v and w common to two paths // then (w-x path) + (x-v path) + (edge v-w) is an odd-length cycle // Note: distTo[v] == distTo[w]; cycle = new LinkedQueue <int>(); LinkedStack <int> stack = new LinkedStack <int>(); int x = v, y = w; while (x != y) { stack.Push(x); cycle.Enqueue(y); x = edgeTo[x]; y = edgeTo[y]; } stack.Push(x); while (!stack.IsEmpty) { cycle.Enqueue(stack.Pop()); } cycle.Enqueue(w); return; } } } }
// is there an augmenting path? // an alternating path is a path whose edges belong alternately to the matching and not to the matching // an augmenting path is an alternating path that starts and ends at unmatched vertices // // if so, upon termination edgeTo[] contains a parent-link representation of such a path // if not, upon terminatation marked[] specifies the subset of vertices reachable via an alternating // path from one side of the bipartition // // this implementation finds a shortest augmenting path (fewest number of edges), though there // is no particular advantage to do so here private bool hasAugmentingPath(Graph G) { marked = new bool[numVertices]; edgeTo = new int[numVertices]; for (int v = 0; v < numVertices; v++) { edgeTo[v] = -1; } // breadth-first search (starting from all unmatched vertices on one side of bipartition) LinkedQueue <int> queue = new LinkedQueue <int>(); for (int v = 0; v < numVertices; v++) { if (bipartition.Color(v) && !IsMatched(v)) { queue.Enqueue(v); marked[v] = true; } } // run BFS, stopping as soon as an alternating path is found while (!queue.IsEmpty) { int v = queue.Dequeue(); foreach (int w in G.Adj(v)) { // either (1) forward edge not in matching or (2) backward edge in matching if (isResidualGraphEdge(v, w)) { if (!marked[w]) { edgeTo[w] = v; marked[w] = true; if (!IsMatched(w)) { return(true); } queue.Enqueue(w); } } } } return(false); }
public static void MainTest(string[] args) { LinkedQueue <string> q = new LinkedQueue <string>(); TextInput StdIn = new TextInput(); while (!StdIn.IsEmpty) { string item = StdIn.ReadString(); if (!item.Equals("-")) { q.Enqueue(item); } else if (!q.IsEmpty) { Console.Write(q.Dequeue() + " "); } } Console.WriteLine("(" + q.Count + " left on queue)"); }
/// <summary> /// Returns the keys in the BST in level order (for debugging).</summary> /// <returns>the keys in the BST in level order traversal</returns> /// public IEnumerable <Key> LevelOrder() { LinkedQueue <Key> keys = new LinkedQueue <Key>(); LinkedQueue <Node> queue = new LinkedQueue <Node>(); queue.Enqueue(root); while (!queue.IsEmpty) { Node x = queue.Dequeue(); if (x == null) { continue; } keys.Enqueue(x.key); queue.Enqueue(x.left); queue.Enqueue(x.right); } return(keys); }
// BFS from single source private void bfs(Digraph G, int s) { LinkedQueue <int> q = new LinkedQueue <int>(); marked[s] = true; distTo[s] = 0; q.Enqueue(s); while (!q.IsEmpty) { int v = q.Dequeue(); foreach (int w in G.Adj(v)) { if (!marked[w]) { edgeTo[w] = v; distTo[w] = distTo[v] + 1; marked[w] = true; q.Enqueue(w); } } } }
private IEnumerable <DirectedEdge> cycle; // negative cycle (or null if no such cycle) /// <summary>Computes a shortest paths tree from <c>s</c> to every other vertex in /// the edge-weighted digraph <c>G</c>.</summary> /// <param name="G">the acyclic digraph</param> /// <param name="s">the source vertex</param> /// <exception cref="ArgumentException">unless 0 <= <c>s</c> <= <c>V</c> - 1</exception> /// public BellmanFordSP(EdgeWeightedDigraph G, int s) { distTo = new double[G.V]; edgeTo = new DirectedEdge[G.V]; onQueue = new bool[G.V]; for (int v = 0; v < G.V; v++) { distTo[v] = double.PositiveInfinity; } distTo[s] = 0.0; // Bellman-Ford algorithm queue = new LinkedQueue <int>(); queue.Enqueue(s); onQueue[s] = true; while (!queue.IsEmpty && !HasNegativeCycle) { int v = queue.Dequeue(); onQueue[v] = false; relax(G, v); } Debug.Assert(check(G, s)); }
private LinkedStack <int> cycle; // the directed cycle; null if digraph is acyclic /// <summary> /// Determines whether the digraph <c>G</c> has a directed cycle and, if so, /// finds such a cycle.</summary> /// <param name="G">the digraph</param> /// public DirectedCycleX(Digraph G) { // indegrees of remaining vertices int[] indegree = new int[G.V]; for (int v = 0; v < G.V; v++) { indegree[v] = G.Indegree(v); } // initialize queue to contain all vertices with indegree = 0 LinkedQueue <int> queue = new LinkedQueue <int>(); for (int v = 0; v < G.V; v++) { if (indegree[v] == 0) { queue.Enqueue(v); } } for (int j = 0; !queue.IsEmpty; j++) { int v = queue.Dequeue(); foreach (int w in G.Adj(v)) { indegree[w]--; if (indegree[w] == 0) { queue.Enqueue(w); } } } // there is a directed cycle in subgraph of vertices with indegree >= 1. int[] edgeTo = new int[G.V]; int root = -1; // any vertex with indegree >= -1 for (int v = 0; v < G.V; v++) { if (indegree[v] == 0) { continue; } else { root = v; } foreach (int w in G.Adj(v)) { if (indegree[w] > 0) { edgeTo[w] = v; } } } if (root != -1) { // find any vertex on cycle bool[] visited = new bool[G.V]; while (!visited[root]) { visited[root] = true; root = edgeTo[root]; } // extract cycle cycle = new LinkedStack <int>(); int v = root; do { cycle.Push(v); v = edgeTo[v]; } while (v != root); cycle.Push(root); } Debug.Assert(check()); }