声明向量 <vector<pair<int, int> &gt;具有特定大小和插入元素？

Question

I want to represent a graph data structure and I am using vector of vector of pairs in c++ stl. Example:

vector<vector<pair<int, int>>> G;

Now I can do, G[u].push_back(make_pair(v, w));

The problem: I need to specify this data structure a size. If I don't I get a segmentation fault when I try to push elements to this data structure. If I do give a size like:

vector< vector<ii> > adj(10, std::vector<ii>(10));

The problem now is the first 10 pairs of vector are initialized to zero. If I push back an element now, it gets pushed to the 11th position. The first 10 being 0s. I don't want to do this. I want to insert elements in the order I need. A snippet to give you an idea about what I am trying to do:

 for(int i=0;i<E-1;i++)
        {
            cin >> p >> q >> l;
            adj[p].push_back(ii(q, l));
            adj[q].push_back(ii(p, l));
        } 

The output for the above would be 10 zeros followed by the values pushed. Any way to get around this?

Answer 1

Somehow you are contradicting yourself: When creating a vector you can either pass the number of elements in the constructor or you start with an empty vector and push the elements you want to have in the vector. If you start with size 10 and then push 10 more there are 20. They way around is to either use

std::vector<T> vect(10);
for (size_t i=0;i<10;i++){
    vect[i] = whatever;
}

or

std::vector<T> vect;
for (size_t i=0;i<10;i++){
     vect.push_back(whatever);
}

Maybe you are confusing the size of the vector with its capacity. This you can set via:

std::vector<T> vect;
vect.reserve(10);
for (size_t i=0;i<10;i++){
     vect.push_back(whatever);
}

For your vector of vectors you have to make sure, that there is a vector at that index before you start pushing elements into it:

std::vector<std::vector<T>> mat;
for (size_t i=0;i<10;i++){
    mat.push_back(std::vector<T>());
    for (size_t j=0;j<10;j++){
        mat[i].push_back(whatever);
    }
}

Answer 2

If you know in advance your data structure size, you can declare it using the proper constructor:

vector<vector<pair<int,int>>> G(10);

While the program is reading data to fill that structure, it can either check if the inputted indeces are out of bounds or resize the vector accordingly. For example this test program:

#include <iostream>
#include <vector>

using std::vector;
using std::pair;
using std::cout;
using std::cin;

int main() {

    vector<vector<pair<int,int>>> G(5);
    //  insufficient initial size  ^^^

    int p, q, l;
    while ( cin >> p >> q >> l )
    {
        // resize the vector to avoid index out of bound
        int m = std::max(p, q) + 1;
        if ( m > G.size() )
            G.resize(m);

        G[p].push_back(std::make_pair(q, l));
        G[q].push_back(std::make_pair(p, l));
    } 

    for( int r = 0; r < G.size(); ++r )
    {
        for ( int c = 0; c < G[r].size(); ++c ) {
            cout << r << ", " << c << ": " << G[r][c].first << ' ' << G[r][c].second << '\n';
        }
    } 

    return 0;
}

With an input like:

1 2 3
4 5 6
7 8 9
8 7 6
5 4 3
2 1 0

Gives this output:

1, 0: 2 3
1, 1: 2 0
2, 0: 1 3
2, 1: 1 0
4, 0: 5 6
4, 1: 5 3
5, 0: 4 6
5, 1: 4 3
7, 0: 8 9
7, 1: 8 6
8, 0: 7 9
8, 1: 7 6

Answer 3

segmentation fault is because of that u >= G.size() and is not by the push_back().

You need first resize you G to the number of the vertexes of the graph, after that, you can do your push back as long as u < G.size()

The corrected code should like this:

vector< vector<ii> > adj(10 /* number of vertexes in the graph */);
for (int i=0; i < E-1; i++)
{
    cin >> p >> q >> l;
    // make sure both p < adj.size() and q < adj.size()
    adj[p].push_back(ii(q, l));
    adj[q].push_back(ii(p, l));
}