private void dfs(EdgeWeightedDigraph G, int v)
{
pre.Enqueue(v);
marked[v] = true;
foreach (var w in G.Adj(v))
if (!marked[w.from])
dfs(G, w.from);
post.Enqueue(v);
reversePost.Push(v);
}
public CPM(int N, List <string> edgeText)
{
var g = new EdgeWeightedDigraph(2 * N + 2);
int s = 2 * N, t = 2 * N + 1;
for (int i = 0; i < N; i++)
{
var e = edgeText[i].Split(' ');
double duration = Convert.ToDouble(e[0]);
g.AddEdge(new DirectedEdge(i, i + N, duration));
g.AddEdge(new DirectedEdge(s, i, 0.0));
g.AddEdge(new DirectedEdge(i + N, t, 0.0));
for (int j = 1; j < e.Length; j++)
{
int successor = Convert.ToInt32(e[j]);
g.AddEdge(new DirectedEdge(i + N, successor, 0.0));
}
}
AcylicSP acy = new AcylicSP(g, s, AcylicSP.PathType.Lagrest);
Console.WriteLine("start\ttimes");
for (int i = 0; i < N; i++)
{
Console.WriteLine($"{i}\t{acy.DistTo[i]}");
}
Console.WriteLine($"Total Times:{acy.DistTo[t]}");
}
public DijkstraAllPairsSP(EdgeWeightedDigraph G)
{
all = new DijkstraSP[G.V];
for (int v = 0; v < G.V; v++)
{
all[v] = new DijkstraSP(G, v);
}
}
private bool[] onStack; // vertices on recursive call stack
#endregion Fields
#region Constructors
public DirectedCycle(EdgeWeightedDigraph G)
{
onStack = new bool[G.V];
edgeTo = new int[G.V];
marked = new bool[G.V];
for (int v = 0; v < G.V; v++)
if (!marked[v])
dfs(G, v);
}
private IEnumerable<int> order; // topological order
#endregion Fields
#region Constructors
public Topological(EdgeWeightedDigraph G)
{
DirectedCycle cyclefinder = new DirectedCycle(G);
if (!cyclefinder.hasCycle())
{
DepthFirstOrder dfs = new DepthFirstOrder(G);
order = dfs.ReversePost();
}
}
private IEnumerable <int> order; // topological order
public Topological(EdgeWeightedDigraph G)
{
DirectedCycle cyclefinder = new DirectedCycle(G);
if (!cyclefinder.hasCycle())
{
DepthFirstOrder dfs = new DepthFirstOrder(G);
order = dfs.ReversePost();
}
}
private Stack<int> reversePost; // vertices in reverse postorder
#endregion Fields
#region Constructors
public DepthFirstOrder(EdgeWeightedDigraph G)
{
pre = new Queue<int>();
post = new Queue<int>();
reversePost = new Stack<int>();
marked = new bool[G.V];
for (int v = 0; v < G.V; v++)
if (!marked[v])
dfs(G, v);
}
private void findNegativeCycle()
{
int V = edgeTo.Length;
EdgeWeightedDigraph spt;
spt = new EdgeWeightedDigraph(V);
for (int v = 0; v < V; v++)
if (edgeTo[v] != null)
spt.addEdge(edgeTo[v]);
DirectedCycle cf = new DirectedCycle(spt);
cycle = cf.Cycle();
}
public AcyclicSP(EdgeWeightedDigraph 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;
Topological top = new Topological(G);
foreach (int v in top.Order)
relax(G, v);
}
public DijkstraSP(EdgeWeightedDigraph G, int s)
{
edgeTo = new DirectedEdge[G.V];
distTo = new double[G.V];
pq = new IndexPriorityQueue<double>(G.V);
for (int v = 0; v < G.V; v++)
distTo[v] = Double.PositiveInfinity;
distTo[s] = 0.0;
pq.Insert(s, 0.0);
while (!pq.isEmpty())
relax(G, pq.Del());
}
private void relax(EdgeWeightedDigraph G, int v)
{
foreach (DirectedEdge 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;
}
}
}
private void relax(EdgeWeightedDigraph G, int v)
{
foreach (DirectedEdge 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 EdgeWeightedCycleFinder(EdgeWeightedDigraph 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 bool[] onStack; // vertices on recursive call stack
public DirectedCycle(EdgeWeightedDigraph G)
{
onStack = new bool[G.V];
edgeTo = new int[G.V];
marked = new bool[G.V];
for (int v = 0; v < G.V; v++)
{
if (!marked[v])
{
dfs(G, v);
}
}
}
public DepthFirstOrder(EdgeWeightedDigraph dg)
{
preQueue = new Queue <int>();
postQueue = new Queue <int>();
reversePost = new Stack <int>();
marked = new bool[dg.V];
for (int s = 0; s < dg.V; s++)
{
if (!marked[s])
{
Dfs(dg, s);
}
}
}
private void dfs(EdgeWeightedDigraph G, int v)
{
pre.Enqueue(v);
marked[v] = true;
foreach (var w in G.Adj(v))
{
if (!marked[w.from])
{
dfs(G, w.from);
}
}
post.Enqueue(v);
reversePost.Push(v);
}
private Stack <int> reversePost; // vertices in reverse postorder
public DepthFirstOrder(EdgeWeightedDigraph G)
{
pre = new Queue <int>();
post = new Queue <int>();
reversePost = new Stack <int>();
marked = new bool[G.V];
for (int v = 0; v < G.V; v++)
{
if (!marked[v])
{
dfs(G, v);
}
}
}
public DijkstraSP(EdgeWeightedDigraph g, int s)
{
_edgeTo = new DirectedEdge[g.V];
_distTo = new double[g.V];
_pq = new IndexMinPQ <double>(g.V * g.V);
for (int i = 0; i < g.V; i++)
{
_distTo[i] = double.PositiveInfinity;
}
_distTo[s] = 0;
_pq.Insert(s, 0);
while (_pq.Count > 0)
{
Relax(g, _pq.DelMin());
}
}
public static void Filling(this EdgeWeightedDigraph ewg, int count)
{
for (int i = 0; i < count - 1; i++)
{
int k = i + 1;
double weight = (i + k) * (double)count / 100;
ewg.addEdge(new DirectedEdge(i, i + 1, weight));
}
for (int i = 0; i < count - 2; i++)
{
int k = i + 2;
double weight = (i + k) * (double)count / 100;
ewg.addEdge(new DirectedEdge(i, i + 2, weight));
}
}
public DijkstraSP(EdgeWeightedDigraph G, int s)
{
edgeTo = new DirectedEdge[G.V];
distTo = new double[G.V];
pq = new IndexPriorityQueue <double>(G.V);
for (int v = 0; v < G.V; v++)
{
distTo[v] = Double.PositiveInfinity;
}
distTo[s] = 0.0;
pq.Insert(s, 0.0);
while (!pq.isEmpty())
{
relax(G, pq.Del());
}
}
public AcyclicSP(EdgeWeightedDigraph 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;
Topological top = new Topological(G);
foreach (int v in top.Order)
{
relax(G, v);
}
}
private void FindNegativeCycle()
{
int v = _edgeTo.Length;
EdgeWeightedDigraph spt = new EdgeWeightedDigraph(v);
for (int s = 0; s < v; s++)
{
if (_edgeTo[s] != null)
{
spt.AddEdge(_edgeTo[s]);
}
}
EdgeWeightedCycleFinder finder = new EdgeWeightedCycleFinder(spt);
_cycle = finder.Cycle;
}
private void findNegativeCycle()
{
int V = edgeTo.Length;
EdgeWeightedDigraph spt;
spt = new EdgeWeightedDigraph(V);
for (int v = 0; v < V; v++)
{
if (edgeTo[v] != null)
{
spt.addEdge(edgeTo[v]);
}
}
DirectedCycle cf = new DirectedCycle(spt);
cycle = cf.Cycle();
}
private void Dfs(EdgeWeightedDigraph dg, int v)
{
preQueue.Enqueue(v);
marked[v] = true;
foreach (var e in dg.Adj(v))
{
int w = e.To;
if (!marked[w])
{
Dfs(dg, w);
}
}
postQueue.Enqueue(v);
reversePost.Push(v);
}
private Queue<int> queue; // vertices being relaxed
#endregion Fields
#region Constructors
public BellmanFordSP(EdgeWeightedDigraph G, int s)
{
distTo = new double[G.V];
edgeTo = new DirectedEdge[G.V];
onQ = new bool[G.V];
queue = new Queue<int>();
for (int v = 0; v < G.V; v++)
distTo[v] = double.PositiveInfinity;
distTo[s] = 0.0;
queue.Enqueue(s);
onQ[s] = true;
while (queue.Count!=0 && !this.hasNegativeCycle())
{
int v = queue.Dequeue();
onQ[v] = false;
relax(G,v);
}
}
private void relax(EdgeWeightedDigraph G, int v)
{
foreach (DirectedEdge 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();
}
}
public static void ShowPathsByAcyclic(this EdgeWeightedDigraph ewg)
{
for (int i = 0; i < ewg.V; i++)
{
AcyclicSP dapsp = new AcyclicSP(ewg, i);
for (int j = 0; j < ewg.V; j++)
{
if (dapsp.hasPathTo(j) && i != j)
{
Console.WriteLine("{0}-{1} : ", i, j);
foreach (var v in dapsp.pathTo(j))
{
Console.WriteLine(v);
}
Console.WriteLine("------------------");
}
}
}
}
private IEnumerable <DirectedEdge> cycle; // negative cycle in edgeTo[]?
public BellmanFordSP(EdgeWeightedDigraph G, int s)
{
distTo = new double[G.V];
edgeTo = new DirectedEdge[G.V];
onQ = new bool[G.V];
queue = new Queue <int>();
for (int v = 0; v < G.V; v++)
{
distTo[v] = double.PositiveInfinity;
}
distTo[s] = 0.0;
queue.Enqueue(s);
onQ[s] = true;
while (queue.Count != 0 && !this.hasNegativeCycle())
{
int v = queue.Dequeue();
onQ[v] = false;
relax(G, v);
}
}
private void relax(EdgeWeightedDigraph G, int v)
{
foreach (DirectedEdge 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.change(w, distTo[w]);
}
else
{
pq.Insert(w, distTo[w]);
}
}
}
}
public BellmanFordSP(EdgeWeightedDigraph g, int s)
{
_distTo = new double[g.V];
_edgeTo = new DirectedEdge[g.V];
_onQueue = new bool[g.V];
_queue = new Queue <int>();
for (int i = 0; i < g.V; i++)
{
_distTo[i] = double.PositiveInfinity;
}
_distTo[s] = 0d;
_queue.Enqueue(s);
_onQueue[s] = true;
while (_queue.Count > 0 && !HasNegativeCycle())
{
int v = _queue.Dequeue();
_onQueue[v] = false;
Relax(g, v);
}
}
public static void ShowPathsByDijkstra(this EdgeWeightedDigraph ewg)
{
DijkstraAllPairsSP dapsp = new DijkstraAllPairsSP(ewg);
for (int i = 0; i < ewg.V; i++)
{
for (int j = 0; j < ewg.V; j++)
{
if (dapsp.hasPathTo(i, j) && i != j)
{
Console.WriteLine("{0}-{1} : ", i, j);
foreach (var v in dapsp.path(i, j))
{
Console.WriteLine(v);
}
Console.WriteLine("------------------");
}
}
}
}
public void Relax(EdgeWeightedDigraph g, int v)
{
foreach (DirectedEdge 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.Change(w, _distTo[w]);
}
else
{
_pq.Insert(w, _distTo[w]);
}
}
}
}
private void relax(EdgeWeightedDigraph G, int v)
{
foreach (DirectedEdge 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();
}
}
}
private static void Main(string[] args)
{
EdgeWeightedDigraph ewg = new EdgeWeightedDigraph(5);
ewg.Filling(5);
ewg.ShowEdges();
Console.WriteLine();
/*Console.WriteLine("Dijkstra Paths :");
* ewg.ShowPathsByDijkstra();
* Console.WriteLine();*/
/*Console.WriteLine("Acyclic Paths");
* ewg.ShowPathsByAcyclic();
* Console.WriteLine();*/
Console.WriteLine("BellmanFord Paths");
ewg.ShowPathsByBellmanFord();
Console.WriteLine();
Console.ReadKey();
}
private void dfs(EdgeWeightedDigraph G, int v)
{
onStack[v] = true;
marked[v] = true;
foreach (var w in G.Adj(v))
if (this.hasCycle())
return;
else if (!marked[w.to])
{
edgeTo[w.to] = v;
dfs(G, w.to);
}
else if (onStack[w.to])
{
cycle = new Stack<DirectedEdge>();
for (int x = v; x != w.to; x = edgeTo[x])
//cycle.Push(x);
cycle.Push(w);
//cycle.Push(v);
}
onStack[v] = false;
}
private void Relax(EdgeWeightedDigraph 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 (!_onQueue[w])
{
_queue.Enqueue(w);
_onQueue[w] = true;
}
}
if (_cost++ % g.V == 0)
{
FindNegativeCycle();
}
}
}
public DijkstraAllPairsSP(EdgeWeightedDigraph G)
{
all = new DijkstraSP[G.V];
for (int v = 0; v < G.V; v++)
all[v] = new DijkstraSP(G, v);
}
private void relax(EdgeWeightedDigraph G, int v)
{
foreach (DirectedEdge 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.change(w, distTo[w]);
else pq.Insert(w, distTo[w]);
}
}
}
static void Main(string[] args)
{
EdgeWeightedDigraph g = new EdgeWeightedDigraph(8);
g.AddEdge(new DirectedEdge(4, 5, 0.35));
g.AddEdge(new DirectedEdge(5, 4, 0.35));
g.AddEdge(new DirectedEdge(4, 7, 0.37));
g.AddEdge(new DirectedEdge(5, 7, 0.28));
g.AddEdge(new DirectedEdge(7, 5, 0.28));
g.AddEdge(new DirectedEdge(5, 1, 0.32));
g.AddEdge(new DirectedEdge(0, 4, 0.38));
g.AddEdge(new DirectedEdge(0, 2, 0.26));
g.AddEdge(new DirectedEdge(7, 3, 0.39));
g.AddEdge(new DirectedEdge(1, 3, 0.29));
g.AddEdge(new DirectedEdge(2, 7, 0.34));
g.AddEdge(new DirectedEdge(6, 2, 0.40));
g.AddEdge(new DirectedEdge(3, 6, 0.52));
g.AddEdge(new DirectedEdge(6, 0, 0.58));
g.AddEdge(new DirectedEdge(6, 4, 0.93));
DijkstraSP dsp = new DijkstraSP(g, 0);
Console.WriteLine("DijkstraSP");
foreach (var e in dsp.PathTo(6))
{
Console.WriteLine($"{e} ");
}
var edges = new List <string>()
{
"41 1 7 9",
"51 2",
"50",
"36",
"38",
"45",
"21 3 8",
"32 3 8",
"32 2",
"29 4 6"
};
var cpm = new CPM(10, edges);
var dedges = new List <string>()
{
"4 5 0.35",
"5 4 -0.66",
"4 7 0.37",
"5 7 0.28",
"7 5 0.28",
"5 1 0.32",
"0 4 0.38",
"0 2 0.26",
"7 3 0.39",
"1 3 0.29",
"2 7 0.34",
"6 2 0.40",
"3 6 0.52",
"6 0 0.58",
"6 4 0.93"
};
int N = 8;
EdgeWeightedDigraph spt = new EdgeWeightedDigraph(N);
for (int i = 0; i < N; i++)
{
var e = dedges[i].Split(' ');
double duration = Convert.ToDouble(e[e.Length - 1]);
int v = Convert.ToInt32(e[0]);
int w = Convert.ToInt32(e[1]);
spt.AddEdge(new DirectedEdge(v, w, duration));
}
BellmanFordSP bsp = new BellmanFordSP(spt, 0);
Console.WriteLine(bsp.HasNegativeCycle());
Console.WriteLine("Hello World!");
}
public Topological(EdgeWeightedDigraph dg)
{
DepthFirstOrder dfo = new DepthFirstOrder(dg);
_order = dfo.Reverse;
}
private static void Main(string[] args)
{
EdgeWeightedDigraph ewg = new EdgeWeightedDigraph(5);
ewg.Filling(5);
ewg.ShowEdges();
Console.WriteLine();
/*Console.WriteLine("Dijkstra Paths :");
ewg.ShowPathsByDijkstra();
Console.WriteLine();*/
/*Console.WriteLine("Acyclic Paths");
ewg.ShowPathsByAcyclic();
Console.WriteLine();*/
Console.WriteLine("BellmanFord Paths");
ewg.ShowPathsByBellmanFord();
Console.WriteLine();
Console.ReadKey();
}
public static bool hasCycles(this EdgeWeightedDigraph ewg)
{
DirectedCycle dc = new DirectedCycle(ewg);
return(dc.hasCycle());
}
