Is it faster to use push_back(x) or using an index (capacity)?

I learned 2 ways of inserting elements into a vector.

And I've been wondering which way is faster since I'm working with time limits.

Method 1:

int n;
cin>>n;
vector<int> v(n);
for(int i = 0;i<n;i++){
  cin>>v[i];
}

Method 2:

int n;
cin>>n;
vector<int> v;
for(int i = 0;i<n;i++){
  int x;
  cin>>x;
  v.push_back(x);
}

If you have a better method to suggest, it'd be appreciated!

Both have issues:
You should be using reserve(n)

int n;
cin >>  n;
vector<int> v;
v.reserve(n);
for(int i = 0; i < n; ++i){
    int x;
    cin >> x;
    v.emplace_back(x);
}

In the first version: Setting size.

Here you have the issue that you are constructing all the elements in the array. Now for integers this may be insignificant. But if we extend this to non integer types that have a constructor that needs to be called for each element and then you are using the assignment operator to copy over them.

The second option: push_back

Here you run into the risk of the underlying storage being reallocated (potentially multiple times). Each time you re-allocate you need to copy the data from the old storage to the new storage.

Again this hurts for integers but really hurts for types with constructors and destructors.

Prefer: emplace_back()

Rather than pushing where you need a fully constructed object. You can use emplace_back and pass in the objects used to construct the object. This allows the vector to construct the object in place. If you have simple integers or classes with effecient move semantics then not an issue but worth it as a general habit.

Method 1 is faster because it avoids the need for reallocation of the underlying array of the vector.

Between the two methods you mentioned, Method 1 is generally faster than Method 2 because it avoids the overhead of resizing the vector and moving elements when pushing back new elements. In Method 1, the vector is initialized with the required size upfront, so there is no need for reallocation or element shifting.

For small or moderate-sized vectors, the performance difference may not be significant enough to be a concern (When you deal with a greater scale, than you'll actually observe a difference in performance).

If you're working with a time limit and need to optimize the performance further, you can try a hybrid approach that combines the advantages of both methods. Here's an example:

    int n;
    cin >> n;
    vector<int> v;
    v.reserve(n); // Reserve memory for n elements
    for (int i = 0; i < n; i++) {
      int x;
      cin >> x;
      v.push_back(x);

}

In this approach, you use v.reserve(n) to preallocate memory for n elements in the vector, which can help avoid frequent reallocations during the push_back operations. This can provide some performance improvement over Method 2, especially for larger vectors!