void
Dijkstra(int** adj_matrix, int num, int start, int dist[]) {
int i, u, v;
int id, key;
bool* access = malloc(sizeof(bool) * num);
struct PQueue* pq = create_pqueue(num);
for (i = 0; i < num; i++) {
if (i == start) {
dist[i] = 0;
}
else {
dist[i] = infinite;
}
access[i] = false;
insert(pq, i, dist[i]);
}
for(i = 0; i < num; i++) {
extract_min(pq, &u, &key);
access[u] = true;
for (v = 0; v < num; v++) {
if (!access[v] && adj_matrix[u][v] && dist[v] > dist[u] + adj_matrix[u][v]) {
dist[v] = dist[u] + adj_matrix[u][v];
decrease_key(pq, v, dist[v]);
}
}
}
destroy_pqueue(pq);
free(access);
}
void dijkstra_heap(int** W, int s, int n){
P = (int *)malloc(n*sizeof(int));
D = (int *)malloc(n*sizeof(int));
int i = 0;
for(; i < n; i++)D[i] = INFTY;
D[s] = 0;
P[s] = s;
int v = 0;
for(; v < n; v++){
if(W[s][v] < INFTY){
D[v] = W[s][v];
P[v] = s;
}
}
build_heap(n,s);
int u;
while(hsize != 0){ // the heap is not empty
u = extract_min();
for(v = 0; v < n; v++){
if(D[v] > D[u] + W[u][v]){
D[v] = D[u] + W[u][v];
P[v] = u;
decrease_key(v,D[v]);
}
}
}
}
/* Relax edge (u, v) with weight w. */
void relax(int u, int v, double w,
double key[], int handle[], int heap_index[], int size, int pi[]) {
if (key[heap_index[v]] > key[heap_index[u]] + w) {
decrease_key(key, handle, heap_index, heap_index[v], size, key[heap_index[u]] + w);
pi[v] = u;
}
}
void
insert(long long *heap, long long value)
{
++heap_size;
heap[heap_size-1] = MAX_INT;
decrease_key(heap, heap_size-1, value);
}
/* Insert a new node into the min-heap. Assumes that an array element
has already been allocated. */
void insert(double key[], int handle[], int heap_index[],
int vertex, int size, double new_key) {
key[++size] = 1000000000.0; /* will be fixed later */
handle[size] = vertex;
heap_index[vertex] = size;
decrease_key(key, handle, heap_index, size, size, new_key); /* here's later */
}
void relax(DijkstraResult* dijkstra_result, MinPriorityQueue* min_priority_queue, Graph* graph, int u, int v){
if(exist_arc(graph, u, v) and dijkstra_result->distance[v] > dijkstra_result->distance[u] + get_cost_edge(graph, u, v)){
dijkstra_result->distance[v] = dijkstra_result->distance[u] + get_cost_edge(graph, u, v);
dijkstra_result->predecessor[v] = u;
decrease_key(min_priority_queue, v, dijkstra_result->distance[v]);
}
};
int main() {
//srand(time(0));
srand(50);
heap *h = make_heap();
node **nodes = malloc(TESTSIZE * sizeof(node *));
for(int i = 0; i < TESTSIZE; i++) {
nodes[i] = insert(h, rand() % 100);
}
while (h->size > 0) {
make_dot(nodes, "after_inserts.dot");
getchar();
if (rand() % 2) {
printf("decrease_key\n");
decrease_key(h, nodes[rand() % TESTSIZE], rand() % 100);
} else {
printf("delete_min\n");
delete_min(h);
}
if (h->size > 0)
printf("heap size = %d and root key = %d\n", h->size, h->root->key);
}
free(nodes);
return 1;
}
void FibHeap<Key, Data, Compare>::erase (Node* node){
if (node==nullptr)
throw logic_error("There is no node to erase.");
decrease_key(node, root->key);
root = node;
Node* temp = extract_minimum();
delete temp;
}
void decrease_key(int x){
int p = parent(x);
vertex temp;
if(D[A[x].i][A[x].j] < D[A[p].i][A[p].j]){
temp = A[x];
A[x] = A[p];
A[p] = temp;
pointers[A[p].i][A[p].j] = p;
pointers[A[x].i][A[x].j] = x;
decrease_key(p);
}
}
void relax(int i, int j){
visited[i][j] = 1;
int dist;
if(i+1 < N && !visited[i+1][j]){
dist = Graph[i][j] == Graph[i+1][j] ? A : B;
dist+= D[i][j];
if(D[i+1][j] > dist){
D[i+1][j] = dist;
decrease_key(lookup[i+1][j]);
}
}
if(j+1 < N && !visited[i][j+1]){
dist = Graph[i][j] == Graph[i][j+1] ? A : B;
dist += D[i][j];
if(D[i][j+1] > dist){
D[i][j+1] = dist;
decrease_key(lookup[i][j+1]);
}
}
if(i-1 >= 0 && !visited[i-1][j]){
dist = Graph[i][j] == Graph[i-1][j] ? A : B;
dist += D[i][j];
if(D[i-1][j] > dist){
D[i-1][j] = dist;
decrease_key(lookup[i-1][j]);
}
}
if(j-1 >= 0 && !visited[i][j-1]){
dist = Graph[i][j] == Graph[i][j-1] ? A : B;
dist += D[i][j];
if(D[i][j-1] > dist){
D[i][j-1] = dist;
decrease_key(lookup[i][j-1]);
}
}
}
void decrease_key(int x){
int p = parent(x);
node temp;
if(p >= 0 && D[Q[x].i][Q[x].j] < D[Q[p].i][Q[p].j]){
temp = Q[x];
Q[x] = Q[p];
Q[p] = temp;
lookup[Q[p].i][Q[p].j] = p;
lookup[Q[x].i][Q[x].j] = x;
decrease_key(p);
}
}
void dijkstra(graph* g, int source, item** ph) {
int infinity = 100000000;
int vertices = g->node_count;
heap* h = make_heap();
for (int i = 0; i < vertices; i++) {
item* itm = (item*)malloc(sizeof(item));
if (i == source) {
itm->key = 0;
} else {
itm->key = infinity;
}
int* item_val = (int*)malloc(sizeof(int));
*item_val = i;
itm->value = item_val;
ph[i] = itm;
insert_item(itm, h);
}
item* val = find_min(h);
delete_min(h);
while (val != NULL) {
if (val->key == infinity) {
break;
}
int u_index = *((int*)(val->value));
g_node* n = g->nodes[u_index];
for (int v_index = 0; v_index < n->edge_count; v_index++) {
edge* e = n->edges[v_index];
int dist_between = e->distance;
item* v = ph[e->target->id];
int alt = val->key + dist_between;
if (alt < v->key) {
int delta = v->key - alt;
decrease_key(delta, v, h);
}
}
val = find_min(h);
delete_min(h);
}
}
void dijsktra(int i, int j){
visited[i][j] = 1;
int dist;
if(i+1 < M && !visited[i+1][j]){
dist = ddown(i,j);
dist += D[i][j];
if(D[i+1][j] > dist){
D[i+1][j] = dist;
decrease_key(pointers[i+1][j]);
}
}
if(j+1 < N && !visited[i][j+1]){
dist = dright(i,j);
dist += D[i][j];
if(D[i][j+1] > dist){
D[i][j+1] = dist;
decrease_key(pointers[i][j+1]);
}
}
if(i-1 >= 0 && !visited[i-1][j]){
dist = dtop(i,j);
dist += D[i][j];
if(D[i-1][j] > dist){
D[i-1][j] = dist;
decrease_key(pointers[i-1][j]);
}
}
if(j-1 >= 0 && !visited[i][j-1]){
dist = dleft(i,j);
dist += D[i][j];
if(D[i][j-1] > dist){
D[i][j-1] = dist;
decrease_key(pointers[i][j-1]);
}
}
}
void do_dijkstra(int source)
{
struct heap_t cur_min;
struct adj_t *cur_ver;
int index, new_weight;
/* All the initializations are already done */
while (len_heap > 0) {
/*
* Get the least and add it's values to
* weights array.
*/
cur_min = extract_min(heap, &len_heap);
index = cur_min.index;
weights[index].dist = cur_min.dist;
/*
* We expect the parents to already be set
* when we update the distances of each vertex
*/
/* Traverse through the elements adj list and
* update the weights in heap,and parents in the
* final array.
*/
for (cur_ver = list[index]; cur_ver != NULL; cur_ver= cur_ver->next) {
new_weight = weights[index].dist +
cur_ver->edge;
/* If the new route is shorter, update */
if (new_weight < weights[cur_ver->index].dist) {
/* Update parent in final array */
weights[cur_ver->index].parent = index;
/* Update dist in final array */
weights[cur_ver->index].dist = new_weight;
/* Update heap */
decrease_key(cur_ver->index, heap, len_heap, new_weight);
}
}
}
}
static void
decrease_key_test(void)
{
node_t *pool, *root, *node;
pool = pool_new(10);
root = make_node(alloc_node(pool), 1);
node = alloc_node(pool);
root = insert(root, node, 5);
root = insert(root, alloc_node(pool), 8);
root = insert(root, alloc_node(pool), 10);
root = insert(root, alloc_node(pool), 2);
root = insert(root, alloc_node(pool), 4);
root = insert(root, alloc_node(pool), 6);
root = insert(root, alloc_node(pool), 3);
decrease_key(root, node, 2);
pool_release(pool);
}
void dijkstra(struct Matrix_Graph *mat_graph, struct Point_Graph *poi_graph, \
int source)
{
struct HeapNode *minNode;
struct Heap heap;
struct Edge *edge;
initHeap(&heap, poi_graph, source);
heapSort(heap.heapNode, heap.heap_size, \
sizeof(struct HeapNode), compare);
while (heap.heap_size != 0) {
minNode = (struct HeapNode *)extractTop(heap.heapNode, \
&(heap.heap_size), sizeof(struct HeapNode), compare);
edge = poi_graph->node[minNode->to].start;
while (edge) {
decrease_key(mat_graph, &heap, source, minNode->to, edge);
edge = edge->next;
}
}
}
int main()
{
int *a;
int heap_size = 0;
char ch, buffer[512];
int key, index, min, size;
printf("Enter size of the priority queue: ");
fgets(buffer, 511, stdin);
sscanf(buffer, "%d", &size);
a = (int *) malloc(sizeof(int) * size);
do
{
printf("1> Enter i to insert a number in priority queue\n");
printf("2> Enter c to delete a number from priority queue\n");
printf("3> Enter d to decrease key\n");
printf("4> Enter g to see minimum value in priority queue\n");
printf("5> Enter m to retrieve maximum value in priority queue\n");
printf("6> Enter p to print the priority queue\n");
printf("7> Enter e to exit\n");
fgets(buffer, 511, stdin);
sscanf(buffer, "%c", &ch);
switch(ch)
{
case 'i':
if(heap_size < size)
{
printf("Enter the key to insert: ");
fgets(buffer, 511, stdin);
sscanf(buffer, "%d", &key);
insert(a, key, &heap_size);
printf("Key inserted successfully\n");
}
else
printf("Priority queue overflow\n");
break;
case 'c':
printf("Enter index to delete: ");
fgets(buffer, 511, stdin);
sscanf(buffer, "%d", &index);
if(delete(a, index, &heap_size) != -1)
printf("Key deleted successfully\n");
break;
case 'd':
printf("Enter index to be decrease: ");
fgets(buffer, 511, stdin);
sscanf(buffer, "%d", &index);
printf("Enter new key less than the previous: ");
fgets(buffer, 511, stdin);
sscanf(buffer, "%d", &key);
decrease_key(a, index, key, heap_size);
printf("Key decreased successfully\n");
break;
case 'g':
min = minimum(a, heap_size);
if(min != -1)
printf("Minimum value in priority queue = %d\n", min);
break;
case 'm':
min = extract_minimum(a, &heap_size);
if(min != -1)
printf("Minimum value in priority queue = %d\n", min);
break;
case 'p':
print_priority_queue(a, heap_size);
break;
case 'e':
printf("Exiting\n");
break;
default:
printf("Try again\n");
break;
}
}
while(ch != 'e');
return 1;
}
void dijkstra( int lift, int start )
{
int i, l, v, pre;
bool intree[MAXLIFTS][MAXFLOORS];
memset( intree, false, sizeof( intree ) );
distance[lift][start] = 0;
heap[1] = lift * 100 + start;
heap_size = 1;
l = lift, v = start;
while ( 1 )
{
if ( heap_size == 0 )
{
break;
}
extract_min( l, v );
intree[l][v] = true;
for ( i = 0; i < MAXFLOORS; ++i )
{
if ( a[l][v][i] != -1 )
{
if ( a[l][v][i] + distance[l][v] < distance[l][i] )
{
pre = distance[l][i];
distance[l][i] = a[l][v][i] + distance[l][v];
if ( pre == INF )
{
insert_heap( l * 100 + i );
}
else
{
decrease_key( l * 100 + i );
}
}
}
}
if ( v != 0 )
{
for ( i = 0; i < lifts; ++i )
{
if ( r[i][v] == true && distance[l][v] + 60 < distance[i][v] )
{
pre = distance[i][v];
distance[i][v] = distance[l][v] + 60;
if ( pre == INF )
{
insert_heap( i * 100 + v );
}
else
{
decrease_key( i * 100 + v );
}
}
}
}
}
}
int main()
{
int n,i,value=0; //number of nodes
scanf("%d",&n);
int a[n];
for(i=1;i<=n;i++){
scanf("%d",&a[i]);
}
char str[20];
scanf("%s",str);
while(strcmp(str,"exit")!=0){
if(strcmp(str,"parent")==0){
scanf("%d",&i);
value=parent(n,a,i);
if(value!=-1)
printf("%d",a[value]);
}
else if(strcmp(str,"left")==0){
scanf("%d",&i);
value=left(n,a,i);
if(value!=-1)
printf("%d",a[value]);
}
else if(strcmp(str,"right")==0){
scanf("%d",&i);
value=right(n,a,i);
if(value!=-1)
printf("%d",a[value]);
}
else if(strcmp(str,"minimum")==0){
value=minimum(n,a);
printf("%d",value);
}
else if(strcmp(str,"minimum")==0){
value=maximum(n,a);
printf("%d",value);
}
else if(strcmp(str,"leaf_nodes")==0){
leaf_nodes(n,a);
}
else if(strcmp(str,"buildheap_max")==0){
buildheap_max(n,a);
for(i=1;i<=n;i++){
printf("%d ",a[i]);
}
}
else if(strcmp(str,"heapsort")==0){
heapsort(n,a);
}
else if(strcmp(str,"extract_max")==0){
value=extract_max(n,a);
printf("%d",value);
}
else if(strcmp(str,"extract_min")==0){
value=extract_min(n,a);
printf("%d",value);
}
else if(strcmp(str,"increase_key")==0){
scanf("%d%d",&i,&value);
increase_key(n,a,i,value);
}
else if(strcmp(str,"decrease_key")==0){
scanf("%d%d",&i,&value);
decrease_key(n,a,i,value);
}
else if(strcmp(str,"buildheap_min")==0){
buildheap_min(n,a);
for(i=1;i<=n;i++){
printf("%d ",a[i]);
}
}
scanf("%s",str);
}
return 0;
}
