Ошибка "Segmentation fault" при вызове метода erase() контейнера vector

#include <iostream>
#include <vector>
#include <forward_list>
 
using namespace std;
 
struct Node
{
    int weight;
    int vertex;
};
 
int main()
{
    vector<forward_list<Node> > g;
    int nvertex, nedges;
    cin >> nvertex >> nedges;
    g.reserve(nvertex);
    int nv1, nv2, edgeWeight;
    Node *inode = new Node;
    // ввожу граф
    for(int i = 0; i < nedges; ++i)
    {
        cin >> nv1 >> nv2 >> edgeWeight;
        // пусть вершины с 0 нумеруются
        --nv1;
        --nv2;
        bool isEdgeUnique = true;
        // проверка ребра на уникальность
        // (если ребро (nv1, nv2) или (nv2, nv1) уже есть в графе g и его вес больше, чем edgeWeight, то меняем его вес на edgeWeight 
        for(forward_list<Node>::iterator itv1 = g[nv1].begin(); itv1 != g[nv1].end(); ++itv1)
        {
            if(itv1->vertex == nv2)
            {
                isEdgeUnique = false;
                if(edgeWeight < itv1->weight)
                {
                    itv1->weight = edgeWeight;
                    for(forward_list<Node>::iterator itv2 = g[nv2].begin(); itv2 != g[nv2].end(); ++itv2)
                        if(itv2->vertex == nv1)
                            itv2->weight = edgeWeight;
                }
            }
        }
        if(isEdgeUnique) // если ребро уникально
        {
            inode->vertex = nv2;
            inode->weight = edgeWeight;
            g[nv1].push_front(*inode);
            inode->vertex = nv1;
            if(nv1 != nv2)
                g[nv2].push_front(*inode);
        }
    }
    delete inode;
    inode = 0;
    
    // вывожу граф
    cout << endl;
    for(int j = 0; j < nvertex; ++j)
    {
        cout << j << ":";
        for(forward_list<Node>::iterator it = g[j].begin(); it != g[j].end(); ++it)
            cout << " " << it->vertex;
        cout << endl;
    }
    
    // пытаюсь коряво убрать изолированные вершины
    vector<forward_list<Node> >::iterator bi = g.begin();
    for(int i = 0; i < nvertex; ++i)
    {
        if(g[i].empty())
        {
            advance(bi, i);
            g.erase(bi);
           --nvertex;
        }
    }
    
    // вывожу граф
    cout << endl;
    for(int j = 0; j < nvertex; ++j)
    {
        cout << j << ":";
        for(forward_list<Node>::iterator it = g[j].begin(); it != g[j].end(); ++it)
            cout << " " << it->vertex;
        cout << endl;
    }
    return 0;
}

// пытаюсь коряво убрать изолированные вершины
    vector<forward_list<Node> >::iterator bi = g.begin();
    for(int i = 0; i < nvertex; ++i)
    {
        if(g[i].empty())
        {
            advance(bi, i);
            g.erase(bi);
           --nvertex;
        }
    }

for(auto i = g.begin(); i != g.end(); ++i)
{
    if(g[j].empty())
        g.erase(i);
    ++j;
}

// пытаюсь коряво убрать изолированные вершины
    vector<forward_list<Node> >::iterator bi = g.begin();
    for(int i = 0; i < nvertex; ++i)
    {
        if(g[i].empty())
        {
            advance(bi, i);
            g.erase(bi);
           --nvertex;
        }
    }

#include <iostream>
#include <vector>
#include <algorithm>
#include <forward_list>
#include <limits>
 
using namespace std;
 
struct Node
{
    int weight;
    int vertex;
};
 
int main()
{
    vector<forward_list<Node> > g;
    int nvertex, nedges, nFlourWarehouse;
    cin >> nvertex >> nedges >> nFlourWarehouse;
    vector<int> flourWarehouse(nFlourWarehouse);
    g.reserve(nvertex);
    int nv1, nv2, edgeWeight;
    Node *inode = new Node;
    for(int i = 0; i < nedges; i++)
    {
        cin >> nv1 >> nv2 >> edgeWeight;
        --nv1;
        --nv2;
        bool isVertexUnique = true;
        for(forward_list<Node>::iterator itv1 = g[nv1].begin(); itv1 != g[nv1].end(); ++itv1)
        {
            if(itv1->vertex == nv2)
            {
                isVertexUnique = false;
                if(edgeWeight < itv1->weight)
                {
                    itv1->weight = edgeWeight;
                    for(forward_list<Node>::iterator itv2 = g[nv2].begin(); itv2 != g[nv2].end(); ++itv2)
                        if(itv2->vertex == nv1)
                            itv2->weight = edgeWeight;
                }
            }
        }
        if(isVertexUnique)
        {
            inode->vertex = nv2;
            inode->weight = edgeWeight;
            g[nv1].push_front(*inode);
            inode->vertex = nv1;
            if(nv1 != nv2)
                g[nv2].push_front(*inode);
        }
    }
    delete inode;
    inode = 0;
    
    // уберем изолированные вершины
    vector<forward_list<Node> >::iterator bi = g.begin();
    for(int i = 0; i < nvertex; ++i)
    {
        if(g[i].empty())
        {
            advance(bi, i);
            g.erase(bi);
           --nvertex;
        }
    }
    
    for(int j = 0; j < nvertex; j++)
    {
        cout << j << ":";
        for(forward_list<Node>::iterator it = g[j].begin(); it != g[j].end(); ++it)
            cout << " " << it->vertex << ":" << it->weight;
        cout << endl;
    }
    
    int numHouse;
    for(int ihouse = 0; ihouse < nFlourWarehouse; ihouse++)
    {
        cin >> numHouse;
        --numHouse;
        flourWarehouse[ihouse] = numHouse;
    }
    
    vector<int> mins;
    for(int indHouse = 0; indHouse < nFlourWarehouse; indHouse++)
    {
        int dist;
        int v = flourWarehouse[indHouse];
        bool *intree = new bool [nvertex];
        for(int i = 0; i < nvertex; i++)
            intree[i] = false;
        vector<int> weights(nvertex, numeric_limits<int>::max());
        weights[v] = 0;
        vector<int> parent(nvertex, -1);
        while(intree[v] == false)
        {
            intree[v] = true;
            for(forward_list<Node>::iterator ind = g[v].begin(); ind != g[v].end(); ++ind)
            {
                if(weights[v] + ind->weight < weights[ind->vertex])
                {
                    weights[ind->vertex] = weights[v] + ind->weight;
                    parent[ind->vertex] = v;
                }
            }
            v = 1;
            dist = numeric_limits<int>::max();
            for(int j = 0; j < nvertex; j++)
            {
                if((intree[j] == false) && (weights[j] < dist))
                {
                    dist = weights[j];
                    v = j;
                }
            }
        }
        delete [] intree;
        intree = 0;
        
        for(int i = 0; i < nFlourWarehouse; ++i)
        {
            vector<int>::iterator it = weights.begin();
            it += flourWarehouse[i];
            weights.erase(it);
        }
        
        vector<int>::iterator begZero = remove(weights.begin(), weights.end(), 0);
        weights.erase(begZero, weights.end());
        
        int minElem = weights[0];
        for(int j = 1; j < nvertex; ++j)
            if(weights[j] < minElem)
                minElem = weights[j];
        
        mins.push_back(minElem);
    }
    
    vector<int>::iterator sum = min_element(mins.begin(), mins.end());
    cout << *sum;
    
    return 0;
}