public bool IsGraphConnected() { if (Graph.GraphParts is null) { } else { var foundedDirectedEdge = Graph.GraphParts.FirstOrDefault(x => x.IsDirected); if (foundedDirectedEdge is null) { } else { throw new ArgumentException( "It won't find out if the graph is connected or not when directed Graph Parts exists."); } } DeclareArrays(); Queue <int> queue = new Queue <int>(); int startVertex = 0; MainLoopForSeparatedConnectedGraph(queue, Visited, PreviousArray, startVertex); return(!Visited.Contains(false)); }
private void Search(int root) { var queue = new Queue <int>(); ChangeColor(root, Colors.Red); queue.Enqueue(root); Visited.Add(root); while (queue.Count > 0) { if (queue.ToList().Exists(d => d == TargetId)) { ChangeColor(TargetId.Value, Colors.Red); BuildPath(); return; } var v1 = queue.Dequeue(); foreach (var v2 in _model.GetAdjacentVerticies(v1)) { if (!Visited.Contains(v2)) { ChangeColor(HashCode.GetHashCode(v1, v2), Colors.CornflowerBlue); ChangeColor(v2, Colors.CornflowerBlue); queue.Enqueue(v2); Visited.Add(v2); _path[v2] = v1; if (v2 == TargetId) { break; } } } } }
private bool Search(int root) { if (root == TargetId) { ChangeColor(root, Colors.Red); return(true); } Visited.Add(root); if (root != SourceId) { ChangeColor(root, Colors.Gold); } foreach (var v in _model.GetAdjacentVerticies(root)) { if (!Visited.Contains(v)) { ChangeColor(HashCode.GetHashCode(root, v), Colors.Gold); if (Search(v)) { return(true); } ChangeColor(HashCode.GetHashCode(root, v), Colors.DarkSlateGray); } } ChangeColor(root, Colors.DarkSlateGray); return(false); }
public virtual IEnumerable <LevelItem <TItem> > ExpandWalk(TItem start, int level, Func <LevelItem <TItem>, bool> predicate) { var queue = new Queue <LevelItem <TItem> > (); Action <TItem, TItem, int> enqueue = (node, path, l) => { if (!Visited.Contains(node)) { var item = new LevelItem <TItem> (node, path, l); if (predicate == null || predicate(item)) { queue.Enqueue(item); } Visited.Add(node); } }; enqueue(start, default(TItem), level); while (queue.Count > 0) { var item = queue.Dequeue(); yield return(item); level = item.Level; if (item.Node is TEdge) { var edge = (TEdge)item.Node; var adjacent = graph.Adjacent(edge, start); if (adjacent != null || (edge.Equals(start)) || (graph.RootIsEdge(edge) && graph.LeafIsEdge(edge))) { // follow link of links foreach (var edge_edge in graph.Edges(edge)) { enqueue(edge_edge, edge, level + 1); } } if (adjacent != null) // follow adjacent of start: { enqueue(adjacent, edge, level); } else { enqueue(edge.Root, edge, level); enqueue(edge.Leaf, edge, level); } } else if (item.Node.Equals(start)) { foreach (var edge in graph.Edges(item.Node)) { enqueue(edge, item.Node, level + 1); } } } }
public virtual IEnumerable <LevelItem <TItem> > CollapseWalk(TItem start, int level) { var queue = new Queue <TItem> (); foreach (var edge in graph.Edges(start)) { foreach (var subedge in graph.Edges(edge)) { if (!Visited.Contains(subedge)) { if (subedge.Leaf.Equals(edge)) { continue; } queue.Enqueue(subedge); Visited.Add(subedge); if (!Visited.Contains(subedge.Leaf)) { queue.Enqueue(subedge.Leaf); Visited.Add(subedge.Leaf); } } } if (!Visited.Contains(edge)) { if (edge.Leaf.Equals(start)) { continue; } queue.Enqueue(edge); Visited.Add(edge); if (!Visited.Contains(edge.Leaf)) { queue.Enqueue(edge.Leaf); Visited.Add(edge.Leaf); } } } while (queue.Count > 0) { var item = queue.Dequeue(); yield return(new LevelItem <TItem> (item, default(TItem), 0)); foreach (var edge in graph.Twig(item)) { if (!Visited.Contains(edge)) { Visited.Add(edge); yield return(new LevelItem <TItem> (edge, default(TItem), 0)); } } } }
public override void Calc() { var inp1 = input.Split('\n'); for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { if (input[i * 7 + j] == '#') { grid[i, j] = true; } } } /* * var g = gridToInt(); * Console.WriteLine(Convert.ToString(g, 2)); */ while (true) { iterate(); int g = gridToInt(); if (Visited.Contains(g)) { //Console.WriteLine(g); /* for (int i = 0; i < 5; i++) * { * for (int j = 0; j < 5; j++) * { * if (grid[i, j]) * { * Console.Write('#'); * } * else * { * Console.Write('.'); * } * * } * Console.WriteLine(); * }*/ // Console.ReadLine(); output = g + ""; break; } Visited.Add(g); } }
private int GetRandomQuestionId() { int currentId; do { currentId = Rand.Next(MinQuestionId, MaxQuestionId + 1); } while (Visited.Contains(currentId)); return(currentId); }
public async Task <IActionResult> FilterQuestions(int catId) { var filtered = await(from q in _context.Questions orderby q.QuestionId where !Visited.Contains(q.QuestionId) select new { questionId = q.QuestionId, body = q.QuestionBody, catId = q.QuestionCategoryId }).ToListAsync(); if (catId > 0) { filtered = filtered.Where(f => f.catId == catId).ToList(); } MinQuestionId = filtered.Min(q => q.questionId); MaxQuestionId = filtered.Max(q => q.questionId); return(await GetNextQuestion()); }
private static long Input() { var attempt = Attempts.Pop().Where(dir => !Visited.Contains(Compass.PositionAfterMovement(droidPosition, dir))).ToList(); if (attempt.Count == 0) { Backtracking = true; Attempt = Compass.Opposite(EnteredFrom[droidPosition]); } else { Backtracking = false; Attempt = attempt[0]; attempt.RemoveAt(0); Attempts.Push(attempt); } var backTrackingString = Backtracking ? " (BACKTRACKING)" : ""; Day15Debug.Write($"({droidPosition.x}),{droidPosition.y}) - {Compass.Name(Attempt)}{backTrackingString} : "); return(Compass.ToLong(Attempt)); }
private void BuildTree(BasicBlock block) { if (block == null) { return; } Visited.Add(block); if (block.Children == null) { return; } var children = new List <BasicBlock>(); if (block.Children != null) { children.AddRange(block.Children); } foreach (var child in children) { if (!Visited.Contains(child)) { if (!SpanningTree.Vertices.Contains(block)) { SpanningTree.AddVertex(block); } if (!SpanningTree.Vertices.Contains(child)) { SpanningTree.AddVertex(child); } SpanningTree.AddEdge(new Edge <BasicBlock>(block, child)); BuildTree(child); } } }
/// <summary> /// under construction; should be a more clear algo than CollapseWalk /// </summary> /// <param name="start"></param> /// <param name="level"></param> /// <returns></returns> public virtual IEnumerable <LevelItem <TItem> > CollapseWalk1(TItem start, int level) { var queue = new Queue <TItem> (); queue.Enqueue(start); while (queue.Count > 0) { var item = queue.Dequeue(); yield return(new LevelItem <TItem> (item, default(TItem), 0)); foreach (var edge in graph.Twig(item)) { if (!Visited.Contains(edge)) { queue.Enqueue(edge); Visited.Add(edge); if (edge.Leaf.Equals(item)) { continue; } if (graph.Adjacent(edge, item) != null) { //if (!done.Contains(edge.Root)) { // queue.Enqueue(edge.Root); // done.Add(edge.Root); //} if (!Visited.Contains(edge.Leaf)) { queue.Enqueue(edge.Leaf); Visited.Add(edge.Leaf); } } } } } }
public override void FindPaths() { var evalQueue = new Queue <ulong[]>(); evalQueue.Enqueue(new ulong[] { TargetObject }); while (evalQueue.Count > 0) { if (Stop) { break; } var chain = evalQueue.Dequeue(); if (chain.Length > MaxDepth) { continue; } var current = chain[0]; if (Visited.Contains(current)) { continue; } Visited.Add(current); AddPathIfRootReached(current, chain); foreach (var referencingObj in Index.FindRefs(current)) { var newChain = new ulong[chain.Length + 1]; newChain[0] = referencingObj; Array.Copy(chain, 0, newChain, 1, chain.Length); evalQueue.Enqueue(newChain); } } }
private void FindPaths(ulong current, Stack <ulong> path) { if (Stop || path.Count > MaxDepth) { return; } if (Visited.Contains(current)) { return; } Visited.Add(current); AddPathIfRootReached(current, path); foreach (ulong referencingObj in Index.FindRefs(current)) { path.Push(referencingObj); FindPaths(referencingObj, path); path.Pop(); } }
public override void FindPaths() { var evalQueue = new ConcurrentQueue <ulong[]>(); evalQueue.Enqueue(new ulong[] { TargetObject }); while (evalQueue.Count > 0) { if (Stop) { break; } // Level-synchronized BFS: process each frontier in parallel Parallel.ForEach(evalQueue, chain => { if (chain.Length > MaxDepth) { return; } var current = chain[0]; // TODO Check if it's necessary to reduce synchronization around 'Visited' lock (Visited) { if (Visited.Contains(current)) { return; } Visited.Add(current); } lock (this) { AddPathIfRootReached(current, chain); } // Turns out ClrMD's heap operations are not thread-safe because the underlying // memory data reader is not thread-safe (WAT?!?). So we have to lock here around // the heap index operations, and that slows everything down to a crawl because // there are some large objects where EnumerateRefsOfObject takes >1000ms. // Throw in one or two of those, and the parallel version runs much slower than // the sequential one. // TODO See if this can be improved, filed an issue on https://github.com/Microsoft/dotnetsamples/issues/21 List <ulong> refs; lock (Index) { refs = Index.FindRefs(current).ToList(); } Parallel.ForEach(refs, referencingObj => { var newChain = new ulong[chain.Length + 1]; newChain[0] = referencingObj; Array.Copy(chain, 0, newChain, 1, chain.Length); evalQueue.Enqueue(newChain); }); }); } }
public virtual IEnumerable <LevelItem <TItem> > Walk(TItem start, int level, Func <LevelItem <TItem>, bool> predicate) { var queue = new Queue <LevelItem <TItem> > (); Func <TItem, TItem, int, LevelItem <TItem> > take = (node, path, l) => { if (!Visited.Contains(node)) { var item = new LevelItem <TItem> (node, path, l); if (predicate == null || predicate(item)) { if (node is TEdge) { queue.Enqueue(item); } else { return(item); } } Visited.Add(node); } return(null); }; Func <TItem, TItem, int, LevelItem <TItem> > enqueue = (node, path, l) => { if (!Visited.Contains(node)) { var item = new LevelItem <TItem> (node, path, l); if (predicate == null || predicate(item)) { queue.Enqueue(item); } Visited.Add(node); } return(null); }; enqueue(start, default(TItem), level); while (queue.Count > 0) { var item = queue.Dequeue(); yield return(item); level = item.Level + 1; if (item.Node is TEdge) { var edge = (TEdge)item.Node; // follow link of links // Fork!? foreach (var edge_edge in graph.Edges(edge)) { enqueue(edge_edge, edge, level); } var adjacent = graph.Adjacent(edge, item.Path); if (adjacent != null) { // follow adjacent of node: var result = take(adjacent, edge, level); if (result != null) { yield return(result); } } else { var result = take(edge.Root, edge, level); if (result != null) { yield return(result); } result = take(edge.Leaf, edge, level); if (result != null) { yield return(result); } } } else { foreach (var edge in graph.Edges(item.Node)) { enqueue(edge, item.Node, level); } } } }
public virtual IEnumerable <LevelItem <TItem> > DeepWalk(TItem start, int startLevel, Func <LevelItem <TItem>, bool> predicate, bool breathFirst) { Action <TItem, TItem, int, bool> put = null; Action <LevelItem <TItem> > add = null; Action <LevelItem <TItem> > addReverse = null; Func <LevelItem <TItem> > get = null; Func <int> loopCount = null; var depthFirst = !breathFirst; var queued = breathFirst; var splitNonAdjacent = depthFirst; var edgeEdgesFirst = depthFirst; DoTrace($"{nameof (DeepWalk)}:{nameof (breathFirst)} {breathFirst}\t{nameof (queued)} {queued}\t"); var list = new LinkedList <LevelItem <TItem> > (); var llNode = list.Last; if (queued) { // first in first out loopCount = () => list.Count; get = () => { var item = list.First.Value; list.RemoveFirst(); DoTrace($"\t{nameof (get)} {item}"); return(item); }; add = item => { list.AddLast(item); DoTrace($"\t{nameof (add)} {item}"); }; addReverse = add; } else { // last in last out loopCount = () => list.Count; get = () => { var item = list.Last.Value; list.RemoveLast(); DoTrace($"\t{nameof (get)} {item}"); return(item); }; add = item => { llNode = null; list.AddLast(item); DoTrace($"\t{nameof (add)} {item}"); }; addReverse = item => { if (llNode != null) { llNode = list.AddBefore(llNode, item); } else { llNode = list.AddLast(item); } DoTrace($"\t{nameof (addReverse)} {item}"); }; if (linqReverse) { addReverse = add; } } put = (node, path, l, reverse) => { if (!Visited.Contains(node)) { var item = new LevelItem <TItem> (node, path, l); DoTrace($"\t{nameof (put)} {item}"); Visited.Add(node); if (predicate == null || predicate(item)) { if (reverse) { addReverse(item); } else { add(item); } } } }; put(start, default(TItem), startLevel, false); while (loopCount() > 0) { var item = get(); if (true) { DoTrace($"\tyield {item}"); yield return(item); } var level = item.Level + 1; if (item.Node is TEdge) { var edge = (TEdge)item.Node; var edgeTuple = Tuple.Create(edge.Leaf, edge.Root); var adjacent = graph.Adjacent(edge, item.Path); if (adjacent == null) { edgeTuple = Ordered(edge); if (splitNonAdjacent) { put(edgeTuple.Item1, edge, level, false); } } Action putEdgeEdges = () => { // follow links of edge: foreach (var edge_edge in Ordered(graph.Edges(edge), edge)) { put(edge_edge, edge, level, true); } }; if (edgeEdgesFirst) { putEdgeEdges(); } if (adjacent != null) { // follow adjacent of node: put(adjacent, edge, level, false); } else { if (splitNonAdjacent) { put(edgeTuple.Item2, edge, level, false); } else { put(edgeTuple.Item1, edge, level, false); put(edgeTuple.Item2, edge, level, false); } } if (!edgeEdgesFirst) { putEdgeEdges(); } } else { // follow links of node: foreach (var edge in Ordered(graph.Edges(item.Node), item.Node)) { put(edge, item.Node, level, true); } } if (false) { DoTrace($"\tyield {item}"); yield return(item); } } }
/// <summary> /// Iterates over all items and links which are connected to each other /// beginning with item start /// items and links are distinct (they dont repeat if there are circles) /// </summary> /// <remarks>the clique containing the start-item, but with multiple egdes allowed</remarks> /// <param name="start"></param> /// <param name="startLevel"></param> /// <returns></returns> public virtual IEnumerable <LevelItem <TItem> > DeepWalk(TItem start, int startLevel, Func <LevelItem <TItem>, bool> predicate, bool breathFirst) { Action <TItem, TItem, int> put = null;; Func <LevelItem <TItem> > get = null; Func <int> loopCount = null; if (breathFirst) { var queue = new Queue <LevelItem <TItem> > (); loopCount = () => queue.Count; put = (node, path, l) => { if (!Visited.Contains(node)) { var item = new LevelItem <TItem> (node, path, l); if (predicate == null || predicate(item)) { queue.Enqueue(item); } Visited.Add(node); } }; get = () => queue.Dequeue(); } else { var stack = new Stack <LevelItem <TItem> > (); loopCount = () => stack.Count; put = (node, path, l) => { if (!Visited.Contains(node)) { var item = new LevelItem <TItem> (node, path, l); if (predicate == null || predicate(item)) { stack.Push(item); } Visited.Add(node); } }; get = () => stack.Pop(); } put(start, default(TItem), startLevel); while (loopCount() > 0) { var item = get(); yield return(item); var level = item.Level + 1; if (item.Node is TEdge) { var edge = (TEdge)item.Node; // follow links of edge: foreach (var edge_edge in graph.Edges(edge)) { put(edge_edge, edge, level); } var adjacent = graph.Adjacent(edge, item.Path); if (adjacent != null) { // follow adjacent of node: put(adjacent, edge, level); } else { put(edge.Root, edge, level); put(edge.Leaf, edge, level); } } else { // follow links of node: foreach (var edge in graph.Edges(item.Node)) { put(edge, item.Node, level); } } } }