private void Dfs(IEdgeWeightedDIgraph g, int v)
{
onStack[v] = true;
marked[v] = true;
foreach (var e in g.Adj(v))
{
int w = e.To;
if (HasCycle())
{
return;
}
else if (!marked[w])
{
edgeTo[w] = e;
Dfs(g, w);
}
else if (onStack[w])
{
cycle = new Stack <IDirectedEdge>();
var x = e;
for (; x.From != w; x = edgeTo[x.From])
{
cycle.Push(x);
}
cycle.Push(x);
}
}
onStack[v] = false;
}
public DijkstraAllPairsSP(IEdgeWeightedDIgraph G)
{
all = new DijkstraSP[G.V];
for (int v = 0; v < G.V; v++)
{
all[v] = new DijkstraSP(G, v);
}
}
public DijkstraSP(IEdgeWeightedDIgraph G, int s) : base(G, s)
{
pq = new IndexMinPQ <double>(G.V);
pq.Insert(s, 0.0);
while (!pq.IsEmpty)
{
Relax(G, pq.DeleteMin());
}
}
public AcyclicSP(IEdgeWeightedDIgraph G, int s) : base(G, s)
{
Topological top = new Topological(G);
foreach (int v in top.Order)
{
Relax(G, v);
}
}
public AbsShortestPath(IEdgeWeightedDIgraph G, int s)
{
edgeTo = new DirectedEdge[G.V];
distTo = new double[G.V];
for (int v = 0; v < G.V; v++)
{
distTo[v] = Double.PositiveInfinity;
}
distTo[s] = 0.0;
}
private void Relax(IEdgeWeightedDIgraph g, int v)
{
foreach (var e in g.Adj(v))
{
int w = e.To;
if (distTo[w] > distTo[v] + e.Weight)
{
distTo[w] = distTo[v] + e.Weight;
edgeTo[w] = e;
}
}
}
public Topological(IEdgeWeightedDIgraph G)
{
IDiGraph g = new DiGraph(G.V);
for (int i = 0; i < G.V; i++)
{
foreach (var e in G.Adj(i))
{
g.AddEdge(e.From, e.To);
}
}
Order = Init(g);
}
private IEnumerable <IDirectedEdge> cycle; //edgeTo中是否含有负权重环
public BellmanFordSP(IEdgeWeightedDIgraph G, int s) : base(G, s)
{
onQ = new bool[G.V];
queue = new Chapter1.Queue <int>();
queue.Enqueue(s);
onQ[s] = true;
while (!queue.IsEmpty && !HasNegativeCycle())
{
int v = queue.Dequeue();
onQ[v] = false;
Relax(G, v);
}
}
public EdgeWeightedCycleFinder(IEdgeWeightedDIgraph G)
{
onStack = new bool[G.V];
edgeTo = new DirectedEdge[G.V];
marked = new bool[G.V];
for (int v = 0; v < G.V; v++)
{
if (!marked[v])
{
Dfs(G, v);
}
}
}
private void Relax(IEdgeWeightedDIgraph g, int v)
{
foreach (var e in g.Adj(v))
{
int w = e.To;
if (distTo[w] > distTo[v] + e.Weight)
{
distTo[w] = distTo[v] + e.Weight;
edgeTo[w] = e;
if (pq.Contains(w))
{
pq.ChangeKey(w, distTo[w]);
}
else
{
pq.Insert(w, distTo[w]);
}
}
}
}
private void Relax(IEdgeWeightedDIgraph g, int v)
{
foreach (var e in g.Adj(v))
{
int w = e.To;
if (distTo[w] > distTo[v] + e.Weight)
{
distTo[w] = distTo[v] + e.Weight;
edgeTo[w] = e;
if (!onQ[w])
{
queue.Enqueue(w);
onQ[w] = true;
}
}
if (cost++ % g.V == 0)
{
FindNegativeCycle();
}
}
}
