The accessing is pretty much the same, but the fundamental representation is quite different, owing mainly to the fact that a std::vector allocates memory on the heap and not the stack.

Suppose we are not in the global scope. Then std::vector<int> a[N] is an array of $$$N$$$ vector objects stored on the stack, with the contents of each vector being stored on the heap, while std::vector<std::vector<int>> a(N) is an object with $$$O(1)$$$ memory being stored on the stack, with $$$O(N)$$$ vector objects stored on the heap (as pointers to those objects) and those objects themselves being stored on the heap. Using the first one may give an error about not being able to allocate that amount of memory on stack, while a heap usually has much more memory and hence the second one is more preferable.

If it is declared in the global scope, then a similar thing holds, however instead of the stack, the array resides in the data segment (which gives more memory than the stack), and not in the stack, so that's why it's sometimes advised to use global variables in competitive programming, even though they're generally frowned upon (very rightfully, too) in software development.

However, note that there is literally zero overhead for using a vector as compared to an array (provided you use std::vector::push_back reasonably to avoid multiple reallocations, possibly using std::vector::reserve), so it's always advisable to use more modern language features, and keeping your code modular to make it compact, easy to reason about and less prone to errors (for instance, forgetting to clear data structures etc). Something more on the performance of std::vector.