Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Single Source Shortest Path II

For a given weighted graph $G = (V, E)$, find the shortest path from a source to each vertex. For each vertex $u$, print the total weight of edges on the shortest path from vertex $0$ to $u$.

Input

In the first line, an integer $n$ denoting the number of vertices in $G$ is given. In the following $n$ lines, adjacency lists for each vertex $u$ are respectively given in the following format:

$u$ $k$ $v_1$ $c_1$ $v_2$ $c_2$ ... $v_k$ $c_k$

Vertices in $G$ are named with IDs $0, 1, ..., n-1$. $u$ is ID of the target vertex and $k$ denotes its degree. $v_i (i = 1, 2, ... k)$ denote IDs of vertices adjacent to $u$ and $c_i$ denotes the weight of a directed edge connecting $u$ and $v_i$ (from $u$ to $v_i$).

Output

For each vertex, print its ID and the distance separated by a space character in a line respectively. Print in order of vertex IDs.

Constraints

$1 \leq n \leq 10,000$

$0 \leq c_i \leq 100,000$

$|E| < 500,000$

All vertices are reachable from vertex $0$

Sample Input 1

5
0 3 2 3 3 1 1 2
1 2 0 2 3 4
2 3 0 3 3 1 4 1
3 4 2 1 0 1 1 4 4 3
4 2 2 1 3 3

Sample Output 1

0 0
1 2
2 2
3 1
4 3

Reference

Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. The MIT Press.

Solution in C (judge verdict: Accepted)

#include<stdio.h>
#include<stdlib.h>
#define WHITE 0
#define GRAY 1
#define BLACK 2
#define INF 1000000

struct node{
  struct node *next;
  int v;
  int weight;
};
typedef struct node *Node;

int d[10001];
int color[10001];
int pi[10001];
int n;
Node head[10001];
void make1node(int,int,int);
int parent(int);
int left(int);
int right(int);
void minheapify(int *,int);
void buildminheap(int*);
void swap(int *,int *);
int heapextractmin(int *);
int H;

int main(){
  int i,j,mincost,u,sum=0,k,v,r,c;
  int A[10001];
  Node ni;
  
  scanf("%d",&n);
  H=n;
  
  for(i=0;i<10001;i++){
   
    head[i]=malloc(sizeof(struct node));
    head[i]->v=INF;
    head[i]->weight=INF;
    head[i]->next=NULL;
   
  }
    
  
    
  
  for(i=1;i<=n;i++){
    d[i]=INF;
    color[i]=WHITE;
    pi[i]=-1;
    scanf("%d%d",&r,&k);
    for(j=0;j<k;j++){
      scanf("%d",&v);
      /* printf("r=%d,v=%d\n",r,v);*/
      scanf("%d",&c);
      make1node(r,v,c);
    }
  }
  /* for(i=0;i<n;i++){
  for(ni=head[i]->next;ni!=NULL;ni=ni->next){
    printf("%d %d\n",ni->v,ni->weight);
  }
  printf("--\n");
  }*/
  /*for(i=0;i<n;i++){
    for(j=0;j<n;j++){
      printf("%d",A[i][j]);
    }
    printf("\n");
    }*/
d[0]=0;
  while(1){
    mincost=INF;
    for(i=0;i<n;i++){
      /*   for(ni=head[i]->next;ni!=NULL;ni=ni->next){*/
	  if(color[i]!=BLACK && d[i]<mincost){
	    mincost=d[i];
           u=i;
	  }
	 
	  /* }*/
    }
    
	if(mincost==INF) break;
	color[u]=BLACK;
	  for(ni=head[u]->next;ni!=NULL;ni=ni->next){
	    /* printf("ni->v=%d\nni->w=%d\n",ni->v,ni->weight);*/
	    if(color[ni->v]!=BLACK &&d[u]+ni->weight<d[ni->v]){
	      pi[ni->v]=u;
	      d[ni->v]=ni->weight+d[u];
	      /*  printf("d[%d]=%d\n",ni->v,d[ni->v]);*/
	      }
	  }
  }
  
    for(i=0;i<n;i++){
       printf("%d %d\n",i,d[i]);  
  }
  
    
  return 0; 
}
void make1node(int r,int a,int b){
  Node n;
  n=(Node)malloc(sizeof(struct node));
  n->v=a;
  n->weight=b;
  n->next=head[r]->next;
  head[r]->next=n;
  
}
void swap(int *p1,int *p2){
  int temp;
  temp=*p1;
  *p1=*p2;
  *p2=temp;
}
int parent(int i){
return i/2;
}
int left(int i){
  return 2*i;
}
int right(int i){
  return 2*i+1;
}
void minheapify(int A[],int i){
  int l,r,smallest;
  l=left(i);
  r=right(i);
  if(l<=H &&A[l]<A[i])smallest=l;
  else smallest=i;
  if(r<=H&&A[r]<A[smallest])smallest=r;

  if(smallest!=i){
    swap(&A[i],&A[smallest]);
    minheapify(A,smallest);
  }
}
void buildminheap(int A[]){
  int i;
  for(i=H/2;i>=1;i--){
    minheapify(A,i);
  }
}
int heapextractmin(int A[]){
  int min;
  if(H<1){
    printf("error\n");
      exit(0);
  }
  min=A[1];
  A[1]=A[H];
  H--;
  minheapify(A,1);
  return min;
}