int main(){
PriorityQueue* pr = new PriorityQueue();
pr->insertElem(4,13);
pr->insertElem(3,5);
pr->insertElem(2,9);
pr->insertElem(1,2);
for(int i=0 ; i<pr->size() ;i++){
printf("%d\n", pr->minQueue[i]->priority );
}
if( pr->contains(4) ) {
pr->changePriority(4,1);
}
while(!pr->isEmpty()){
Element * elem = pr->minPriority();
printf("(%d,%d)\n",elem->vertex,elem->priority);
}
}
void Prim::mst(int root,Color color){
Q.clear();
int size=G->V(); // number of vertices
for(int i=0;i<size;i++){
dist[i]=1000.0;
edges[i]=NO_EDGE;
if(G->get_node_value(i)==color){ // only choose the same color
//dist[i]=INF; // equal to infinite
//cout<<"insert node!"<<i<<" and dist is "<<dist[i]<<endl;
Q.Insert(Type_Queue_Element (i,dist[i])); // assign V[G] to Q
}
}
dist[root]=0.0;
if(!Q.contains(root)) cout<<"not include root !!"<<endl;
else {
Q.chgPrioirity(root,dist[root]); //dist[i] and priority value in priority queue must be synchronized
edges[root]=ROOT_EDGE;
while(!Q.empty()){
Type_Queue_Element currElement=Q.top();
Q.minPrioirty(); // remove from priority queue
int currNode=currElement.first;
if(edges[currNode]!=NO_EDGE){
dist[currNode]=currElement.second;
vector<int> neibs=G->neighbors(currNode,color);
for(unsigned int i=0;i<neibs.size();i++){
if(Q.contains(neibs[i]) && (G->get_edge_value(neibs[i],currNode)<dist[neibs[i]]) ){
edges[neibs[i]]=currNode;
dist[neibs[i]]=G->get_edge_value(neibs[i],currNode);
Q.chgPrioirity(neibs[i],dist[neibs[i]]);
}
}
}
}
}
}
// Return a list<char> containing the list of nodes in the shortest path between 'u' and 'w'
list<char> ShortestPath::path(char u, char w)
{
// Initialize candidates list with all nodes
list<char> candidates = graph.vertices(), desiredPath;
list<NodeInfo> minPaths;
PriorityQueue p;
NodeInfo lastSelected, n;
// Calculate shortest path from 'u' to 'w' (Dijkstra's Algorithm)
candidates.remove(u); // Remove 'u' from candidates list
lastSelected.nodeName = u; // Set 'u' as lastSelected
lastSelected.minDist = 0;
lastSelected.through = u;
minPaths.push_back(lastSelected); // Add 'u' to minPath list
while ((!candidates.empty()) && (lastSelected.nodeName !=w))
{
// For each node in candidate list calculate the cost to reach that candidate through lastSelected
for(list<char>::iterator i=candidates.begin(); i != candidates.end(); ++i)
{
n.nodeName=*i;
n.minDist=lastSelected.minDist+graph.get_edge_value(lastSelected.nodeName,*i);
n.through=lastSelected.nodeName;
if (!p.contains(n)) // Add candidate to priority queue if doesn't exist
p.insert(n);
else
if (p.isBetter(n)) // Update candidate minDist in priority queue if a better path was found
p.chgPriority(n);
}
lastSelected = p.top(); // Select the candidate with minDist from priority queue
p.minPriority(); // Remove it from the priority queue
minPaths.push_back(lastSelected); // Add the candidate with min distance to minPath list
candidates.remove(lastSelected.nodeName); // Remove it from candidates list
}
// Go backward from 'w' to 'u' adding nodes in that path to desiredPath list
lastSelected=minPaths.back();
desiredPath.push_front(lastSelected.nodeName);
while(lastSelected.nodeName!=u)
{
for(list<NodeInfo>::iterator i=minPaths.begin(); i != minPaths.end(); ++i)
if ((*i).nodeName==lastSelected.through)
{
lastSelected=(*i);
desiredPath.push_front(lastSelected.nodeName);
}
}
return desiredPath;
}
