向量分配是否比C ++中的原始数组花费更多时间？

Question

在解决有关 codechef 的问题时，我发现了一种模式，发现除了填充完整的 n * m 数组外，我还可以通过构建两个<尺寸> n * 3和3 * m 。因此，我这样写：

    // #define REP(i, s, e) for(int i = s; i < e; i++)
    // 1≤ N,M ≤10**5

    vector< vector<int> > dp(n.size()+1, vector<int>(m.size()+1));
    REP(i, 1, m.size()+1)
        dp[0][i] = m[i-1]-48;
    REP(i, 1, n.size()+1)
        dp[i][0] = n[i-1]-48;
    up = min(3, (int)(m.size()+1));
    REP(j, 1, up){
        REP(i,  1, n.size()+1)
            dp[i][j] = (dp[i-1][j]&dp[i][j-1])^1;
    }
    up = min(3, (int)(n.size()+1));
    REP(j, 1, up){
        REP(i, 1, m.size()+1)
            dp[j][i] = (dp[j-1][i]&dp[j][i-1])^1;
    }

我在三个测试案例中都获得了TLE，然后我像这样更改了它：

    // #define REP(i, s, e) for(int i = s; i < e; i++)
    // 1≤ N,M ≤10**5

    int rp[ns+1][3];
    int cp[3][ms+1];
    REP(i, 1, ms+1)
        cp[0][i] = m[i-1]-48;
    REP(i, 1, ns+1)
        rp[i][0] = n[i-1]-48;
    up = min(3, ms+1);
    REP(j, 1, up){
        rp[0][j] = cp[0][j];
        REP(i, 1, ns+1)
            rp[i][j] = (rp[i-1][j]&rp[i][j-1])^1;
    }
    up = min(3, ns+1);
    REP(j, 1, up){
        cp[j][0] = rp[j][0];
        REP(i, 1, ms+1)
            cp[j][i] = (cp[j-1][i]&cp[j][i-1])^1;
    }

假设访问元素和数组元素的时间相同，那么向量的分配和初始化时间有何不同？我无法使我的代码正常工作。