update prim alg

Author: xtaci

include/heap.h

@@ -49,15 +49,15 @@ namespace alg {
 				int32_t m_max;		// max heap size.
 				KV * m_kvs;			// key value pairs.
 
-				HashTable<int32_t, int32_t>  * m_idx; // key -> idx
+				HashTable<T, int32_t>  * m_idx; // key -> idx
 
 			public:
 				Heap(int max) {
 					m_size = 0;
 					m_max = max+1;
 					m_kvs = new KV[m_max];
 					m_kvs[0].key = INT_MIN;
-					m_idx = new HashTable<int32_t, int32_t>(m_max);
+					m_idx = new HashTable<T, int32_t>(m_max);
 				};
 
 				~Heap() {
@@ -88,19 +88,19 @@ namespace alg {
 					m_size++;
 					m_kvs[m_size].key	= key;
 					m_kvs[m_size].value	= value;
-					(*m_idx)[key] = m_size;
+					(*m_idx)[value] = m_size;
 
 					// Adjust its position
 					int now = m_size;
 					while(m_kvs[now/2].key > key) {
 						m_kvs[now] = m_kvs[now/2];
-						(*m_idx)[m_kvs[now/2].key] = now;
+						(*m_idx)[m_kvs[now/2].value] = now;
 						now /= 2;
 					}
 
 					m_kvs[now].key		= key;
 					m_kvs[now].value	= value;
-					(*m_idx)[key] 	= now;
+					(*m_idx)[value] 	= now;
 				}
 
 				/**
@@ -159,7 +159,7 @@ namespace alg {
 						// if the last key is less than the minimum key among both the children
 						if(lastKey > m_kvs[child].key) {
 							m_kvs[now] = m_kvs[child];
-							(*m_idx)[m_kvs[now].key] = now;	// record index
+							(*m_idx)[m_kvs[now].value] = now;	// record index
 						}
 						else { // It fits there
 							break;
@@ -168,24 +168,24 @@ namespace alg {
 
 					m_kvs[now].key 	= lastKey;
 					m_kvs[now].value= lastValue;
-					(*m_idx)[lastKey] 	= now;	// record index
+					(*m_idx)[lastValue] 	= now;	// record index
 				}
 
 				/**
 				 * so called DECREASE KEY operation.
 				 * step 1. find the value
 				 * step 2. decrease the key to the newkey
 				 */
-				void decrease_key(int32_t oldkey, int32_t newkey) {
-					int32_t index = (*m_idx)[oldkey];
+				void decrease_key(T value, int32_t newkey) {
+					int32_t index = (*m_idx)[value];
 					if (index > m_size || index == 0) return; 	// value not found 
 					if (newkey >= m_kvs[index].key) return; 	// violate DECREASE meanning.
 					T oldvalue = m_kvs[index].value;
 
 					int now = index;
 					while(m_kvs[now/2].key > newkey) {
 						m_kvs[now] = m_kvs[now/2];
-						(*m_idx)[m_kvs[now].key] = now;	// record index
+						(*m_idx)[m_kvs[now].value] = now;	// record index
 						now /= 2;
 					}
 

include/prim_mst.h

@@ -33,75 +33,6 @@
 
 namespace alg {
 	class Prim {
-		private:
-			/**
-			 * Prim's Adjacent Lists, for Prim's Algorithm caculation
-			 */
-			struct PrimAdjacent {
-				Heap<Graph::Vertex*> heap; 		// binary heap representation of weight->node
-				// the top of the heap is always the minimal element
-				const Graph::Vertex & v;
-
-				PrimAdjacent(const Graph::Vertex & vertex, uint32_t num_neigh):heap(num_neigh),v(vertex) { }
-
-				struct list_head pa_node; 
-			};
-
-			/**
-			 * Prim's Graph, simplified to list.
-			 */
-			typedef struct list_head PrimGraph;
-		private:
-			PrimGraph m_pg;
-		public:
-			/**
-			 * construct Prim's DataStrcuture by a given graph
-			 */	
-			Prim(const Graph & g) {
-				INIT_LIST_HEAD(&m_pg);
-
-				Graph::Adjacent * a;
-				list_for_each_entry(a, &g.list(), a_node){
-					add_adjacent(*a);
-				}
-			}
-
-			~Prim() {
-				PrimAdjacent * pa, *pan;
-				list_for_each_entry_safe(pa, pan, &m_pg, pa_node){
-					list_del(&pa->pa_node);
-					delete pa;
-				}
-			}
-		private:
-			Prim(const Prim&);
-			Prim& operator= (const Prim&);
-		private:
-			/**
-			 * add an adjacent list to prim's graph
-			 */
-			void add_adjacent(const Graph::Adjacent & a) {
-				PrimAdjacent * pa = new PrimAdjacent(a.vertex(), a.num_neigh);
-				list_add_tail(&pa->pa_node, &m_pg);
-
-				Graph::Vertex * v;
-				list_for_each_entry(v, &a.v_head, v_node){
-					pa->heap.insert(v->weight, v);  // weight->vertex
-				}
-			}
-
-			/**
-			 * lookup up a given id
-			 * the related adjacent list is returned.
-			 */ 
-			PrimAdjacent * lookup(uint32_t id) const {
-				PrimAdjacent * pa;
-				list_for_each_entry(pa, &m_pg, pa_node){
-					if (pa->v.id == id) { return pa;}
-				}
-
-				return NULL;
-			}
 		public:
 			/**
 			 * Prim's Algorithm. 
@@ -118,66 +49,54 @@ namespace alg {
 			 *
 			 * Output: Vnew and Enew describe a minimal spanning tree
 			 */
-			Graph * run() {
+			static Graph * run(const Graph & g, int32_t src_id) {
 				UndirectedGraph * mst = new UndirectedGraph(); // empty set == Vnew
+				// weight hash table
+				HashTable<int32_t, int32_t> keys(g.vertex_count());
+				// previous vertex hash table
+				HashTable<int32_t, int32_t> pi(g.vertex_count()); 
 
-				// choose the first vertex as the starting point
-				PrimAdjacent * pa;
-				list_for_each_entry(pa, &m_pg, pa_node){ break; }
-				const Graph::Vertex * v = &pa->v;
-				mst->add_vertex(v->id);
-
-				// Prim's Algorithm
-				while(true) {
-					int weight = INT_MAX;			// loop tmp variables
-					uint32_t best_to;
-					struct PrimAdjacent * best_from;
+				// a binary heap
+				Heap<uint32_t> Q(g.vertex_count());
 
-					// for each Vnew, find a new vertex in V that has minimal weight.
-					Graph::Adjacent * a; 
-					list_for_each_entry(a, &mst->list(), a_node){
-						pa = lookup(a->v.id);
-						while (!pa->heap.is_empty()) { 	// find one neighbour
-							v = pa->heap.min_value(); 
-							if ((*mst)[v->id]==NULL) {  // if new V appears 
-								if (pa->heap.min_key() < weight) {
-									weight = pa->heap.min_key();
-									best_to = v->id;
-									best_from = pa; 
-								}
-								break;
-							} else {
-								pa->heap.delete_min();
-							}
-						}
+				// all vertices
+				Graph::Adjacent * a;
+				list_for_each_entry(a, &g.list(), a_node){
+					if (a->v.id != src_id) {
+						Q.insert(INT_MAX, a->v.id);
+						keys[a->v.id] = INT_MAX;
 					}
+				}
 
-					if (weight != INT_MAX) {
-						// congrats , new V & E
-						mst->add_vertex(best_to);
-						mst->add_edge(best_from->v.id, best_to, weight);
-						best_from->heap.delete_min();
-					} else break;
-				};
+				Q.insert(0, src_id);
+				keys[src_id] = 0;
 
-				return mst;
-			}
+				while (!Q.is_empty()) {
+					int32_t id = Q.min_value();
+					Q.delete_min();		// remove u from Q
 
-			/**
-			 * print the PrimGraph
-			 */
-			void print() {
-				struct PrimAdjacent * pa;
-				printf("Prim Graph: \n");
-				list_for_each_entry(pa, &m_pg, pa_node){
-					printf("%d->{", pa->v.id);
-					for(uint32_t i=0;i<pa->heap.count();i++) {
-						Graph::Vertex * v = pa->heap[i];
-						printf("id:%d->w:%d \t", v->id, v->weight);
+					Graph::Adjacent * u = g[id];	// the vertex to process
+					Graph::Vertex * v;
+					list_for_each_entry(v, &u->v_head, v_node) {
+						if (Q.contains(v->id) && v->weight < keys[v->id]) {
+							pi[v->id] = id;
+							Q.decrease_key(v->id, v->weight);
+							keys[v->id] = v->weight;
+						}
+					}
+				}
+
+				// create graph
+				list_for_each_entry(a, &g.list(), a_node){
+					mst->add_vertex(a->v.id);
+					if (pi[a->v.id] != 0) {
+						mst->add_vertex(pi[a->v.id]);
+						mst->add_edge(pi[a->v.id], a->v.id, (*a)[pi[a->v.id]]->weight);
 					}
-					printf("}\n");
 				}
-			}
+
+				return mst;
+			};
 	};
 }
 

include/undirected_graph.h

@@ -128,22 +128,23 @@ namespace alg {
 			}
 			/**
 			 * randomly generate a graph, for test purpose
+			 * start from 1
 			 */
 			static UndirectedGraph * randgraph(int nvertex) {
 				UndirectedGraph * g = new UndirectedGraph;
 				int i;	
 
-				for(i=0;i<nvertex;i++) {
+				for(i=1;i<=nvertex;i++) {
 					g->add_vertex(i);
 				}
 
 				// random connect
-				for(i=0;i<nvertex;i++) {
+				for(i=1;i<=nvertex;i++) {
 					int j;
 					for(j=i+1;j<nvertex;j++) {
 						int dice = rand()%5;
 						if (dice == 0) {  // chance 20%
-							int w = rand()%100;
+							int w = rand()%100+1;
 							g->add_edge(i, j, w);
 						}
 					}

src/dijkstra_demo.cpp

@@ -18,8 +18,8 @@ int main(void)
 	g->printdot();
 
 	Graph::Adjacent * a;
-	printf("finding Dijkstra shortest path starting from 0: \n");
-	HashTable<int32_t,int32_t> * result = Dijkstra::run(*g, 0);
+	printf("finding Dijkstra shortest path starting from 1: \n");
+	HashTable<int32_t,int32_t> * result = Dijkstra::run(*g, 1);
 
 	list_for_each_entry(a, &g->list(), a_node){
 		printf("previous of %u is ", a->v.id);
@@ -29,9 +29,9 @@ int main(void)
 	}
 	delete result;
 
-	printf("finding Dijkstra shortest path starting from 1: \n");	
+	printf("finding Dijkstra shortest path starting from 2: \n");	
 
-	result = Dijkstra::run(*g, 1);
+	result = Dijkstra::run(*g, 2);
 	list_for_each_entry(a, &g->list(), a_node){
 		printf("previous of %u is ", a->v.id);
 		int32_t pre = (*result)[a->v.id];

src/heap_demo.cpp

@@ -17,9 +17,8 @@ int main()
 		printf("inserting: %d->%d\n", i, value);
 	}
 
-	int index = 9;
-	printf("decrease a key[%d] to %d\n", index, -1);
-	heap.decrease_key(index, -1);
+	printf("decrease a value[%d] to %d\n", 5, -1);
+	heap.decrease_key(5, -1);
 	while(!heap.is_empty()) {
 		printf("deleting min: %d->%d\n", heap.min_key(), heap.min_value());
 		heap.delete_min();

src/prim_mst_demo.cpp

@@ -5,24 +5,18 @@
 
 #include "undirected_graph.h"
 #include "prim_mst.h"
-using namespace alg;
-
 
 int main(void)
 {
 	using namespace alg;
 	srand(time(NULL));
 	int NVERTEX = 10;
-	UndirectedGraph * g = UndirectedGraph::randgraph(NVERTEX);
+	alg::UndirectedGraph * g = alg::UndirectedGraph::randgraph(NVERTEX);
 	g->printdot();
 	printf("Generating Prim's Graph: \n");	
-	Prim pg(*g);
-	pg.print();
-
-	printf("Generating Minimal spanning tree: \n");	
-	Graph * mst = pg.run();
-	mst->printdot();
-	delete mst;
+	Graph * prim = alg::Prim::run(*g, 1);
+	prim->printdot();
+	delete prim;
 	delete g;
 	return 0;	
 }