public void Run()
{
const int v = 50;
const int e = 100;
Console.WriteLine("complete graph");
Console.WriteLine(DigraphGenerator.Complete(v));
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("simple");
Console.WriteLine(DigraphGenerator.Simple(v, e));
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("path");
Console.WriteLine(DigraphGenerator.Path(v));
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("cycle");
Console.WriteLine(DigraphGenerator.Cycle(v));
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("Eulierian path");
Console.WriteLine(DigraphGenerator.EulerianPath(v, e));
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("Eulierian cycle");
Console.WriteLine(DigraphGenerator.EulerianCycle(v, e));
Console.WriteLine();
Console.WriteLine("binary tree");
Console.WriteLine(DigraphGenerator.BinaryTree(v));
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("tournament");
Console.WriteLine(DigraphGenerator.Tournament(v));
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("DAG");
Console.WriteLine(DigraphGenerator.Dag(v, e));
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("rooted-in DAG");
Console.WriteLine(DigraphGenerator.RootedInDag(v, e));
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("rooted-out DAG");
Console.WriteLine(DigraphGenerator.RootedOutDag(v, e));
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("rooted-in tree");
Console.WriteLine(DigraphGenerator.RootedInTree(v));
Console.WriteLine("---------------------------------------------------------------");
Console.WriteLine("rooted-out DAG");
Console.WriteLine(DigraphGenerator.RootedOutTree(v));
Console.WriteLine("---------------------------------------------------------------");
Console.ReadLine();
}
public void Run()
{
const int v = 50;
const int e = 100;
// Eulerian cycle
var g1 = DigraphGenerator.EulerianCycle(v, e);
DirectedEulerianPath.UnitTest(g1, "Eulerian cycle");
Console.WriteLine("---------------------------------------------------------------");
// Eulerian path
var g2 = DigraphGenerator.EulerianPath(v, e);
DirectedEulerianPath.UnitTest(g2, "Eulerian path");
Console.WriteLine("---------------------------------------------------------------");
// add one random edge
var g3 = new Digraph(g2);
g3.AddEdge(StdRandom.Uniform(v), StdRandom.Uniform(v));
DirectedEulerianPath.UnitTest(g3, "one random edge added to Eulerian path");
Console.WriteLine("---------------------------------------------------------------");
// self loop
var g4 = new Digraph(v);
var v4 = StdRandom.Uniform(v);
g4.AddEdge(v4, v4);
DirectedEulerianPath.UnitTest(g4, "single self loop");
Console.WriteLine("---------------------------------------------------------------");
// single edge
var g5 = new Digraph(v);
g5.AddEdge(StdRandom.Uniform(v), StdRandom.Uniform(v));
DirectedEulerianPath.UnitTest(g5, "single edge");
Console.WriteLine("---------------------------------------------------------------");
// empty digraph
var g6 = new Digraph(v);
DirectedEulerianPath.UnitTest(g6, "empty digraph");
Console.WriteLine("---------------------------------------------------------------");
// random digraph
var g7 = DigraphGenerator.Simple(v, e);
DirectedEulerianPath.UnitTest(g7, "simple digraph");
Console.WriteLine("---------------------------------------------------------------");
Console.ReadLine();
}
/**
* Unit tests the {@code DirectedEulerianCycle} data type.
*
* @param args the command-line arguments
*/
public static void main(String[] args) {
int V = Integer.parseInt(args[0]);
int E = Integer.parseInt(args[1]);
// Eulerian cycle
Digraph G1 = DigraphGenerator.eulerianCycle(V, E);
unitTest(G1, "Eulerian cycle");
// Eulerian path
Digraph G2 = DigraphGenerator.eulerianPath(V, E);
unitTest(G2, "Eulerian path");
// empty digraph
Digraph G3 = new Digraph(V);
unitTest(G3, "empty digraph");
// self loop
Digraph G4 = new Digraph(V);
int v4 = StdRandom.uniform(V);
G4.addEdge(v4, v4);
unitTest(G4, "single self loop");
// union of two disjoint cycles
Digraph H1 = DigraphGenerator.eulerianCycle(V/2, E/2);
Digraph H2 = DigraphGenerator.eulerianCycle(V - V/2, E - E/2);
int[] perm = new int[V];
for (int i = 0; i < V; i++)
perm[i] = i;
StdRandom.shuffle(perm);
Digraph G5 = new Digraph(V);
for (int v = 0; v < H1.V(); v++)
for (int w : H1.adj(v))
G5.addEdge(perm[v], perm[w]);
for (int v = 0; v < H2.V(); v++)
for (int w : H2.adj(v))
G5.addEdge(perm[V/2 + v], perm[V/2 + w]);
unitTest(G5, "Union of two disjoint cycles");
// random digraph
Digraph G6 = DigraphGenerator.simple(V, E);
unitTest(G6, "simple digraph");
// 4-vertex digraph
Digraph G7 = new Digraph(new In("eulerianD.txt"));
unitTest(G7, "4-vertex Eulerian digraph");
}
/**
* Unit tests the {@code DirectedEulerianPath} data type.
*
* @param args the command-line arguments
*/
public static void main(String[] args) {
int V = Integer.parseInt(args[0]);
int E = Integer.parseInt(args[1]);
// Eulerian cycle
Digraph G1 = DigraphGenerator.eulerianCycle(V, E);
unitTest(G1, "Eulerian cycle");
// Eulerian path
Digraph G2 = DigraphGenerator.eulerianPath(V, E);
unitTest(G2, "Eulerian path");
// add one random edge
Digraph G3 = new Digraph(G2);
G3.addEdge(StdRandom.uniform(V), StdRandom.uniform(V));
unitTest(G3, "one random edge added to Eulerian path");
// self loop
Digraph G4 = new Digraph(V);
int v4 = StdRandom.uniform(V);
G4.addEdge(v4, v4);
unitTest(G4, "single self loop");
// single edge
Digraph G5 = new Digraph(V);
G5.addEdge(StdRandom.uniform(V), StdRandom.uniform(V));
unitTest(G5, "single edge");
// empty digraph
Digraph G6 = new Digraph(V);
unitTest(G6, "empty digraph");
// random digraph
Digraph G7 = DigraphGenerator.simple(V, E);
unitTest(G7, "simple digraph");
// 4-vertex digraph
Digraph G8 = new Digraph(new In("eulerianD.txt"));
unitTest(G8, "4-vertex Eulerian digraph");
}
public void Run()
{
// create random DAG with V vertices and E edges; then add F random edges
const int v = 50;
const int e = 100;
const int f = 0;
var g = DigraphGenerator.Dag(v, e);
// add F extra edges
for (var i = 0; i < f; i++)
{
var ve = StdRandom.Uniform(v);
var we = StdRandom.Uniform(v);
g.AddEdge(ve, we);
}
Console.WriteLine(g);
// find a directed cycle
var topological = new TopologicalX(g);
if (!topological.HasOrder())
{
Console.WriteLine("Not a DAG");
}
// or give topologial sort
else
{
Console.Write("Topological order: ");
foreach (int i in topological.Order())
{
Console.Write($"{i} ");
}
Console.WriteLine();
}
Console.ReadLine();
}
public void Run()
{
// create random DAG with V vertices and E edges; then add F random edges
const int v = 20;
const int e = 30;
const int f = 10;
var digraph = DigraphGenerator.Dag(v, e);
// add F extra edges
for (var i = 0; i < f; i++)
{
var ve = StdRandom.Uniform(v);
var we = StdRandom.Uniform(v);
digraph.AddEdge(ve, we);
}
Console.WriteLine(digraph);
var finder = new DirectedCycleX(digraph);
if (finder.HasCycle())
{
Console.Write("Directed cycle: ");
foreach (int j in finder.Cycle())
{
Console.Write($"{j} ");
}
Console.WriteLine();
}
else
{
Console.WriteLine("No directed cycle");
}
Console.ReadLine();
}
public void Run()
{
const int v = 50;
const int e = 100;
// Eulerian cycle
var g1 = DigraphGenerator.EulerianCycle(v, e);
DirectedEulerianCycle.UnitTest(g1, "Eulerian cycle");
Console.WriteLine("---------------------------------------------------------------");
// Eulerian path
var g2 = DigraphGenerator.EulerianPath(v, e);
DirectedEulerianCycle.UnitTest(g2, "Eulerian path");
Console.WriteLine("---------------------------------------------------------------");
// empty digraph
var g3 = new Digraph(v);
DirectedEulerianCycle.UnitTest(g3, "empty digraph");
Console.WriteLine("---------------------------------------------------------------");
// self loop
var g4 = new Digraph(v);
var v4 = StdRandom.Uniform(v);
g4.AddEdge(v4, v4);
DirectedEulerianCycle.UnitTest(g4, "single self loop");
Console.WriteLine("---------------------------------------------------------------");
// union of two disjoint cycles
var h1 = DigraphGenerator.EulerianCycle(v / 2, e / 2);
var h2 = DigraphGenerator.EulerianCycle(v - v / 2, e - e / 2);
var perm = new int[v];
for (var i = 0; i < v; i++)
{
perm[i] = i;
}
StdRandom.Shuffle(perm);
var g5 = new Digraph(v);
for (var vi = 0; vi < h1.V; vi++)
{
foreach (int w in h1.Adj(vi))
{
g5.AddEdge(perm[vi], perm[w]);
}
}
for (var vi = 0; vi < h2.V; vi++)
{
foreach (int w in h2.Adj(vi))
{
g5.AddEdge(perm[v / 2 + vi], perm[v / 2 + w]);
}
}
DirectedEulerianCycle.UnitTest(g5, "Union of two disjoint cycles");
Console.WriteLine("---------------------------------------------------------------");
// random digraph
var g6 = DigraphGenerator.Simple(v, e);
DirectedEulerianCycle.UnitTest(g6, "simple digraph");
Console.WriteLine("---------------------------------------------------------------");
Console.ReadLine();
}
