void Dfs(EdgeWeightedDirectedGraph g, int v)
{
onStack[v] = true;
marked[v] = true;
foreach (var i in g.Adj(v))
{
int end = i.End;
if (HasCircle())
{
return;
}
else if (!marked[i.Start])
{
edgeTo[end] = i;
}
else if (onStack[end])
{
circle = new Stack <DirectedEdge>();
DirectedEdge f = i;
while (f.Start != end)
{
circle.Push(f);
f = edgeTo[f.Start];
}
circle.Push(f);
return;
}
}
onStack[v] = false;
}
public DijkstraAllPairShortestPath(EdgeWeightedDirectedGraph graph)
{
all = new DijkstraShortestPath[graph.VertexCount];
for (int i = 0; i < graph.VertexCount; i++)
{
all[i] = new DijkstraShortestPath(graph, i);
}
}
void Relax(EdgeWeightedDirectedGraph graph, int start)
{
foreach (var directedEdge in graph.Adj(start))
{
int end = directedEdge.End;
if (DistTo[end] > DistTo[start] + directedEdge.Weight)
{
DistTo[end] = DistTo[start] + directedEdge.Weight;
EdgeTo[end] = directedEdge;
}
}
}
void Relax(EdgeWeightedDirectedGraph graph, int vertex)
{
foreach (var edge in graph.Adj(vertex))
{
int v2 = edge.End;
if (DistTo[v2] > DistTo[vertex] + edge.Weight)
{
DistTo[v2] = DistTo[vertex] + edge.Weight;
EdgeTo[v2] = edge;
}
}
}
public EdgeWeightedCircleFinder(EdgeWeightedDirectedGraph g)
{
onStack = new bool[g.VertexSize];
edgeTo = new DirectedEdge[g.VertexSize];
marked = new bool[g.VertexSize];
for (int i = 0; i < g.VertexSize; i++)
{
if (!marked[i])
{
Dfs(g, i);
}
}
}
private void FindNegativeCircle()
{
int v = EdgeTo.Length;
EdgeWeightedDirectedGraph spt = new EdgeWeightedDirectedGraph(v);
for (int i = 0; i < v; i++)
{
if (EdgeTo[i] != null)
{
spt.AddEdge(EdgeTo[i]);
}
EdgeWeightedCircleFinder cf = new EdgeWeightedCircleFinder(spt);
Circle = cf.Circle();
}
}
void Relax(EdgeWeightedDirectedGraph graph, int vertex)
{
foreach (var edge in graph.Adj(vertex))
{
int v2 = edge.End;
if (DistTo[v2] > DistTo[vertex] + edge.Weight)
{
DistTo[v2] = DistTo[vertex] + edge.Weight;
EdgeTo[v2] = edge;
if (pq.Contains(v2))
{
pq.Change(v2, DistTo[v2]);
}
pq.Insert(v2, DistTo[v2]);
}
}
}
public DijkstraShortestPath(EdgeWeightedDirectedGraph graph, int start)
{
EdgeTo = new DirectedEdge[graph.VertexCount];
DistTo = new double[graph.VertexCount];
pq = new IndexMinPQ <double>(graph.VertexCount);
for (int i = 0; i < graph.VertexCount; i++)
{
DistTo[i] = double.PositiveInfinity;
DistTo[start] = 0;
pq.Insert(start, 0);
while (!pq.IsEmpty())
{
Relax(graph, pq.DeleteMin());
}
}
}
public AcyclicShortestPath(EdgeWeightedDirectedGraph g, int start)
{
EdgeTo = new DirectedEdge[g.VertexCount];
DistTo = new double[g.VertexCount];
for (int i = 0; i < g.VertexCount; i++)
{
DistTo[i] = double.PositiveInfinity;
}
DistTo[start] = 0;
Topological top = new Topological(g);
foreach (var i in top.Order)
{
Relax(g, i);
}
}
public BellmanFordShortestPath(EdgeWeightedDirectedGraph graph, int start)
{
DistanceTo = new double[graph.VertexCount];
EdgeTo = new DirectedEdge[graph.VertexCount];
OnQueue = new bool[graph.VertexCount];
Queue = new Queue <int>();
for (int i = 0; i < graph.VertexCount; i++)
{
DistanceTo[i] = double.PositiveInfinity;
}
DistanceTo[start] = 0;
OnQueue[start] = true;
while (Queue.Count != 0)
{
int v = Queue.Dequeue();
OnQueue[v] = false;
Relax(graph, v);
}
}
public void Relax(EdgeWeightedDirectedGraph graph, int v)
{
foreach (var edge in graph.Adj(v))
{
int end = edge.End;
if (DistanceTo[end] > DistanceTo[v] + edge.Weight)
{
DistanceTo[end] = DistanceTo[v] + edge.Weight;
EdgeTo[end] = edge;
if (!OnQueue[end])
{
Queue.Enqueue(end);
OnQueue[end] = true;
}
}
if (Cost++ % graph.VertexCount == 0)
{
FindNegativeCircle();
}
}
}
