In multidimensional arrays, can you use variable arrays or their names instead of the actual data?
Two-dimensional arrays come in two &quot;flavours&quot;. Actually, multi-dimensional arrays are possible in any combination of these.

All elements in a rectangular grid, at least from the abstract view of the programming language;
A one-dimensional array of one-dimensional arrays.

If you declare:
byte array[n][m];

then you have reserved space for &quot;n times m&quot; bytes. From the programmer's view it is a rectangular grid, actually all bytes are in sequence in a one-dimensional array. This is because the memory of our computers are commonly organized as a big one-dimensional array of bytes. The compiler generates the correct calculation for the offset into this array, multiplying one index with the size of the width (or length, depending on your mental model) and adding the other index.
You can initialize such an array with the nested set of curly braces like this:
byte array[n][m] = {
    { /* ... */ },
    /* ... */
};

But you cannot initialize it as you show.
Otherwise, if you declare
byte* array[n];

then you have reseved space for &quot;n&quot; pointers to bytes, that is a one-dimensional array of pointers. Each of these pointers can point to a different or the same one-dimensional array of bytes, or to no array at all if it's nullptr.
Now you can set up the array as you like:
byte arrayX[m1] = { /* ... */ };
byte arrayY[m2] = { /* ... */ };

byte* array[n] = { arrayX, arrayY, /* ... */ };

The arrays arrayX and arrayY (and any further) don't need to have the same length. Each can have its own length. But beware, you need to trace the length somehow to avoid out-of-bounds accesses. And of course, you need to check or be sure that a pointer is not null before dereferencing it.
In both cases you can access a single element with:
byte element = array[i][j];
array[k][l] = 23;

This is because the syntax with the brackets is equivalent to the dereferencing operator:
x[y] == *(x + y)

Note 1: Since Arduinos are programmed in C++, there is another option. You can use references instead of pointers. Because it is really hard to create a null reference, some see it as a safety measure against null pointers.
Note 2: Again, since Arduinos are programmed in C++, you can implement an own class that provides the operator[]. With this option you can do any magical stuff, but it might break the user's expectation. Be careful if you go that route.