public void Case1()
{
var vertices = new ExtendedVertex[]
{
new ExtendedVertex(1, new AdjacentEdge[]
{
new AdjacentEdge(2,1),
new AdjacentEdge(3,3),
new AdjacentEdge(4,4),
}),
new ExtendedVertex(2, new AdjacentEdge[]
{
new AdjacentEdge(1,1),
new AdjacentEdge(3,2),
}),
new ExtendedVertex(3, new AdjacentEdge[]
{
new AdjacentEdge(4,5),
new AdjacentEdge(2,2),
}),
new ExtendedVertex(4, new AdjacentEdge[]
{
new AdjacentEdge(1,4),
new AdjacentEdge(3,5),
}),
};
var primAlg = new PrimMST();
Assert.AreEqual(7, primAlg.CalcMSTLength(vertices));
}
public void Case2()
{
var vertices = new ExtendedVertex[]
{
new ExtendedVertex(1, new AdjacentEdge[]
{
new AdjacentEdge(2,6),
new AdjacentEdge(3,3),
new AdjacentEdge(4,-14),
}),
new ExtendedVertex(2, new AdjacentEdge[]
{
new AdjacentEdge(1,6),
new AdjacentEdge(4,8),
}),
new ExtendedVertex(3, new AdjacentEdge[]
{
new AdjacentEdge(4,12),
new AdjacentEdge(1,3),
}),
new ExtendedVertex(4, new AdjacentEdge[]
{
new AdjacentEdge(1,-14),
new AdjacentEdge(3,12),
new AdjacentEdge(5,-5),
}),
new ExtendedVertex(5, new AdjacentEdge[]
{
new AdjacentEdge(4,-5),
}),
};
var primAlg = new PrimMST();
Assert.AreEqual(-10, primAlg.CalcMSTLength(vertices));
}
public decimal CalcMSTLength(ExtendedVertex[] vertices)
{
var startVertex = new Random().Next(1, vertices.Length);
var mst = new HashSet<int> {startVertex};
decimal mstLength = 0;
while (mst.Count < vertices.Length)
{
//select min edge
//foreach edge with one vertex in mst and another not select min
decimal minWeight = decimal.MaxValue;
int mstVetrexIndex = int.MaxValue;
foreach (int vertexIndex in mst)
{
foreach (AdjacentEdge edge in vertices[vertexIndex - 1].AdjacentVertices)
{
if (!mst.Contains(edge.Vertex))
{
if (edge.Weigth < minWeight)
{
minWeight = edge.Weigth;
mstVetrexIndex = edge.Vertex;
}
}
}
}
//add vertex to mst
mst.Add(mstVetrexIndex);
// updated mstLength
mstLength += minWeight;
}
return mstLength;
}
public void TestCase1()
{
var vertices = new ExtendedVertex[]
{
new ExtendedVertex(1, new AdjacentEdge[]
{
new AdjacentEdge(2,10),
new AdjacentEdge(4,30),
new AdjacentEdge(5,100),
}),
new ExtendedVertex(2, new AdjacentEdge[]
{
new AdjacentEdge(3,50),
}),
new ExtendedVertex(3, new AdjacentEdge[]
{
new AdjacentEdge(5,10),
}),
new ExtendedVertex(4, new AdjacentEdge[]
{
new AdjacentEdge(3,20),
new AdjacentEdge(5,50),
}),
new ExtendedVertex(5, new AdjacentEdge[0]),
};
var alg = new DijkstraAlgorithm(vertices);
var minPaths = alg.CalculateMinPath();
Assert.AreEqual(5, minPaths.Length);
Assert.AreEqual("0,10,50,30,60", string.Join(",", minPaths));
}
public void Assignment1_Case1()
{
var vertices = new ExtendedVertex[]
{
new ExtendedVertex(1, new AdjacentEdge[]
{
new AdjacentEdge(2,1),
new AdjacentEdge(3,1),
new AdjacentEdge(4,2),
new AdjacentEdge(5,2),
new AdjacentEdge(6,2),
}),
new ExtendedVertex(2, new AdjacentEdge[]
{
new AdjacentEdge(1,1),
new AdjacentEdge(3,1),
new AdjacentEdge(4,2),
new AdjacentEdge(5,2),
new AdjacentEdge(6,2),
}),
new ExtendedVertex(3, new AdjacentEdge[]
{
new AdjacentEdge(1,1),
new AdjacentEdge(2,1),
new AdjacentEdge(4,2),
new AdjacentEdge(5,2),
new AdjacentEdge(6,2),
}),
new ExtendedVertex(4, new AdjacentEdge[]
{
new AdjacentEdge(1,2),
new AdjacentEdge(2,2),
new AdjacentEdge(3,2),
new AdjacentEdge(5,2),
new AdjacentEdge(6,2),
}),
new ExtendedVertex(5, new AdjacentEdge[]
{
new AdjacentEdge(1,2),
new AdjacentEdge(2,2),
new AdjacentEdge(3,2),
new AdjacentEdge(4,2),
new AdjacentEdge(6,2),
}),
new ExtendedVertex(6, new AdjacentEdge[]
{
new AdjacentEdge(1,2),
new AdjacentEdge(2,2),
new AdjacentEdge(3,2),
new AdjacentEdge(4,2),
new AdjacentEdge(5,2),
}),
};
var maxSpaceClustering = new MaxSpaceClustering();
Assert.AreEqual(2, maxSpaceClustering.CalcMaxSpacing(vertices, 4));
}
public int CalcMaxSpacing(ExtendedVertex[] vertices, int clustersCount)
{
Array.ForEach(vertices, v =>
{
v.Parent = v;
v.Rank = 0;
});
int mergeCount = 0;
while (mergeCount < vertices.Length - clustersCount)
{
var minEdge = GetNextMinEdge(vertices);
UnionFind.Union(vertices[minEdge.Item1 - 1], vertices[minEdge.Item2 - 1]);
mergeCount++;
}
return CalcMaxSpacing(vertices);
}
public void TestCase2()
{
var vertices = new ExtendedVertex[]
{
new ExtendedVertex(1, new AdjacentEdge[]
{
new AdjacentEdge(2,50),
new AdjacentEdge(3,10),
new AdjacentEdge(5,45),
}),
new ExtendedVertex(2, new AdjacentEdge[]
{
new AdjacentEdge(5,10),
}),
new ExtendedVertex(3, new AdjacentEdge[]
{
new AdjacentEdge(1,20),
new AdjacentEdge(4,15),
}),
new ExtendedVertex(4, new AdjacentEdge[]
{
new AdjacentEdge(2,20),
new AdjacentEdge(5,35),
}),
new ExtendedVertex(5, new AdjacentEdge[]
{
new AdjacentEdge(4,30),
}),
new ExtendedVertex(6, new AdjacentEdge[]
{
new AdjacentEdge(4,3),
}),
};
var alg = new DijkstraAlgorithm(vertices);
Assert.AreEqual("0,45,10,25,45,1000000", string.Join(",", alg.CalculateMinPath()));
Assert.AreEqual("1000000,50,1000000,30,0,1000000", string.Join(",", alg.CalculateMinPath(5)));
Assert.AreEqual("1000000,23,1000000,3,33,0", string.Join(",", alg.CalculateMinPath(6)));
}
private static void AddEdge(ExtendedVertex[] vertices, int left, int right, int weight)
{
vertices[left - 1].AddAdjacenEdge(new AdjacentEdge(right, weight));
vertices[right - 1].AddAdjacenEdge(new AdjacentEdge(left, weight));
}
private int CalcMaxSpacing(ExtendedVertex[] vertices)
{
var minEdge = GetNextMinEdge(vertices);
return vertices[minEdge.Item1 - 1].AdjacentVertices.Single(x => x.Vertex == minEdge.Item2).Weigth;
}
private Tuple<int, int> GetNextMinEdge(ExtendedVertex[] vertices)
{
decimal minWeight = decimal.MaxValue;
Tuple<int, int> nextMinEdge = null;
foreach (var vertex in vertices)
{
foreach (AdjacentEdge edge in vertex.AdjacentVertices)
{
if (UnionFind.FindRoot(vertex) != UnionFind.FindRoot(vertices[edge.Vertex - 1]))
{
if (edge.Weigth < minWeight)
{
minWeight = edge.Weigth;
nextMinEdge = new Tuple<int, int>(vertex.Id, edge.Vertex);
}
}
}
}
return nextMinEdge;
}
public DijkstraAlgorithm(ExtendedVertex[] vertices )
{
_vertices = vertices;
}
