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);
}
}
}
}
