public void Constructor()
{
var graph = new UndirectedGraph <int, Edge <int> >();
var algorithm = new KruskalMinimumSpanningTreeAlgorithm <int, Edge <int> >(graph, edge => 1.0);
AssertAlgorithmState(algorithm, graph);
algorithm = new KruskalMinimumSpanningTreeAlgorithm <int, Edge <int> >(null, graph, edge => 1.0);
AssertAlgorithmState(algorithm, graph);
}
public void Kruskal<TVertex,TEdge>([PexAssumeNotNull]IUndirectedGraph<TVertex, TEdge> g)
where TEdge : IEdge<TVertex>
{
var distances = new Dictionary<TEdge, double>();
foreach(var e in g.Edges)
distances[e] = g.AdjacentDegree(e.Source) + 1;
var kruskal = new KruskalMinimumSpanningTreeAlgorithm<TVertex, TEdge>(g, e => distances[e]);
AssertMinimumSpanningTree<TVertex, TEdge>(g, kruskal);
}
public static IEnumerable <TaggedEdge <string, string> > GetEdges(UndirectedGraph <string, TaggedEdge <string, string> > g)
{
var algorithm = new KruskalMinimumSpanningTreeAlgorithm <string, TaggedEdge <string, string> >(g, edgeWeights => double.Parse(edgeWeights.Tag));
var recorder = new EdgeRecorderObserver <string, TaggedEdge <string, string> >();
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges);
}
}
public static IEnumerable <Edge <int> > GetEdges(UndirectedGraph <int, Edge <int> > g)
{
var algorithm = new KruskalMinimumSpanningTreeAlgorithm <int, Edge <int> >(g, edgeWeights => 1.0);
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges);
}
}
protected static void KruskalSpanningTree <TVertex, TEdge>(IUndirectedGraph <TVertex, TEdge> graph, Func <TEdge, double> edgeWeights)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (TEdge edge in graph.Edges)
{
distances[edge] = edgeWeights(edge);
}
var kruskal = new KruskalMinimumSpanningTreeAlgorithm <TVertex, TEdge>(graph, e => distances[e]);
AssertMinimumSpanningTree(graph, kruskal);
}
/// <summary>
/// Kruskal Minimum Spanning Tree
/// </summary>
/// <typeparam name="TVertex"></typeparam>
/// <typeparam name="TEdge"></typeparam>
/// <param name="g"></param>
/// <param name="edgeWeights"></param>
/// <param name="resultEdges"></param>
private static void Kruskal <TVertex, TEdge>(IUndirectedGraph <TVertex, TEdge> g, Func <TEdge, double> edgeWeights, ref int[][] resultEdges) where TEdge : IEdge <TVertex>
{
var ed = g.Edges.ToList();
var distances = new Dictionary <TEdge, double>();
foreach (var e in g.Edges)
{
distances[e] = edgeWeights(e);
}
var prim = new KruskalMinimumSpanningTreeAlgorithm <TVertex, TEdge>(g, e => distances[e]);
AssertMinimumSpanningTree <TVertex, TEdge>(g, prim, ref resultEdges);
}
private static void Kruskal <TVertex, TEdge>([NotNull] IUndirectedGraph <TVertex, TEdge> graph)
where TEdge : IEdge <TVertex>
{
var distances = new Dictionary <TEdge, double>();
foreach (TEdge edge in graph.Edges)
{
distances[edge] = graph.AdjacentDegree(edge.Source) + 1;
}
var kruskal = new KruskalMinimumSpanningTreeAlgorithm <TVertex, TEdge>(graph, e => distances[e]);
AssertMinimumSpanningTree(graph, kruskal);
}
public void MyKruskal <TVertex, TEdge>([PexAssumeNotNull] IUndirectedGraph <TVertex, TEdge> g, Func <TEdge, double> edgeWeights)
where TEdge : IEdge <TVertex>
{
var ed = g.Edges.ToList();
var distances = new Dictionary <TEdge, double>();
foreach (var e in g.Edges)
{
distances[e] = edgeWeights(e);
}
var prim = new KruskalMinimumSpanningTreeAlgorithm <TVertex, TEdge>(g, e => distances[e]);
AssertMinimumSpanningTree <TVertex, TEdge>(g, prim);
}
public static double GetCost(UndirectedGraph <string, TaggedEdge <string, string> > g)
{
var algorithm = new KruskalMinimumSpanningTreeAlgorithm <string, TaggedEdge <string, string> >(g, edgeWeights => double.Parse(edgeWeights.Tag));
var recorder = new EdgeRecorderObserver <string, TaggedEdge <string, string> >();
var distances = new Dictionary <TaggedEdge <string, string>, double>();
foreach (var e in g.Edges)
{
distances[e] = double.Parse(e.Tag);
}
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges.Sum(e => distances[e]));
}
}
public static double GetCost(UndirectedGraph <int, Edge <int> > g)
{
var algorithm = new KruskalMinimumSpanningTreeAlgorithm <int, Edge <int> >(g, edgeWeights => 1.0);
var recorder = new EdgeRecorderObserver <int, Edge <int> >();
var distances = new Dictionary <Edge <int>, double>();
foreach (var edge in g.Edges)
{
distances[edge] = 1.0;
}
using (recorder.Attach(algorithm))
{
algorithm.Compute();
return(recorder.Edges.Sum(e => distances[e]));
}
}
/// <summary>
/// Computes the minimum spanning tree using Kruskal's algorithm.
/// </summary>
/// <typeparam name="TVertex">type of the vertices</typeparam>
/// <typeparam name="TEdge">type of the edges</typeparam>
/// <param name="visitedGraph"></param>
/// <param name="weights"></param>
/// <returns></returns>
public static IEnumerable <TEdge> MinimumSpanningTreeKruskal <TVertex, TEdge>
(this IUndirectedGraph <TVertex, TEdge> visitedGraph, Func <TEdge, double> weights)
where TEdge : IEdge <TVertex>
{
Contract.Requires(visitedGraph != null);
Contract.Requires(weights != null);
if (visitedGraph.VertexCount == 0)
{
return(new TEdge[0]);
}
var kruskal = new KruskalMinimumSpanningTreeAlgorithm <TVertex, TEdge>(visitedGraph, weights);
var edgeRecorder = new EdgeRecorderObserver <TVertex, TEdge>();
using (edgeRecorder.Attach(kruskal))
kruskal.Compute();
return(edgeRecorder.Edges);
}
