Question

This is the dijkstra structure i am using :(however the MAXV(which is maximum number of vertices is maximum at 500 and every time i try to change it to something more than this it generates and error when running )

-I want to use this way to represent a graph with 10000 vertices, does anyone know how to optimize it ?

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
using namespace std;
#define MAXV 500
#define MAXINT 99999
typedef struct{
        int next;
        int weight;
}edge;
typedef struct{
        edge edges[MAXV][MAXV];
        int nedges;
        int nvertices;
        int ndegree[MAXV];
}graph;

and this is my dijkstra code:

int dijkstra(graph *g,int start,int end){
    int distance[MAXV];
    bool intree[MAXV];
    for(int i=0;i<=MAXV;++i){
            intree[i]=false;
            distance[i]=MAXINT;
    }
    int v=start;
    distance[v]=0;
    while(intree[v]==false){
           intree[v]=true;
           for(int i=0;i<g->ndegree[v];++i){
                   int cand=g->edges[v][i].next;
                   int weight=g->edges[v][i].weight;
                   if(distance[cand] > distance[v]+weight){
                           distance[cand] = distance[v]+weight;
                   }
           }
           int dist=MAXINT;
           for(int i=0;i<g->nvertices;++i){
                   if((intree[i]==false) && (dist > distance[i])){
                           dist=distance[i];
                            v=i;
                   }
           }
    }
    return distance[end];
}

Answer 1

Use adjacency lists for storing the graph. Right now you’re using an adjacency matrix, which means that you allocate MAXV*MAXV*sizeof(edge) bytes just for that. That’s a lot when MAXV is 10 000, so you’re probably getting a segmentation fault. Switching to adjacency lists will get rid of the error.

However, even with adjacency lists, the Dijkstra algorithm you have right now is O(n^2) where n is the number of nodes. That’s still a lot for 10 000 nodes. Consider implementing Dijkstra with heaps (also here) if you have to support this many nodes.