Convert 1D Array Into 2D Array — Editorial

Opening the reading…

Intuitionthe dimensions determine both feasibility and placement

A matrix with m rows and n columns contains exactly m * n cells. The 1D array can fill that matrix using every element exactly once only when its length equals that cell count. If the counts differ, some cells would be empty or some input values would have nowhere to go, so the correct result is an empty 2D array.

When the sizes match, fill the matrix row by row. Row i starts after the i previous rows, so its first value is at index i * n in original. Moving across column j advances j more positions, giving the direct mapping original[i * n + j]. This preserves the required order and avoids maintaining a separate input pointer.

Approachcheck the shape first, then copy by row and column

Compare original.size() with m * n and return an empty 2D array when they differ, because no exact m by n arrangement can use every input element once otherwise.

Allocate an m by n result filled with default integers, because every destination cell must exist before the nested loops assign its value.

Loop through each row i from 0 to m - 1, because a row-major conversion must finish one complete row before starting the next.

Loop through each column j from 0 to n - 1 inside the current row, because these are exactly the n positions that belong to row i.

Assign ans[i][j] from original[i * n + j], because i * n skips the earlier rows and j selects the position within the current row.

Return ans after all cells are assigned, because the size check guarantees that every input value has been copied exactly once.

Complexitythe output is required storage, not working memory

MEASURE	BOUND	WHY
Time	O(m * n)	The nested loops visit each of the m * n destination cells once, and each visit performs one indexed read and one assignment. The size check is constant work, so it does not change the bound.
Space	O(1) extra	The returned matrix contains m * n values and is required output, so it is excluded from the extra-space bound. Apart from that result, the algorithm keeps only loop indices and references; the bound remains O(1) for every input shape.

Here m is the number of rows, n is the number of columns, and L is original.length; the valid case has L = m * n.

Annotated solutionC++ · nested row-major loops · complete judge-ready class

CPPCheck the total cell count, then copy each row-major input position into its matrix cell.

#include <vector>

using namespace std;

class Solution {
public:
    vector<vector<int>> construct2DArray(vector<int>& original, int m, int n) {
        if (original.size() != static_cast<size_t>(m) * n) {
            return {};
        }

        vector<vector<int>> ans(m, vector<int>(n));
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                ans[i][j] = original[i * n + j];
            }
        }

        return ans;
    }
};

The single-index alternativea different arrangement, not an optimisation

You can also walk through the input with one index p and derive the destination coordinates from p. The row is p / n and the column is p % n, so each input value is placed once without nested loops. This has the same O(m * n) time and O(1) extra space as the row-and-column version; it is simply a compact alternative when you prefer one linear traversal.

CPPUse division and remainder to turn one linear index into its row and column.

#include <vector>

using namespace std;

class Solution {
public:
    vector<vector<int>> construct2DArray(vector<int>& original, int m, int n) {
        if (original.size() != static_cast<size_t>(m) * n) {
            return {};
        }

        vector<vector<int>> ans(m, vector<int>(n));
        for (int p = 0; p < static_cast<int>(original.size()); ++p) {
            ans[p / n][p % n] = original[p];
        }

        return ans;
    }
};