Friday 31 October 2014

Dijkstra

spoj :

Easy Dijkstra Problem

solution 1
( faster )

#include <cstdio>
#include <queue>
#include <vector>

using namespace std;

#define INF 1000000;

struct edge {
int u;
int w;
};

bool operator <( edge a, edge b ) {
return a.w < b.w;
}

void dijkstra( vector< edge > graph[], int dist[], int N, int s ) {
dist[ s ] = 0;
priority_queue< edge > q;
q.push( ( edge ) { s, 0 } );

while ( !q.empty() ) {
edge p = q.top();
q.pop();
for ( int i = 0; i < graph[ p.u ].size(); ++i ) {
int u = p.u;
int v = graph[ p.u ][ i ].u;
if ( dist[ u ] + graph[ p.u ][ i ].w < dist[ v ] ) {
dist[ v ] = dist[ u ] + graph[ p.u ][ i ].w;
q.push( graph[ p.u ][ i ] );
}
}
}
}

int main() {
int t;
int N, E;
int S, T;
int u, v, w, i;
scanf( "%d", &t );
while ( t > 0 ) {
scanf( "%d%d", &N, &E );
vector< edge > graph[ N + 1 ];
int dist[ N + 1 ];
for ( i = 0; i < E; ++i ) {
scanf( "%d%d%d", &u, &v, &w );
graph[ u ].push_back( ( edge ) { v, w } );
}
for ( i = 0; i <= N; ++i ) {
dist[ i ] = INF;
}
scanf( "%d%d", &S, &T );
dijkstra( graph, dist, N, S );
if ( dist[ T ] != 1000000 ) {
printf( "%d\n", dist[ T ] );
}
else {
printf( "NO\n" );
}

--t;
}
return 0;
}






solution 2

#include <stdio.h>
#include <limits.h>
int a[1501][1501];
//int v[1500];
int oo;


int mind(int d[],int v[],int nv)
{
 int mini=INT_MAX,m;
 //printf("the value of nv is %d\n",nv);
 for(int i=1;i<=nv;i++)
 {  //printf("we are in loop\n");
     if(!v[i] && d[i]<mini)
        mini=d[i],m=i;
 }
// printf("minimum distance is of %dand index is %d\n",mini,m);
 return m;
}

int dj(int src,int tv)
{
    int v[1500],d[1500];// for keeping the finalization info and keeping the distanvle info

    for(int i=0;i<=tv;i++)
    {
        v[i]=0,d[i]=INT_MAX;
    }
    d[src]=0;
    for(int c=0;c<tv-1;c++)
    {
        int u=mind(d,v,tv);//sending the distance and the vertices array
       // printf("here it comes to dj");
        v[u]=1;
        /*if(u==2)
            break;*/
        for(int i=1;i<=tv;i++)
        {
            if(v[i]==0 && a[u][i] && d[u]!=INT_MAX && a[u][i]+d[u]<d[i]){
            // printf("\n************** it has updated a element %d with value %d*************\n",i,a[u][i]+d[u]);

                d[i]=a[u][i]+d[u];}
        }

    }
    if(d[oo]!=INT_MAX)
    printf("%d\n",d[oo]);
    else
    printf("NO\n");

}


int main()
{

int RKS=INT_MAX;
// printf("%d",RKS);
    int t,v,e,u,r,w,i,j;
    scanf("%d",&t);
    while(t--){for(i=0;i<1000;++i)
            for(j=0;j<1000;j++)
            a[i][j]=0;
    scanf("%d %d",&v,&e);
    for(int l=0;l<e;l++)
    {
        scanf("%d %d %d",&u,&r,&w);      a[u][r]=w;

    }
    //printf("it has scnanned all elements properly\n");
    int er ,fg;
    scanf("%d %d",&er,&fg);
    oo=fg;
    dj(er,v);

    }
    return 0;
}






Segment tree

Thursday 30 October 2014

Simple bfs and dfs

// N-> total nodes , graph[N][N] adjacency matrix

int bfs(int start,int end)
{
    list <int > q ;
    q.push_back(y);
    int visited[N],frontt;
    visited[start]=1;
    memset(vi,0,N*sizeof(int));
    
    while(!q.empty())
    {
          frontt=q.front();
          
          q.pop_front();
          for(int i=0;i<N;i++)
          { 
                   if(graph[frontt][i] && !visited[i])
                   {
                         visited[i]=1;
                         //graph[srart][i]=1; in case there are many queries wand we want to speed up , bcz we know there is path between start and i
                        if(i==end)
                                return 1;
                        q.push_back(i);
                  }
           }
      }
return 0;
}







int dfs(int start,int end)
{
    list <int > st ;
    st.push_back(y);
    int visited[N],Top;
    visited[start]=1;
    memset(vi,0,N*sizeof(int));
    
    while(!st.empty())
    {
          Top=st.back();
          
          st.pop_back();
          for(int i=0;i<N;i++)
          { 
                   if(graph[Top][i] && !visited[i])
                   {
                         visited[i]=1;
                         //graph[srart][i]=1; in case there are many queries wand we want to speed up , bcz we know there is path between start and i
                        if(i==end)
                                return 1;
                        st.push_back(i);
                  }
           }
      }
return 0;
}



Some tweaks for adjacency  list

If there are N nodes
Input form
N->total number of nodes
then N lines with x and as first element (showing its connected to x elements)


scanf("%d",&N);
vector <int>  graph [N];
for(int i=0;i<N;i++)
{
    scanf("%d",&x);
    for(int j=0;j<N;i++)
    {
        scanf("%d",&e);
        v[j].push_back(e);
    }
}


Code modifications in dfs (similar for bfs)


int dfs(int start,int end)
{
    list <int > st ;
    st.push_back(y);
    int visited[N],Top;
    visited[start]=1;
    memset(vi,0,N*sizeof(int));
    
    while(!st.empty())
    {
          Top=st.back();
          
          st.pop_back();
          vector <int>:: iterator iii;

          for(int iii=graph[Top].begin();iii!=graph[Top].end();iii++)
          { 
                   if(graph[Top][i] && !visited[i])
                   {
                         visited[*iii]=1;
                         //graph[srart][*iii]=1; in case there are many queries wand we want to speed up , bcz we know there is path between start and i
                        if(*iii==end)
                                return 1;
                        st.push_back(*iii);
                  }
           }
      }
return 0;
}