Can't resolve Segmentation Fault core dump error

Question

I am writing a program that implements Dijkstra algorithm for graphs and I ran into this: Segmentation fault (core dump). I have narrowed down the line (I have marked the line where the error is occurring) that is causing me the error, and then I used both GDB and Valgrind on my program, but all those told me was what line the error was occurring on, something I already new. Any help that y'all can give would me awesome! Thanks in advance!

    ////HERE'S MY MAIN/////
#include "Vertex.h"
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <fstream>
using namespace std;
void Dijkstra(vector<Vertex> & V);


///overload the less than operator in order to use the stl sort for vector
///print out the path for each vertex

int main()
{

    /////READ ALL THE STUFF INTO THE GRAPH////
    ifstream file;
    file.open("graph.txt");
    cout << "Opening file..." << endl;
    if(!file)
    {
        cout << "System failed to open file.";
    }
    else
    {
        cout << "File successfully opened" << endl;
    }

    int numVertices;
    int numEdges;
    int adjacentVertex;
    int weight;

    file >> numVertices;
    cout << "The number of vertices that are being read into the graph from the file: " << numVertices;
    cout << endl;
    vector<Vertex*> vertices;
    //vector<Vertex> vertices(numVertices + 1);

    for(int i=1;i<=numVertices;i++)
    {   
        file >> numEdges;
        cout << "At vertex " << i << " the number of edges is " << numEdges << endl;
        cout << "Hello" << endl;
        vertices[i] = new Vertex(); ////THIS IS WHERE THE ERROR IS
        cout << "World" << endl;
        //Vertex newVertex;

        //Using the i counter variable in the outer for loop to identify
        //the what vertex what are currently looking at in order to read in the correct adjacent vertex and weight
        vertices[i] -> setVertexNum(i);
        //newVertex.setVertexNum(i);

        for(int j=1;j<=numEdges;j++)
        {
            file >> adjacentVertex;
            cout << "The adjacent vertex is: " << adjacentVertex << endl;


            file >> weight;
            cout << "The weight is: " <<  weight << endl;
            cout << endl;

            vertices[i]->setAdjacentVertex(adjacentVertex, weight);
        }
        vertices.push_back(vertices[i]);
    }
    file.close();


/*
    for(int i=0;i<vertices.size();i++)
    {
        cout << "V" << i <<":  ";
        cout << endl;
        for(int j=0;j<vertices[i].getAdjacentVertices().size();j++)
        {
            cout << "V" << vertices[i].getAdjacentVertices()[j].getAdjVertex() << " " << vertices[i].getAdjacentVertices()[j].getWeight() << endl;
        }
    }
*/






    //CALL THE SHORTEST PATH FUNCTION ON THE GRAPH/////



}


    ////HERE'S MY VERTEX CLASS/////
#include "Edge.h"
#include <vector>
#include <climits>
#include <fstream>
using namespace std;
class Vertex
{
    private:
        int vertexNum; //number of the vertex for identification purposes
        int degree;
        bool known;
        vector<Edge> adjacentVertices; //vector of vertices that are adjacent to the vertex we are currently looking at
        int dv; //distance 
        int pv; //previous vertex
        Vertex *vertex;
    public:
        Vertex()
        {
            dv = INT_MAX;
            known = false;
        }

        void setKnown(bool Known)
        {
            known = Known;
        }

        bool getKnown()
        {
            return known;
        }

        void setVertexNum(int VertexNum)
        {
            vertexNum = VertexNum;
        }

        void setDegree(int Degree)
        {
            degree = Degree;
        }

        vector<Edge> & getAdjacentVertices()
        {
            return adjacentVertices;
        }

        int getVertexNum()
        {
            return vertexNum;
        }

        int getDegree()
        {
            return degree;
        }

        int getDV() const 
        {
            return dv;
        }

        void setAdjacentVertex(int AdjacentVertex, int Weight)
        {
            Edge newEdge;
            newEdge.setWeight(Weight);
            newEdge.setAdjVertex(AdjacentVertex);
            adjacentVertices.push_back(newEdge);
        }

        friend ostream & operator <<(ostream & outstream, Vertex & vertex)
        {
            outstream << vertex.vertexNum << endl;
            outstream << vertex.degree << endl;
            outstream << vertex.known << endl;
            vector<Edge> E = vertex.getAdjacentVertices();
            for(int x=0;x<E.size();x++)
            {
                outstream << E[x].getAdjVertex() << endl;
                outstream << E[x].getWeight() << endl;
            }
            return outstream;
        }

        friend bool operator < (const Vertex & v1, const Vertex & v2);

        void printVertex()
        {

        }


};

Answer 1

So you must replace the line

vector <Vertex*> vertices;

By

vector<Vertex*> vertices(numVertices);

Answer 2

When initializing elements of a vector, you should use the push_back method.

So change:

vertices[i] = new Vertex();

to:

vertices.push_back( new Vertex() );

---

Of course, there are still other problems in your code. One hint I can give you is to iterate your for loops starting with 0 and using < instead of <= in the predicate.