private void CalculateDistanceFromStart(int from)
{
for (int i = 0; i < NumberOfNodes; i++)
{
DistanceFromStart[i] = double.MaxValue;
}
int indexToStar = StarIndex[from];
ForwardStarNode tmpNode = null;
for (int i = 0; i + indexToStar < ForwardStar.GetLength(0); ++i)
{
tmpNode = ForwardStar[indexToStar + i];
if (tmpNode.StartNode != from)
{
break;
}
DistanceFromStart[tmpNode.EndNode] = tmpNode.Distance;
}
}
private Queue <int> GetNeighboursIndexes(int vertex)
{
Queue <int> neighbourNodes = new Queue <int>();
ForwardStarNode tmpStarNode = null;
tmpStarNode = ForwardStar[vertex];
if (tmpStarNode != null)
{
while (true)
{
if (tmpStarNode.StartNode != vertex)
{
neighbourNodes.Enqueue(tmpStarNode.StartNode);
}
else
{
neighbourNodes.Enqueue(tmpStarNode.EndNode);
}
if (tmpStarNode.StartNode == vertex)
{
if (tmpStarNode.StartNodeRef == ForwardStar[vertex])
{
break;
}
tmpStarNode = tmpStarNode.StartNodeRef;
}
else
{
if (tmpStarNode.EndNodeRef == ForwardStar[vertex])
{
break;
}
tmpStarNode = tmpStarNode.EndNodeRef;
}
}
}
return(neighbourNodes);
}
public void ReadIncidentEdges(string fileName)
{
string input = "";
double distance = 0;
int startIndex = -1;
int endIndex = -1;
int edgeId = -1;
ForwardStarNode tmpStartNode = null;
ForwardStarNode newNode = null;
ForwardStarNode tmpNode = null;
ForwardStar = new ForwardStarNode[NumberOfNodes];
int iter = 0;
using (var reader = new StreamReader(fileName))
{
string[] splitResult = new string[3];
while ((input = reader.ReadLine()) != null)
{
splitResult = input.Split(" ");
edgeId = Int32.Parse(splitResult[0]);
startIndex = Int32.Parse(splitResult[1]);
endIndex = Int32.Parse(splitResult[2]);
distance = Edges[edgeId];
if (startIndex == endIndex)
{
continue;
}
newNode = new ForwardStarNode {
ID = edgeId, StartNode = startIndex, EndNode = endIndex, Distance = distance
};
tmpStartNode = ForwardStar[startIndex];
if (tmpStartNode == null)
{
ForwardStar[startIndex] = newNode;
newNode.StartNodeRef = newNode;
}
else
{
tmpNode = null;
if (tmpStartNode.StartNode == startIndex)
{
tmpNode = tmpStartNode.StartNodeRef;
}
else
{
tmpNode = tmpStartNode.EndNodeRef;
}
newNode.StartNodeRef = tmpStartNode;
bool found = false;
while (true)
{
if (tmpNode.StartNode == startIndex)
{
if (tmpNode.StartNodeRef == tmpStartNode)
{
tmpNode.StartNodeRef = newNode;
found = true;
break;
}
tmpNode = tmpNode.StartNodeRef;
}
else
{
if (tmpNode.EndNodeRef == tmpStartNode)
{
tmpNode.EndNodeRef = newNode;
found = true;
break;
}
tmpNode = tmpNode.EndNodeRef;
}
}
if (found)
{
}
}
tmpStartNode = ForwardStar[endIndex];
if (tmpStartNode == null)
{
ForwardStar[endIndex] = newNode;
newNode.EndNodeRef = newNode;
}
else
{
tmpNode = null;
if (tmpStartNode.StartNode == endIndex)
{
tmpNode = tmpStartNode.StartNodeRef;
}
else
{
tmpNode = tmpStartNode.EndNodeRef;
}
newNode.EndNodeRef = tmpStartNode;
while (true)
{
if (tmpNode.StartNode == endIndex)
{
if (tmpNode.StartNodeRef == tmpStartNode)
{
tmpNode.StartNodeRef = newNode;
break;
}
tmpNode = tmpNode.StartNodeRef;
}
else
{
if (tmpNode.EndNodeRef == tmpStartNode)
{
tmpNode.EndNodeRef = newNode;
break;
}
tmpNode = tmpNode.EndNodeRef;
}
}
}
/* Console.WriteLine(++iter);
*
* Console.WriteLine(edgeId);*/
}
}
//Console.WriteLine("done");
startIndex = 0;
tmpStartNode = ForwardStar[startIndex];
tmpNode = tmpStartNode;
while (true)
{
//Console.WriteLine(tmpNode.ID);
if (tmpNode.StartNode == startIndex)
{
tmpNode = tmpNode.StartNodeRef;
}
else
{
tmpNode = tmpNode.EndNodeRef;
}
if (tmpNode == tmpStartNode)
{
break;
}
}
}
public bool CalculateShortestPath(int from = 12, int to = 5)
{
Console.WriteLine("Zacinam");
var stopW = new Stopwatch();
bool[] wasVisited = new bool[NumberOfNodes];
List <int> unvisitedList = new List <int>();
List <int> visitedList = new List <int>();
List <ForwardStarNode> neighbourNodes = new List <ForwardStarNode>();
ForwardStarNode tmpStarNode = null;
CalulateEuclidian(to);
for (int i = 0; i < NumberOfNodes; ++i)
{
DistanceFromStart[i] = double.MaxValue;
PreviousVertex[i] = -1;
//unvisitedList.Add(i);
}
DistanceFromStart[from] = 0;
unvisitedList.Add(from);
double actualMinumum;
int tmpIndex = -1;
int actualNode = -1;
double tmpDistance = -1;
bool vertexReached = false;
int removedIndex = -1;
stopW.Start();
while (unvisitedList.Count != 0)
{
actualMinumum = double.MaxValue;
for (int i = 0; i < unvisitedList.Count; i++)
{
tmpIndex = unvisitedList[i];
if (DistanceFromStart[tmpIndex] + EuclidianDistanceToEnd[tmpIndex] < actualMinumum)
{
actualMinumum = DistanceFromStart[tmpIndex] + EuclidianDistanceToEnd[tmpIndex];
actualNode = tmpIndex;
removedIndex = i;
}
}
if (actualNode == to)
{
vertexReached = true;
break;
}
wasVisited[actualNode] = true;
unvisitedList[removedIndex] = unvisitedList[unvisitedList.Count - 1];
unvisitedList.RemoveAt(unvisitedList.Count - 1);
//unvisitedList.RemoveAt(removedIndex);
//unvisitedList.Remove(actualNode);
tmpStarNode = ForwardStar[actualNode];
neighbourNodes.Clear();
if (tmpStarNode != null)
{
while (true)
{
neighbourNodes.Add(tmpStarNode);
if (tmpStarNode.StartNode == actualNode)
{
if (tmpStarNode.StartNodeRef == ForwardStar[actualNode])
{
break;
}
tmpStarNode = tmpStarNode.StartNodeRef;
}
else
{
if (tmpStarNode.EndNodeRef == ForwardStar[actualNode])
{
break;
}
tmpStarNode = tmpStarNode.EndNodeRef;
}
}
}
for (int i = 0; i < neighbourNodes.Count; i++)
{
tmpStarNode = neighbourNodes[i];
tmpIndex = tmpStarNode.StartNode != actualNode ? tmpStarNode.StartNode : tmpStarNode.EndNode;
tmpDistance = DistanceFromStart[actualNode] + tmpStarNode.Distance;
if (tmpDistance < DistanceFromStart[tmpIndex])
{
DistanceFromStart[tmpIndex] = tmpDistance;
PreviousVertex[tmpIndex] = actualNode;
if (!wasVisited[tmpIndex])
{
unvisitedList.Add(tmpIndex);
}
}
}
}
stopW.Stop();
Console.WriteLine(stopW.Elapsed);
ReconstructedPath.Clear();
if (vertexReached)
{
ReconstructedPath.Add(to);
tmpIndex = PreviousVertex[to];
while (tmpIndex != -1)
{
ReconstructedPath.Add(tmpIndex);
tmpIndex = PreviousVertex[tmpIndex];
}
ReconstructedPath.Reverse();
Console.WriteLine(String.Join("-", ReconstructedPath.ToArray()));
Console.WriteLine($"Vzdialenost: {DistanceFromStart[to]}");
}
else
{
Console.WriteLine("Trasa neexistuje");
}
return(vertexReached);
}
