// Builds the tree
TreeNode<SymbolPriority>* MakeTree(const string& message)
{
char currentChar;
vector<SymbolPriority> temp;
PriorityQueue<TreeNode<SymbolPriority>*> myPriorityQueue;
for (int i = 0; i < int(message.size()); i++)
{
currentChar = message[i];
if ( temp.empty() )
temp.push_back( SymbolPriority(currentChar, 1) );
else if ( characterExists(temp, currentChar) )
{
for (int c = 0; c < int (temp.size()); i++)
if (currentChar == temp[i].Symbol)
temp[i].Priority++;
}
else
temp.push_back( SymbolPriority(currentChar, 1) );
}
for (int i = 0; i < int(temp.size()); i++)
{
if (myPriorityQueue.GetSize() <= 1)
myPriorityQueue.Push( new TreeNode<SymbolPriority>( temp[i]) );
else
{
char aChar;
TreeNode<SymbolPriority>* tempNode;
// create a new TreeNode<SymbolPriority>* and
// make the first popped element its left child
// make the second popped element its right child
// set its value to the sum of its left and right child priorities
tempNode->Left = myPriorityQueue.Top();
aChar = myPriorityQueue.Top()->Data.Priority;
myPriorityQueue.Pop();
tempNode->Right = myPriorityQueue.Top();
aChar += myPriorityQueue.Top()->Data.Priority;
myPriorityQueue.Pop();
myPriorityQueue.Push( tempNode );
}
}
return myPriorityQueue.Top();
}
void bestFirstSearch(state_t *state) {
PriorityQueue<state_t> pq;
pq.Add(0,0,*state);
state_map_t *map = new_state_map();
state_map_add(map,state,0);
state_t currentState;
state_t child;
int *cost;
int ruleid, priority, childCost;
ruleid_iterator_t iter;
while (!pq.Empty()) {
priority = pq.CurrentPriority();
currentState = pq.Top();
pq.Pop();
nodes++;
cost = state_map_get(map,¤tState);
if (cost == nullptr || priority <= *cost) {
/* The state added to map is Gray */
state_map_add(map,¤tState,priority);
if (is_goal(¤tState)) {
fprintf(output, ": - %i %lu ", priority, nodes);
destroy_state_map(map);
return;
}
init_fwd_iter(&iter,¤tState);
while((ruleid = next_ruleid(&iter)) >= 0) {
apply_fwd_rule(ruleid,¤tState,&child);
if (h.getHeuristic(&child) < UINT_MAX) {
childCost = priority + get_fwd_rule_cost(ruleid);
state_map_add(map,&child,childCost);
pq.Add(childCost,childCost,child);
}
}
}
}
destroy_state_map(map);
cout << "No goal found.\n";
}
bool Prim(SGraph& graph, SGraph& result){
SGraph t_g = graph;
int num_v = graph.GetNumVertices();
result.Clear();
if(!graph.IsConnected()){
return false;
}
Vector<SGraph::Edge> unroll_edges;
graph.UnrollEdges(unroll_edges);
Algorithms::Sorting::HeapSort(unroll_edges, unroll_edges);
PriorityQueue<SGraph::Edge> adjacencies;
Vector<int> v_adjac;
SGraph::Edge e = unroll_edges[0];
SGraph::Edge t(0,0);
t_g.DeleteEdge(e);
result.AddEdge(e);
while(result.GetNumEdges() < (num_v -1)){
t_g.FindAdjacencyVertices(e.head, v_adjac);
for(int i = 0; i < v_adjac.Size(); i++){
if(result.HasVertex(v_adjac[i])) continue;
t.head = e.head;
t.tail = v_adjac[i];
t.weight = t_g.GetEdgeW(t.head, t.tail);
adjacencies.Push(t);
}
t_g.FindAdjacencyVertices(e.tail, v_adjac);
for(int i = 0; i < v_adjac.Size(); i++){
if(result.HasVertex(v_adjac[i])) continue;
t.head = v_adjac[i];
t.tail = e.tail;
t.weight = t_g.GetEdgeW(t.head, t.tail);
adjacencies.Push(t);
}
e = adjacencies.Head();
result.AddEdge(e);
t_g.DeleteEdge(e);
adjacencies.Pop();
}
return true;
}
int main( int argc, char **argv )
{
// VARIABLES FOR INPUT
char str[ MAX_LINE_LENGTH +1 ] ;
ssize_t nchars;
state_t state; // state_t is defined by the PSVN API. It is the type used for individual states.
PriorityQueue<state_t> open;
//state_map_t *map = new_state_map();//******
// VARIABLES FOR ITERATING THROUGH state's SUCCESSORS
state_t child;
ruleid_iterator_t iter; // ruleid_terator_t is the type defined by the PSVN API successor/predecessor iterators.
int ruleid ; // an iterator returns a number identifying a rule
int64_t totalNodes;
// READ A LINE OF INPUT FROM stdin
printf("Please enter a state followed by ENTER: ");
if ( fgets(str, sizeof str, stdin) == NULL ) {
printf("Error: empty input line.\n");
return 0;
}
// CONVERT THE STRING TO A STATE
nchars = read_state( str, &state );
if (nchars <= 0) {
printf("Error: invalid state entered.\n");
return 0;
}
printf("The state you entered is: ");
print_state( stdout, &state );
printf("\n");
List StateList = List();
// state_map_add( map, &state, 0 );//******dont know if its a must
open.Add(0,0,state);
StateList.add(&state);
StateList.change_color(&state,1);// Gray
// StateList.change_distance(&state,0);
totalNodes = 0;
int d = 0;
/* Search */
while ( !open.Empty() ) {
// g.n
d = open.CurrentPriority();
printf("D: %d\n",d);
state = open.Top();
open.Pop();
totalNodes++;
/* DDD */
if (StateList.get_color(&state)==0 || (StateList.get_distance(&state)>(d-1))){
StateList.change_distance(&state,d);
if (is_goal(&state)==1){
//PRINT STUFF
printf("Estado: ");
print_state( stdout, &state);
printf(" Estados Generados: %"PRId64" , costo: %d",totalNodes,StateList.get_distance(&state));
return 1;//SUCCES
}
/* expand node */
init_fwd_iter(&iter, &state);
while((ruleid = next_ruleid(&iter)) >= 0){
apply_fwd_rule(ruleid,&state,&child);//'child' is a succesor state_t of 'state'
StateList.add(&child);
StateList.change_color(&child, 1);//Gray
const int child_d = d + get_fwd_rule_cost(ruleid);
StateList.change_distance( &child , child_d );
open.Add( child_d , child_d , child );
}
StateList.change_color(&state,2); //Black
}
}
printf("FAIL!");
return 2; //FAIL
}
int main(int argc, char **argv)
{
// using PriorityQueue = pg::heap::Binary<int>;
using PriorityQueue = pg::heap::Pairing<int>;
// using PriorityQueue = StdWrapper<int>;
test("Basic Push/Pop", []()
{
PriorityQueue pq;
pq.Push(10);
pq.Push(5);
pq.Push(8);
pq.Push(12);
pq.Push(1);
pq.Push(90);
pq.Push(9);
assertEquals(1, pq.Pop());
assertEquals(5, pq.Pop());
assertEquals(8, pq.Pop());
assertEquals(9, pq.Pop());
assertEquals(10, pq.Pop());
assertEquals(12, pq.Pop());
assertEquals(90, pq.Pop());
assertEquals(true, pq.Empty());
});
test("Update value", []()
{
PriorityQueue pq;
pq.Push(10);
pq.Push(5);
pq.Push(8);
pq.Push(12);
pq.Push(1);
pq.Push(90);
pq.Push(9);
pq.Update(70, 5);
pq.Update(7, 12);
assertEquals(1, pq.Pop());
assertEquals(7, pq.Pop());
assertEquals(8, pq.Pop());
assertEquals(9, pq.Pop());
assertEquals(10, pq.Pop());
assertEquals(70, pq.Pop());
assertEquals(90, pq.Pop());
assertEquals(true, pq.Empty());
});
test("Performance", []()
{
constexpr auto size = 1000000;
std::default_random_engine random_engine(time(nullptr));
std::uniform_int_distribution<int> distribution(1,9999999);
auto rand = std::bind ( distribution, random_engine );
std::vector<int> test;
PriorityQueue pq;
for(int i = 0 ; i < size; i++)
pq.Push(rand());
while(!pq.Empty())
test.push_back(pq.Pop());
assertEquals(true, std::is_sorted(test.begin(), test.end()));
});
return 0;
}
