public void TestCase4ShouldPass()
{
//var textreader = new StreamReader(typeof(PrimTests).Assembly.GetManifestResourceStream("Tests.largeEWG.txt"));
var result = Kruskal.Run(ReadLines("c:\\work\\largeEWG.txt"));//GetLines(textreader));
Assert.AreEqual(new Decimal(647.66306955), result);
}
private void btnChayTuDong_Click(object sender, EventArgs e)
{
if (Check())
{
// kiểm tra time delay
int timeDelay = 0;
try
{
timeDelay = Int32.Parse(txtDelay.Text);
if (timeDelay < 0)
{
MessageBox.Show("Time delay phải là số nguyên dương", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
catch
{
MessageBox.Show("Time delay phải là số nguyên dương", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
btnTamDung.Enabled = true;
btnKetThuc.Enabled = true;
btnBatDauChayTungBuoc.Enabled = false;
listDoThi = Kruskal.Run(Data.Data.graph_Kruskal);
index = 0;
timer.Enabled = true;
timer.Interval = timeDelay;
timer.Start();
return;
}
}
public void KruskalWithGraph()
{
char[] vertices = new char[] { 'a', 'b', 'c', 'd', 'e', 'f' };
List <(int, char, char)> actualResult = new List <(int, char, char)>();
actualResult.Add((1, 'a', 'b'));
actualResult.Add((1, 'c', 'd'));
actualResult.Add((2, 'b', 'd'));
Kruskal <char> kruskal = new Kruskal <char>(vertices);
kruskal.AddEdges(1, ('a', 'b'));
kruskal.AddEdges(5, ('a', 'c'));
kruskal.AddEdges(3, ('a', 'd'));
kruskal.AddEdges(4, ('b', 'c'));
kruskal.AddEdges(2, ('b', 'd'));
kruskal.AddEdges(1, ('c', 'd'));
List <QueueItem <(char u, char v)> > result = kruskal.ExecuteKruskal();
Assert.Equal(3, result.Count);
for (int i = 0; i < result.Count; i++)
{
Assert.Equal(actualResult[i], (result[i].Priority, result[i].Data.u, result[i].Data.v));
}
}
void Tree()
{
int vNum = roomLayer.Objects.OfType <Room>().Count(x => x.isMainRoom);
var kruskal = new Kruskal(vNum, graphLayer.Objects.OfType <Line>());
LineList = kruskal.Compute();
var unSelectedLines = new List <Line>();
foreach (Line line in graphLayer.Objects.OfType <Line>().Where(x => !(LineList.Any(x.Equals))))
{
graphLayer.RemoveObject(line);
unSelectedLines.Add(line);
}
foreach (Line line in new List <Line>(unSelectedLines)
.OrderBy(i => Guid.NewGuid())
.Take((int)(unSelectedLines.Count() * 0.1))
)
{
graphLayer.AddObject(line);
unSelectedLines.Remove(line);
}
foreach (Line line in unSelectedLines)
{
line.Dispose();
}
}
void RegenerateLines()
{
foreach (var line in lines)
{
Destroy(line);
}
lines.Clear();
var triangles = BowyerWatson.Triangulate(points);
var graph = new HashSet <Edge>();
foreach (var triangle in triangles)
{
graph.UnionWith(triangle.edges);
}
var tree = Kruskal.MinimumSpanningTree(graph);
foreach (var edge in tree)
{
Vector3 p1 = new Vector3(edge.a.x, edge.a.y);
Vector3 p2 = new Vector3(edge.b.x, edge.b.y);
var line = new GameObject();
var lineRenderer = line.AddComponent <LineRenderer>();
lineRenderer.material = lineMaterial;
lineRenderer.SetPosition(0, p1);
lineRenderer.SetPosition(1, p2);
lines.Add(line);
}
}
public void Solve_adjGraph1_CorrectAnswer()
{
/* Graph
* (1)
* / \
* 3 2
* / \
* (0)--2--(2)
*/
var adj = new float[, ]
{
{ 0, 3, 2 },
{ 3, 0, 2 },
{ 2, 2, 0 },
};
/* Expected MST
* (1)
* \
* 2
* \
* (0)--2--(2)
*/
var expected = new[, ]
{
{ float.PositiveInfinity, float.PositiveInfinity, 2 },
{ float.PositiveInfinity, float.PositiveInfinity, 2 },
{ 2, 2, float.PositiveInfinity },
};
Kruskal.Solve(adj).Cast <float>().SequenceEqual(expected.Cast <float>()).Should().BeTrue();
}
private void btnKruskal_Click(object sender, EventArgs e)
{
this.ResetResolucion();
this.resolucion = Kruskal.Ejecutar(g);
this.Dibujar();
this.ImprimirResultado();
}
private void btnBatDauChayTungBuoc_Click(object sender, EventArgs e)
{
if (btnBatDauChayTungBuoc.Text == "Bắt đầu chạy từng bước")
{
if (Check())
{
listDoThi = Kruskal.Run(Data.Data.graph_Kruskal);
index = 0;
HienThiDoThi();
btnChayTuDong.Enabled = false;
btnPrev.Enabled = true;
btnNext.Enabled = true;
btnStart.Enabled = true;
btnEnd.Enabled = true;
btnBatDauChayTungBuoc.Text = "Kết thúc chạy từng bước";
}
return;
}
if (btnBatDauChayTungBuoc.Text == "Kết thúc chạy từng bước")
{
btnBatDauChayTungBuoc.Text = "Bắt đầu chạy từng bước";
btnChayTuDong.Enabled = true;
btnPrev.Enabled = false;
btnNext.Enabled = false;
btnStart.Enabled = false;
btnEnd.Enabled = false;
return;
}
}
private void TestMstAlgorithm(IWeightedGraph <int, double> graph, double expectedMstWeight, double precision, ALGORITHM algorithm)
{
// Build minimum spanning tree with algorithm to test
IWeightedGraph <int, double> msp;
switch (algorithm)
{
case ALGORITHM.KRUSKAL:
msp = Kruskal.FindMinimumSpanningTree(graph);
break;
case ALGORITHM.PRIM:
msp = Prim.FindMinimumSpanningTree(graph, 0, double.MaxValue);
break;
default:
throw new NotImplementedException($"No minimum spanning tree test implemented for algorithm {algorithm.ToString()}.");
}
// Check that all verteces are included
Assert.AreEqual(graph.VertexCount, msp.VertexCount);
// Count edges and compute total weight
IEnumerable <IWeightedEdge <int, double> > edges = msp.GetAllEdges();
int edgeCount = edges.Count();
double mspWeight = edges.Sum(e => e.Weight);
// Check edge count
Assert.AreEqual(graph.VertexCount - 1, edgeCount);
// Check that the total weight is as expected
AssertDoublesNearlyEqual(expectedMstWeight, mspWeight, precision);
}
static void Main(string[] args)
{
Kruskal graph = new Kruskal();
int numEdges, numVertices = 0;
try
{
StreamReader sr = new StreamReader("inputs.txt");
string veri = sr.ReadToEnd();
veri = veri.Replace("\r\n", " ");
string[] veriler = veri.Split(' ');
numVertices = Convert.ToInt32(veriler[0]);
numEdges = Convert.ToInt32(veriler[1]);
sr.Close();
for (int i = 2; i < veriler.Length; i += 3)
{
graph.AddEdge(Convert.ToInt32(veriler[i]), Convert.ToInt32(veriler[i + 1]), Convert.ToInt32(veriler[i + 2]));
}
}
catch (IOException e)
{
Console.WriteLine("Error - the file could not be read");
Console.WriteLine(e.Message);
}
graph.SortGraph();
graph.Write();
Console.WriteLine();
Console.WriteLine("----------------------------- Kruskal Minimum Spanning Tree -----------------------------");
Console.WriteLine();
graph.MST(numVertices);
Console.ReadKey();
}
public void DeberiaRetornarListaVaciaSiElGrafoEstaVacio()
{
var g = new Grafo();
var l = Kruskal.Ejecutar(g);
Assert.IsNotNull(l);
Assert.AreEqual(0, l.Count);
}
//Kruskal
private void RibbonButton_Click_4(object sender, RoutedEventArgs e)
{
Kruskal k = new Kruskal(leitor.Customgrafo);
k.Kruskal_();
GraphControl.Graph = k.toGraphSharp();
UpdateStatusBar();
}
async void _Kruskal()
{
Logs.Add(new LogViewModel("KruskalClicked"));
await exactStop();
var results = Kruskal.Run(_graph);
changeColor(results, Colors.Red);
}
private static int RunKruskal(Vertex[] vertices)
{
foreach (Vertex v in vertices)
{
v.Reset();
}
return(Kruskal.Run(vertices).Sum(e => e.Weight));
}
public void KruskalWithEmptyGraph()
{
char[] vertices = new char[] {};
Kruskal <char> kruskal = new Kruskal <char>(vertices);
List <QueueItem <(char u, char v)> > result = kruskal.ExecuteKruskal();
Assert.Equal(0, result.Count);
}
public static void PerformSingleKruskal(string FileName)
{
string input = File.ReadAllText(FileName);
Kruskal k = new Kruskal(input);
k.BuildSpanningTree();
Console.WriteLine("Cost: " + k.Cost);
// k.DisplayInfo();
}
static void Main(string[] args)
{
var graph = new Graph <int>();
var nodes = new List <Node <int> >();
var edges = new List <Edge <int> >();
while (true)
{
Console.Write("Додати нову вершину?\n-> ");
if (Console.ReadLine() == "y")
{
nodes.Add(new Node <int>()
{
Value = 1 + nodes.Count
});
Console.WriteLine($"Додали вершину {nodes.Last().ToString()}");
}
else
{
break;
}
}
while (true)
{
Console.Write("Додати нове ребро?\n-> ");
if (Console.ReadLine() == "y")
{
Console.Write("Номер першої вершини\n-> ");
int node1Num = Int32.Parse(Console.ReadLine());
Console.Write("Номер другої вершини\n-> ");
int node2Num = Int32.Parse(Console.ReadLine());
Console.Write("Вага ребра\n-> ");
int weight = Int32.Parse(Console.ReadLine());
edges.Add(new Edge <int>()
{
Node1 = nodes[node1Num - 1],
Node2 = nodes[node2Num - 1],
Weight = weight
});
}
else
{
break;
}
}
graph.Nodes = nodes;
graph.Edges = edges;
Console.WriteLine("Алгоритм Краскала");
var res = Kruskal.Run(graph);
ShowCarcass(res);
Console.WriteLine("Алгоритм Прима");
var resprim = Prim.Run(graph);
ShowCarcass(resprim);
Console.ReadLine();
}
public void Test()
{
var g = GraphGenerator.edgeWeightedGraph();
var mst = new Kruskal(g);
foreach (var e in mst.MST)
{
console.WriteLine(e.ToString());
}
}
public void Ordinal()
{
var ks = new Kruskal();
ks.AddPath(0, 1, 300);
ks.AddPath(1, 2, 50);
ks.AddPath(0, 2, 351);
ks.AddPath(1, 3, 90);
ks.AddPath(2, 3, 25);
Assert.AreEqual(375, ks.GetCost());
}
public void TestCase2ShouldPass()
{
var results = new List <decimal>();
for (int i = 0; i < 100; i++)
{
var result = Kruskal.Run(File.ReadLines("c:\\temp\\homework2_1_2_test2.txt"));
results.Add(result);
}
var minresult = results.Min();
Assert.AreEqual(new Decimal(10.46351), minresult);
}
public void ValidateGraph_adjDirectedGraph_ThrowsException()
{
// Nodes 1 and 2 have a directed edge
var adj = new[, ]
{
{ 0, float.PositiveInfinity, 4, float.PositiveInfinity, float.PositiveInfinity },
{ 3, 0, 5, 6, 2 },
{ 4, 5, 0, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, 6, float.PositiveInfinity, 0, float.PositiveInfinity },
{ float.PositiveInfinity, 2, float.PositiveInfinity, float.PositiveInfinity, 0 },
};
Assert.Throws <ArgumentException>(() => Kruskal.Solve(adj), "adj must be symmetric!");
}
public void TestCase3ShouldPass()
{
var results = new List <decimal>();
for (int i = 0; i < 100; i++)
{
var result = Kruskal.Run(File.ReadLines("c:\\temp\\tinyEWG.txt"));
Console.WriteLine("итого: {0}", result);
results.Add(result);
}
var minresult = results.Min();
Assert.AreEqual(new decimal(1.81), minresult);
}
public static void ThreadTaskWithThread(Object Args)
{
object[] lArgs = (object[])Args;
int ThreadNum = (int)(lArgs[0]);
string[] lines = (string[])(lArgs[1]);
buffer[ThreadNum] = new Kruskal(lines);
buffer[ThreadNum].BuildSpanningTree();
// buffer[ThreadNum].DisplayInfo();
}
public void Solve_ListGraph1_CorrectAnswer()
{
/* Graph
* (1)
* / \
* 3 2
* / \
* (0)--2--(2)
*/
var adj = new[]
{
new Dictionary <int, float> {
{ 1, 3 }, { 2, 2 }
},
new Dictionary <int, float> {
{ 0, 3 }, { 2, 2 }
},
new Dictionary <int, float> {
{ 0, 2 }, { 1, 2 }
},
};
/* Expected MST
* (1)
* \
* 2
* \
* (0)--2--(2)
*/
var expected = new[]
{
new Dictionary <int, float> {
{ 2, 2 }
},
new Dictionary <int, float> {
{ 2, 2 }
},
new Dictionary <int, float> {
{ 0, 2 }, { 1, 2 }
},
};
var res = Kruskal.Solve(adj);
for (var i = 0; i < adj.Length; i++)
{
res[i].OrderBy(edge => edge.Key).SequenceEqual(expected[i]).Should().BeTrue();
}
}
public void Solve_adjGraph4_CorrectAnswer()
{
/* Graph
* (0)--7--(1)--8--(2)
* \ / \ /
* 5 9 7 5
* \ / \ /
* (3)--15-(4)
* \ / \
* 6 8 9
* \ / \
* (5)--11-(6)
*/
var adj = new[, ]
{
{ 0, 7, float.PositiveInfinity, 5, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
{ 7, 0, 8, 9, 7, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, 8, 0, float.PositiveInfinity, 5, float.PositiveInfinity, float.PositiveInfinity },
{ 5, 9, float.PositiveInfinity, 0, 15, 6, float.PositiveInfinity },
{ float.PositiveInfinity, 7, 5, 15, 0, 8, 9 },
{ float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 6, 8, 0, 11 },
{ float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 9, 11, 0 },
};
/* Expected MST
* (0)--7--(1) (2)
* \ \ /
* 5 7 5
* \ \ /
* (3) (4)
* \ \
* 6 9
* \ \
* (5) (6)
*/
var expected = new[, ]
{
{ float.PositiveInfinity, 7, float.PositiveInfinity, 5, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
{ 7, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 7, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 5, float.PositiveInfinity, float.PositiveInfinity },
{ 5, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 6, float.PositiveInfinity },
{ float.PositiveInfinity, 7, 5, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 9 },
{ float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 6, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 9, float.PositiveInfinity, float.PositiveInfinity },
};
Kruskal.Solve(adj).Cast <float>().SequenceEqual(expected.Cast <float>()).Should().BeTrue();
}
public void Solve_adjGraph6_CorrectAnswer()
{
/* Graph
* (0)--7--(1) (2)
* \ / /|
* 5 9 5 |
* \ / / |
* (3) (4) 2
* / \ |
* 8 9 |
* / \|
* (5)--11-(6)
*/
var adj = new[, ]
{
{ 0, 7, float.PositiveInfinity, 5, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
{ 7, 0, float.PositiveInfinity, 9, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, float.PositiveInfinity, 0, float.PositiveInfinity, 5, float.PositiveInfinity, 2 },
{ 5, 9, float.PositiveInfinity, 0, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, float.PositiveInfinity, 5, float.PositiveInfinity, 0, 8, 9 },
{ float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 8, 0, 11 },
{ float.PositiveInfinity, float.PositiveInfinity, 2, float.PositiveInfinity, 9, 11, 0 },
};
/* Expected MST
* (0)--7--(1) (2)
* \ /|
* 5 5 |
* \ / |
* (3) (4) 2
* / |
* 8 |
* / |
* (5) (6)
*/
var expected = new[, ]
{
{ float.PositiveInfinity, 7, float.PositiveInfinity, 5, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
{ 7, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 5, float.PositiveInfinity, 2 },
{ 5, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, float.PositiveInfinity, 5, float.PositiveInfinity, float.PositiveInfinity, 8, float.PositiveInfinity },
{ float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, 8, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, float.PositiveInfinity, 2, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
};
Kruskal.Solve(adj).Cast <float>().SequenceEqual(expected.Cast <float>()).Should().BeTrue();
}
public void AlgorithmTest()
{
var satellites = SatelliteRepository.GetSatellites().ToList();
var edges = PopulateEdgesFromSatellites(satellites);
List <int> vertices = satellites.Select(s => s.Id).ToList();
List <Edge> MinimumSpanningTree = Kruskal.Kruskals_MST(edges, vertices);
UndirectedGraph <int, UndirectedEdge <int> > graph = CreateGraphFromTree(vertices, MinimumSpanningTree);
RunDFS(graph);
CollectionAssert.AreEquivalent(new List <int> {
0, 1, 3, 2, 4
}, vertices);
}
public static void ThreadTask(Object Args)
{
object[] lArgs = (object[])Args;
int ThreadNum = (int)(lArgs[0]);
string[] lines = (string[])(lArgs[1]);
ManualResetEvent ev = (lArgs[2] as ManualResetEvent);
buffer[ThreadNum] = new Kruskal(lines);
buffer[ThreadNum].BuildSpanningTree();
// buffer[ThreadNum].DisplayInfo();
ev.Set();
}
public IList <IList <int> > FindCriticalAndPseudoCriticalEdges(int n, int[][] edges)
{
var graph = new EdgeWeightedGraph <int, int>(n);
for (var i = 0; i < edges.Length; i++)
{
graph.AddEdge(new WeightedEdge <int, int>(edges[i][0], edges[i][1], edges[i][2], i));
}
var kruskal = new Kruskal <int, int>(graph);
var mst = kruskal.MinimumSpanningTree;
var weight = mst.Sum(edge => edge.Weight);
var criticals = new HashSet <WeightedEdge <int, int> >();
foreach (var edge in mst)
{
graph.RemoveEdge(edge);
try {
if (new Kruskal <int, int>(graph).MinimumSpanningTree.Sum(edge => edge.Weight) > weight)
{
criticals.Add(edge);
}
}
catch (ArgumentException) {
criticals.Add(edge);
}
graph.AddEdge(edge);
}
var pseudos = new List <WeightedEdge <int, int> >();
foreach (var edge in graph.Edges)
{
if (!criticals.Contains(edge) && new Kruskal <int, int>(graph, edge).MinimumSpanningTree.Sum(edge => edge.Weight) == weight)
{
pseudos.Add(edge);
}
}
var result0 = new List <int>(criticals.Count);
var result1 = new List <int>(pseudos.Count);
result0.AddRange(criticals.Select(edge => edge.Id));
result1.AddRange(pseudos.Select(edge => edge.Id));
return(new List <IList <int> >(2)
{
result0, result1
});
}
public void DeberiaRetornarListaCon1NodoSiElGrafoTiene1Nodo()
{
var g = new Grafo();
var n1 = new Nodo("N1");
var n2 = new Nodo("N2");
g.AgregarNodo(n1);
g.AgregarNodo(n2);
var e1 = new Enlace(2, n1, n2);
g.AgregarEnlace(e1);
var l = Kruskal.Ejecutar(g);
Assert.IsNotNull(l);
Assert.AreEqual(1, l.Count);
}
public void Solve_adjGraph2_CorrectAnswer()
{
/* Graph
* (0) (4)
* |\ /
* | 3 2
* | \ /
* 4 (1)
* | / \
* | 5 6
* |/ \
* (2) (3)
*/
var adj = new[, ]
{
{ 0, 3, 4, float.PositiveInfinity, float.PositiveInfinity },
{ 3, 0, 5, 6, 2 },
{ 4, 5, 0, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, 6, float.PositiveInfinity, 0, float.PositiveInfinity },
{ float.PositiveInfinity, 2, float.PositiveInfinity, float.PositiveInfinity, 0 },
};
/* Expected MST
* (0) (4)
* |\ /
* | 3 2
* | \ /
* 4 (1)
* | \
* | 6
* | \
* (2) (3)
*/
var expected = new[, ]
{
{ float.PositiveInfinity, 3, 4, float.PositiveInfinity, float.PositiveInfinity },
{ 3, float.PositiveInfinity, float.PositiveInfinity, 6, 2 },
{ 4, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, 6, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
{ float.PositiveInfinity, 2, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity },
};
Kruskal.Solve(adj).Cast <float>().SequenceEqual(expected.Cast <float>()).Should().BeTrue();
}
