使用 arrays 和向量之间的时间复杂度差异

Question

for the question finding nth ugly number(whose prime factorisation only contains 2,3,5 ) (1 included).when i used the below solution using vectors the time taken is >1.013 which showed TLE but when i used arrays the time taken is 0.9 which got accepted? can anyone explain why this is happening?

#include <bits/stdc++.h>
using namespace std;
#define llb long long int
int main() {
    int t;
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        llb ugly[n]; // To store ugly numbers 
        llb i2 = 0, i3 = 0, i5 = 0; 
        llb next_multiple_of_2 = 2; 
        llb next_multiple_of_3 = 3; 
        llb next_multiple_of_5 = 5; 
        llb next_ugly_no = 1; 
      
        ugly[0] = 1; 
        for (int i=1; i<n; i++) 
        { 
           next_ugly_no = min(next_multiple_of_2, 
                               min(next_multiple_of_3, 
                                   next_multiple_of_5)); 
           ugly[i] = next_ugly_no; 
           if (next_ugly_no == next_multiple_of_2) 
           { 
               i2 = i2+1; 
               next_multiple_of_2 = ugly[i2]*2; 
           } 
           if (next_ugly_no == next_multiple_of_3) 
           { 
               i3 = i3+1; 
               next_multiple_of_3 = ugly[i3]*3; 
           } 
           if (next_ugly_no == next_multiple_of_5) 
           { 
               i5 = i5+1; 
               next_multiple_of_5 = ugly[i5]*5; 
           } 
        } /*End of for loop (i=1; i<n; i++) */
        cout<<next_ugly_no<<endl;
    }
    return 0;
}

Answer 1

The performance should be virtually identical if you write the code correctly.

What is likely happening (since you don't show the other case) is that in the std::vector case you are re-allocating many times, probably by re-creating the object on every outer loop iteration. If you re-use the object, then you should see very similar performance.

---

Side note:

llb ugly[n]; // To store ugly numbers

This is non-standard C++: a Variable Length Array (VLA).