Why reserving space with std::vector runs slower? - c++

Question

I created the following function: given a m * n matrix of ones and zeros, it return how many square submatrices have all ones
For example
Input: matrix =
[
[0,1,1,1],
[1,1,1,1],
[0,1,1,1]
]
Output: 15
Explanation:
There are 10 squares of side 1.
There are 4 squares of side 2.
There is 1 square of side 3.
There is the program without reserving space.
int countSquares(vector<vector<int>>& matrix)
{
const size_t rows{ matrix.size() }, cols{ matrix[0].size() }; //Get the number of rows and colums
//Creating a dynamic programing matrix
vector<vector<int>> dp(rows, vector<int>(cols)); //Initializing m * n elements (this should be slower than reserving without initializing)
dp[0][0] = matrix[0][0];
size_t count = dp[0][0]; //counter of the squares
for (size_t i{ 1 }; i < rows; ++i)
count += dp[i][0] = matrix[i][0]; //Count squares in the first row and update the dynamic programming first row
for (size_t i{ 1 }; i < cols; ++i)
count += dp[0][i] = matrix[0][i]; //Count squares in the first colums and update the dynamic programming first column
//Count the rest of squares and update the dynamic programming matrix
for (size_t i{ 1 }; i < rows; ++i)
for (size_t j{ 1 }; j < cols; ++j)
count += dp[i][j] = matrix[i][j] ? min({ dp[i - 1][j], dp[i - 1][j - 1], dp[i][j - 1] }) + 1 : 0;
return count;
}
This is exactly the same program but without initialization the dynamic programming matrix at construction and reserving all space before use
int countSquares(vector<vector<int>>& matrix)
{
const size_t rows{ matrix.size() }, cols{ matrix[0].size() }; //Get the number of rows and colums
//Creating a dynamic programing matrix
vector<vector<int>> dp; //This time without default initialization
dp.reserve(rows);
dp.push_back(vector<int>());
dp.back().reserve(cols);
dp.back().push_back(matrix[0][0]);
size_t count = dp[0][0];
//Count squares in the first row and update the dynamic programming first row
for (size_t i{ 1 }; i < rows; ++i)
{
dp.push_back(vector<int>());
dp.back().reserve(cols);
dp.back().push_back(matrix[i][0]);
count += dp.back().back();
}
//Count squares in the first colums and update the dynamic programming first column
for (size_t i{ 1 }; i < cols; ++i)
{
dp[0].push_back(matrix[0][i]);
count += dp[0].back();
}
//Count the rest of squares and update the dynamic programming matrix
for (size_t i{ 1 }; i < rows; ++i)
for (size_t j{ 1 }; j < cols; ++j)
{
dp[i].push_back(matrix[i][j] ? min({ dp[i - 1][j], dp[i - 1][j - 1], dp[i][j - 1] }) + 1 : 0);
count += dp[i].back();
}
return count;
}
Why the first option runs 50% faster ??
Update 1: I timed my functions with std::chrono::system_clock::now() in visual studio (creating a really long matrix) and also using this page :
https://leetcode.com/problems/count-square-submatrices-with-all-ones/
the first option runs at 90% and the second one at 40%