public bool BreadthFirstSearch(Node Start)
{
Queue.Enqueue(Start);
VisitedNodes.Add(Start);
for (; Queue.Count > 0;)
{
Start = Queue.Dequeue();
for (int Index = 0; Index < InnerGraph.NumberOfNodes; Index++)
{
if (InnerGraph.SetOfNodes[Start.Index][Index] != null && !VisitedNodes.Contains(InnerGraph.SetOfNodes[Index]))
{
ResultOfSearching.Add(InnerGraph.FindEdge(Start, InnerGraph.SetOfNodes[Index]));
Queue.Enqueue(InnerGraph.SetOfNodes[Index]);
VisitedNodes.Add(InnerGraph.SetOfNodes[Index]);
}
}
}
return(VisitedNodes.Count.Equals(InnerGraph.NumberOfNodes));
}
///
/// bfs var 2
/// searching path to target node from some start node
///
/// <param name="Start"> - first node
/// <param name="Target"> - our scope
/// <param name="Path"> - for our scope
/// <returns></returns>
public bool BreadthFirstSearch(Node Start, Node Target, Node[] Path)
{
Queue.Enqueue(Start);
VisitedNodes.Add(Start);
Path[Start.Index] = Start;
if (VisitedNodes.Contains(Target))
{
return(true);
}
for (; Queue.Count > 0;)
{
Start = Queue.Dequeue();
for (int Index = 0; Index < InnerGraph.QuantityOfNodes; Index++)
{
if (InnerGraph.SetOfNodes[Start.Index][Index] != null && !VisitedNodes.Contains(InnerGraph.SetOfNodes[Index]) && InnerGraph.FindEdge(Start, InnerGraph.SetOfNodes[Index]).Weight > 0)
{
Path[Index] = Start;
Queue.Enqueue(InnerGraph.SetOfNodes[Index]);
VisitedNodes.Add(InnerGraph.SetOfNodes[Index]);
}
}
}
return(VisitedNodes.Contains(Target));
}
public void Move()
{
if (CompletedMoving)
{
return;
}
double prev = 0;
double random = new Random().NextDouble();
foreach (var item in Choices.Where(z => !VisitedNodes.Contains(z.Item2)).OrderByDescending(z => z.Item1))
{
if (random > prev && random < item.Item1 + prev)
{
var transition = item.Item2.Neighbours.GetValueOrDefault(CurrentNode);
LeavePheromone(transition);
VisitedNodes.Add(CurrentNode);
WayPassed += transition.Value;
CurrentNode = item.Item2; //.Neighbours.Where(z => z.Value == transition && z.Key != CurrentNode).First().Key;
RecalculateChoices();
return;
}
prev += item.Item1;
}
VisitedNodes.Add(CurrentNode);
CompletedMoving = true;
}
public bool FindTheShortestPathes(Node Start)
{
ShortestPathes[Start.Index].Weight = 0;
for (int FirstIndex = 0; FirstIndex < InnerGraph.NumberOfNodes - 1; FirstIndex++)
{
Node CurrentNode = new Node {
Weight = Infinity
};
for (int SecondIndex = 0; SecondIndex < InnerGraph.NumberOfNodes; SecondIndex++)
{
if (!VisitedNodes.Contains(ShortestPathes[SecondIndex]) && ShortestPathes[SecondIndex].Weight <= CurrentNode.Weight)
{
CurrentNode = ShortestPathes[SecondIndex];
Index = ShortestPathes[SecondIndex].Index;
}
}
VisitedNodes.Add(ShortestPathes[Index]);
for (int SecondIndex = 0; SecondIndex < InnerGraph.NumberOfNodes; SecondIndex++)
{
if (!VisitedNodes.Contains(ShortestPathes[SecondIndex]) && InnerGraph.SetOfNodes[Index][SecondIndex] != null && !ShortestPathes[Index].Weight.Equals(Infinity) && ShortestPathes[SecondIndex].Weight > ShortestPathes[Index].Weight + InnerGraph.FindEdge(InnerGraph.SetOfNodes[Index], InnerGraph.SetOfNodes[SecondIndex]).Weight)
{
ShortestPathes[SecondIndex].Weight = ShortestPathes[Index].Weight + InnerGraph.FindEdge(InnerGraph.SetOfNodes[Index], InnerGraph.SetOfNodes[SecondIndex]).Weight;
}
}
}
return(InnerGraph.NegativeCycleChecker(ShortestPathes));
}
public bool DijkstraSWSAlgorithm(Node Start)
{
ShortestPath[Start.Index].Weight = 0;
for (int FirstIndex = 0; FirstIndex < InnerGraph.QuantityOfNodes - 1; FirstIndex++)
{
Node CurrentNode = new Node {
Weight = double.PositiveInfinity
};
for (int SecondIndex = 0; SecondIndex < InnerGraph.QuantityOfNodes; SecondIndex++)
{
if (!VisitedNodes.Contains(ShortestPath[SecondIndex]) && ShortestPath[SecondIndex].Weight <= CurrentNode.Weight)
{
CurrentNode = ShortestPath[SecondIndex];
Index = ShortestPath[SecondIndex].Index;
}
}
VisitedNodes.Add(ShortestPath[Index]);
for (int SecondIndex = 0; SecondIndex < InnerGraph.QuantityOfNodes; SecondIndex++)
{
if (!VisitedNodes.Contains(ShortestPath[SecondIndex]) && InnerGraph.SetOfNodes[Index][SecondIndex] != null &&
!ShortestPath[Index].Weight.Equals(double.PositiveInfinity) &&
ShortestPath[SecondIndex].Weight >
ShortestPath[Index].Weight + InnerGraph.FindEdge(InnerGraph.SetOfNodes[Index], InnerGraph.SetOfNodes[SecondIndex]).Weight)
{
ShortestPath[SecondIndex].Weight = ShortestPath[Index].Weight + InnerGraph.FindEdge(InnerGraph.SetOfNodes[Index], InnerGraph.SetOfNodes[SecondIndex]).Weight;
}
}
}
return(InnerGraph.NegativeCycleChecker(ShortestPath));
}
private void CreateMoreAgents()
{
foreach (var connectedNode in CurrentNode.Connections)
{
if (!VisitedNodes.Contains(connectedNode))
{
CreateAgent(connectedNode);
}
}
}
void MarkNodeAsVisisted(Node node)
{
if (!VisitedNodes.Contains(node))
{
VisitedNodes.Enqueue(node);
}
if (UnvisitedNodes.Contains(node))
{
UnvisitedNodes.Remove(node);
}
}
private void PushNeighborsToStack()
{
IEnumerable <T> neighborList = _graph[Current];
foreach (T neighbor in neighborList)
{
if (!VisitedNodes.Contains(neighbor))
{
_pendingSearches.Push(new SearchData(neighbor, _currentSearchData.Level + 1));
}
}
}
private bool DoSearch()
{
AssignCurrentVertex();
if (VisitedNodes.Contains(Current))
{
return(MoveNext());
}
VisitedNodes.Add(Current);
PushNeighborsToStack();
return(true);
}
public bool DepthFirstSearch(Node Start)
{
VisitedNodes.Add(Start);
for (int Index = 0; Index < InnerGraph.NumberOfNodes; Index++)
{
if (InnerGraph.SetOfNodes[Start.Index][Index] != null && !VisitedNodes.Contains(InnerGraph.SetOfNodes[Index]))
{
ResultOfSearching.Add(InnerGraph.FindEdge(Start, InnerGraph.SetOfNodes[Index]));
DepthFirstSearch(InnerGraph.SetOfNodes[Index]);
}
}
return(VisitedNodes.Count.Equals(InnerGraph.NumberOfNodes));
}
protected override bool Skip(Node node)
{
if (base.Skip(node))
{
return(true);
}
var dependencyNode = _dependenciesGraph.AllNodes[node.Id];
foreach (var parent in dependencyNode.Parents)
{
if (!VisitedNodes.Contains(parent.Id))
{
return(true);
}
}
return(false);
}
public bool FindMinimumSpanningTree()
{
VisitedNodes.Add(InnerGraph.SetOfNodes[0]);
for (; VisitedNodes.Count < InnerGraph.NumberOfNodes;)
{
Node Start = new Node();
Node End = new Node();
Edge CurrentEdge = new Edge {
Weight = Infinity
};
for (int Index = 0; Index < InnerGraph.NumberOfNodes; Index++)
{
if (VisitedNodes.Contains(InnerGraph.SetOfNodes[Index]))
{
foreach (Node Inheritor in InnerGraph.SetOfNodes[Index].Inheritors.Where(Node => Node != null && !VisitedNodes.Contains(Node)))
{
if (CurrentEdge.Weight > InnerGraph.FindEdge(InnerGraph.SetOfNodes[Index], Inheritor).Weight)
{
CurrentEdge = InnerGraph.FindEdge(InnerGraph.SetOfNodes[Index], Inheritor);
Start = CurrentEdge[0];
End = CurrentEdge[1];
}
}
}
}
VisitedNodes.Add(End);
MinimumSpanningTree.Add(InnerGraph.FindEdge(Start, End));
}
return(VisitedNodes.Count.Equals(InnerGraph.NumberOfNodes));
}
public bool DepthFirstSearch(Node Start, Node Target)
{
VisitedNodes.Add(Start);
if (VisitedNodes.Contains(Target))
{
return(true);
}
for (int Index = 0; Index < InnerGraph.NumberOfNodes; Index++)
{
if (InnerGraph.SetOfNodes[Start.Index][Index] != null && !VisitedNodes.Contains(InnerGraph.SetOfNodes[Index]))
{
ResultOfSearching.Add(InnerGraph.FindEdge(Start, InnerGraph.SetOfNodes[Index]));
if (DepthFirstSearch(InnerGraph.SetOfNodes[Index], Target))
{
return(true);
}
}
}
return(VisitedNodes.Contains(Target));
}
public bool DepthFirstSearch(Node Start, Node Target, Node[] FoundPath)
{
VisitedNodes.Add(Start);
if (VisitedNodes.Contains(Target))
{
return(true);
}
for (int Index = 0; Index < InnerGraph.NumberOfNodes; Index++)
{
if (InnerGraph.SetOfNodes[Start.Index][Index] != null && !VisitedNodes.Contains(InnerGraph.SetOfNodes[Index]) && InnerGraph.FindEdge(Start, InnerGraph.SetOfNodes[Index]).Weight > 0)
{
FoundPath[Index] = Start;
if (DepthFirstSearch(InnerGraph.SetOfNodes[Index], Target, FoundPath))
{
return(true);
}
}
}
return(VisitedNodes.Contains(Target));
}
private double CalculateChoice(Transition t)
{
return((Math.Pow(Math.Floor(t.Pheromone), Const.A) * Math.Pow(t.Visibility, Const.B)) /
CurrentNode.Neighbours.Where(z => !VisitedNodes.Contains(z.Key)).Sum(s => (Math.Pow(Math.Floor(s.Value.Pheromone), Const.A) * Math.Pow(s.Value.Visibility, Const.B))));
}
