private LinkedQueue <Edge> mst = new LinkedQueue <Edge>(); // edges in MST
/// <summary>
/// Compute a minimum spanning tree (or forest) of an edge-weighted graph.</summary>
/// <param name="G">the edge-weighted graph</param>
///
public KruskalMST(EdgeWeightedGraph G)
{
// more efficient to build heap by passing array of edges
MinPQ <Edge> pq = new MinPQ <Edge>();
foreach (Edge e in G.Edges())
{
pq.Insert(e);
}
// run greedy algorithm
UF uf = new UF(G.V);
while (!pq.IsEmpty && mst.Count < G.V - 1)
{
Edge e = pq.DelMin();
int v = e.Either;
int w = e.Other(v);
if (!uf.Connected(v, w))
{ // v-w does not create a cycle
uf.Union(v, w); // merge v and w components
mst.Enqueue(e); // add edge e to mst
weight += e.Weight;
}
}
// check optimality conditions
Debug.Assert(check(G));
}
public static void MainTest(string[] args)
{
int M = int.Parse(args[0]);
MinPQ <Transaction> pq = new MinPQ <Transaction>(M + 1);
TextInput StdIn = new TextInput();
while (!StdIn.IsEmpty)
{
// Create an entry from the next line and put on the PQ.
string line = StdIn.ReadLine();
Transaction transaction = new Transaction(line);
pq.Insert(transaction);
// remove minimum if M+1 entries on the PQ
if (pq.Count > M)
{
pq.DelMin();
}
} // top M entries are on the PQ
// print entries on PQ in reverse order
LinkedStack <Transaction> stack = new LinkedStack <Transaction>();
foreach (Transaction transaction in pq)
{
stack.Push(transaction);
}
foreach (Transaction transaction in stack)
{
Console.WriteLine(transaction);
}
}
/// <summary>
/// Initializes a system with the specified collection of particles.
/// The individual particles will be mutated during the simulation.</summary>
/// <param name="limit">The simulation time in milliseconds</param>
/// <param name="N">The number of particle</param>
///
public CollisionSystem(int N, double limit)
{
// Set up the drawing surface (canvas) and use the unit scale
SetCanvasSize(CanvasWidth, CanvasHeight);
SetPercentScale(true);
// Initialize the domain objects with the unit coordinates
particles = new Particle[N];
for (int i = 0; i < N; i++)
{
particles[i] = new Particle(this);
}
// initialize PQ with collision events and redraw event
pq = new MinPQ <Event>();
for (int i = 0; i < particles.Length; i++)
{
predict(particles[i], limit);
}
pq.Insert(new Event(0, null, null)); // redraw event
this.limit = limit;
FrameUpdateHandler = Update; // atache a frame update handler
}
// additional test
static void TopInts()
{
int[] allInts = { 12, 11, 8, 7, 9, 5, 4, 3, 2, 29, 23, 1, 24, 30, 9, 4, 88, 5, 100, 29, 23, 5, 99, 87, 22, 111 };
MinPQ <int> pq0 = new MinPQ <int>(allInts);
int M = allInts.Length / 3;
MinPQ <int> pq = new MinPQ <int>(M + 1);
Console.WriteLine("Top {0} is ", M);
foreach (var n in allInts)
{
pq.Insert(n);
Console.WriteLine("Min is {0}", pq.Min);
// remove minimum if M+1 entries on the PQ
if (pq.Count > M)
{
pq.DelMin();
}
}
// print entries on PQ in reverse order
LinkedStack <int> stack = new LinkedStack <int>();
foreach (int n in pq)
{
stack.Push(n);
}
foreach (int n in stack)
{
Console.WriteLine(n);
}
Console.WriteLine("These are the top elements");
}
// For a complete description, see
// http://www.proofwiki.org/wiki/Labeled_Tree_from_Prüfer_Sequence
// http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.36.6484&rep=rep1&type=pdf
/// <summary>
/// Returns a uniformly random tree on <c>V</c> vertices.
/// This algorithm uses a Prufer sequence and takes time proportional to <c>V log V</c>.</summary>
/// <param name="V">the number of vertices in the tree</param>
/// <returns>a uniformly random tree on <c>V</c> vertices</returns>
///
public static Graph Tree(int V)
{
Graph G = new Graph(V);
// special case
if (V == 1)
{
return(G);
}
// Cayley's theorem: there are V^(V-2) labeled trees on V vertices
// Prufer sequence: sequence of V-2 values between 0 and V-1
// Prufer's proof of Cayley's theorem: Prufer sequences are in 1-1
// with labeled trees on V vertices
int[] prufer = new int[V - 2];
for (int i = 0; i < V - 2; i++)
{
prufer[i] = StdRandom.Uniform(V);
}
// degree of vertex v = 1 + number of times it appers in Prufer sequence
int[] degree = new int[V];
for (int v = 0; v < V; v++)
{
degree[v] = 1;
}
for (int i = 0; i < V - 2; i++)
{
degree[prufer[i]]++;
}
// pq contains all vertices of degree 1
MinPQ <int> pq = new MinPQ <int>();
for (int v = 0; v < V; v++)
{
if (degree[v] == 1)
{
pq.Insert(v);
}
}
// repeatedly delMin() degree 1 vertex that has the minimum index
for (int i = 0; i < V - 2; i++)
{
int v = pq.DelMin();
G.AddEdge(v, prufer[i]);
degree[v]--;
degree[prufer[i]]--;
if (degree[prufer[i]] == 1)
{
pq.Insert(prufer[i]);
}
}
G.AddEdge(pq.DelMin(), pq.DelMin());
return(G);
}
private MinPQ <Edge> pq; // edges with one endpoint in tree
/// <summary>
/// Compute a minimum spanning tree (or forest) of an edge-weighted graph.</summary>
/// <param name="G">the edge-weighted graph</param>
///
public LazyPrimMST(EdgeWeightedGraph G)
{
mst = new LinkedQueue <Edge>();
pq = new MinPQ <Edge>();
marked = new bool[G.V];
for (int v = 0; v < G.V; v++) // run Prim from all vertices to
{
if (!marked[v])
{
prim(G, v); // get a minimum spanning forest
}
}
// check optimality conditions
Debug.Assert(check(G));
}
// add all items to copy of heap
// takes linear time since already in heap order so no keys move
public HeapIEnumerator(MinPQ <Key> pq)
{
if (pq.comparator == null)
{
innerPQ = new MinPQ <Key>(pq.Count);
}
else
{
innerPQ = new MinPQ <Key>(pq.Count, pq.comparator);
}
for (int i = 1; i <= pq.N; i++)
{
innerPQ.Insert(pq.pq[i]);
}
copy = innerPQ;
}
public static void MainTest(string[] args)
{
TextInput StdIn = new TextInput();
MinPQ <string> pq = new MinPQ <string>();
while (!StdIn.IsEmpty)
{
string item = StdIn.ReadString();
if (!item.Equals("-"))
{
pq.Insert(item);
}
else if (!pq.IsEmpty)
{
Console.Write(pq.DelMin() + " ");
}
}
Console.WriteLine("(" + pq.Count + " left on pq)");
}
// build the Huffman trie given frequencies
private static Node buildTrie(int[] freq)
{
// initialze priority queue with singleton trees
MinPQ <Node> pq = new MinPQ <Node>();
for (int i = 0; i < R; i++)
{
if (freq[i] > 0)
{
pq.Insert(new Node((char)i, freq[i], null, null));
}
}
// special case in case there is only one character with a nonzero frequency
if (pq.Count == 1)
{
if (freq[ZERO] == 0)
{
pq.Insert(new Node(ZERO, 0, null, null));
}
else
{
pq.Insert(new Node(ONE, 0, null, null));
}
}
// merge two smallest trees
while (pq.Count > 1)
{
Node left = pq.DelMin();
Node right = pq.DelMin();
Node parent = new Node(ZERO, left.freq + right.freq, left, right);
pq.Insert(parent);
}
return(pq.DelMin());
}
public void Reset()
{
innerPQ = copy;
}
